From 25a0db9b1eb2345fd48a9d7fafeb905748b09ace Mon Sep 17 00:00:00 2001 From: KoCoder Date: Tue, 12 Aug 2025 18:10:43 +0200 Subject: [PATCH] Initial commit. --- .air.toml | 52 +++ go.mod | 43 ++ go.sum | 116 ++++++ main.go | 113 ++++++ model/ansprechpartner.go | 29 ++ model/dokument.go | 7 + model/firma.go | 23 ++ model/firmaansprechpartner.go | 16 + model/kalender.go | 7 + model/kalendereintrag.go | 7 + model/kostenstelle.go | 7 + model/lager.go | 7 + model/lagerplatz.go | 7 + model/material.go | 7 + model/nachricht.go | 7 + model/projekt.go | 7 + model/rechnung.go | 7 + model/rechnungsposition.go | 7 + model/scanobject.go | 7 + model/user.go | 7 + model/zahlung.go | 7 + query/ansprechpartners.gen.go | 562 +++++++++++++++++++++++++ query/dokuments.gen.go | 395 ++++++++++++++++++ query/firma_ansprechpartner.gen.go | 407 +++++++++++++++++++ query/firmas.gen.go | 630 +++++++++++++++++++++++++++++ query/gen.go | 231 +++++++++++ query/kalendereintrags.gen.go | 395 ++++++++++++++++++ query/kalenders.gen.go | 395 ++++++++++++++++++ query/kostenstelles.gen.go | 395 ++++++++++++++++++ query/lagerplatzs.gen.go | 395 ++++++++++++++++++ query/lagers.gen.go | 395 ++++++++++++++++++ query/materials.gen.go | 395 ++++++++++++++++++ query/nachrichts.gen.go | 395 ++++++++++++++++++ query/projekts.gen.go | 395 ++++++++++++++++++ query/rechnungs.gen.go | 395 ++++++++++++++++++ query/rechnungspositions.gen.go | 395 ++++++++++++++++++ query/scanobjects.gen.go | 395 ++++++++++++++++++ query/users.gen.go | 395 ++++++++++++++++++ query/zahlungs.gen.go | 395 ++++++++++++++++++ routers/ansprechpartner.go | 128 ++++++ routers/firma.go | 105 +++++ tmp/build-errors.log | 1 + tmp/main | Bin 0 -> 20704205 bytes utils/pagination.go | 37 ++ 44 files changed, 8121 insertions(+) create mode 100644 .air.toml create mode 100644 go.mod create mode 100644 go.sum create mode 100644 main.go create mode 100644 model/ansprechpartner.go create mode 100644 model/dokument.go create mode 100644 model/firma.go create mode 100644 model/firmaansprechpartner.go create mode 100644 model/kalender.go create mode 100644 model/kalendereintrag.go create mode 100644 model/kostenstelle.go create mode 100644 model/lager.go create mode 100644 model/lagerplatz.go create mode 100644 model/material.go create mode 100644 model/nachricht.go create mode 100644 model/projekt.go create mode 100644 model/rechnung.go create mode 100644 model/rechnungsposition.go create mode 100644 model/scanobject.go create mode 100644 model/user.go create mode 100644 model/zahlung.go create mode 100644 query/ansprechpartners.gen.go create mode 100644 query/dokuments.gen.go create mode 100644 query/firma_ansprechpartner.gen.go create mode 100644 query/firmas.gen.go create mode 100644 query/gen.go create mode 100644 query/kalendereintrags.gen.go create mode 100644 query/kalenders.gen.go create mode 100644 query/kostenstelles.gen.go create mode 100644 query/lagerplatzs.gen.go create mode 100644 query/lagers.gen.go create mode 100644 query/materials.gen.go create mode 100644 query/nachrichts.gen.go create mode 100644 query/projekts.gen.go create mode 100644 query/rechnungs.gen.go create mode 100644 query/rechnungspositions.gen.go create mode 100644 query/scanobjects.gen.go create mode 100644 query/users.gen.go create mode 100644 query/zahlungs.gen.go create mode 100644 routers/ansprechpartner.go create mode 100644 routers/firma.go create mode 100644 tmp/build-errors.log create mode 100755 tmp/main create mode 100644 utils/pagination.go diff --git a/.air.toml b/.air.toml new file mode 100644 index 0000000..498951f --- /dev/null +++ b/.air.toml @@ -0,0 +1,52 @@ +root = "." +testdata_dir = "testdata" +tmp_dir = "tmp" + +[build] + args_bin = [] + bin = "./tmp/main" + cmd = "go build -o ./tmp/main ." + delay = 1000 + exclude_dir = ["assets", "tmp", "vendor", "testdata"] + exclude_file = [] + exclude_regex = ["_test.go"] + exclude_unchanged = false + follow_symlink = false + full_bin = "" + include_dir = [] + include_ext = ["go", "tpl", "tmpl", "html"] + include_file = [] + kill_delay = "0s" + log = "build-errors.log" + poll = false + poll_interval = 0 + post_cmd = [] + pre_cmd = [] + rerun = false + rerun_delay = 500 + send_interrupt = false + stop_on_error = false + +[color] + app = "" + build = "yellow" + main = "magenta" + runner = "green" + watcher = "cyan" + +[log] + main_only = false + silent = false + time = false + +[misc] + clean_on_exit = false + +[proxy] + app_port = 0 + enabled = false + proxy_port = 0 + +[screen] + clear_on_rebuild = false + keep_scroll = true diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..cbed51c --- /dev/null +++ b/go.mod @@ -0,0 +1,43 @@ +module git.kocoder.xyz/kocoded/vt + +go 1.24.4 + +require ( + github.com/gofiber/fiber/v2 v2.52.9 + gorm.io/driver/postgres v1.6.0 + gorm.io/gen v0.3.27 + gorm.io/gorm v1.30.1 + gorm.io/plugin/dbresolver v1.6.2 +) + +require ( + filippo.io/edwards25519 v1.1.0 // indirect + github.com/andybalholm/brotli v1.2.0 // indirect + github.com/go-sql-driver/mysql v1.9.3 // indirect + github.com/google/uuid v1.6.0 // indirect + github.com/jackc/pgpassfile v1.0.0 // indirect + github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect + github.com/jackc/pgx/v5 v5.7.5 // indirect + github.com/jackc/puddle/v2 v2.2.2 // indirect + github.com/jinzhu/inflection v1.0.0 // indirect + github.com/jinzhu/now v1.1.5 // indirect + github.com/klauspost/compress v1.18.0 // indirect + github.com/mattn/go-colorable v0.1.14 // indirect + github.com/mattn/go-isatty v0.0.20 // indirect + github.com/mattn/go-runewidth v0.0.16 // indirect + github.com/philhofer/fwd v1.2.0 // indirect + github.com/rivo/uniseg v0.4.7 // indirect + github.com/tinylib/msgp v1.3.0 // indirect + github.com/valyala/bytebufferpool v1.0.0 // indirect + github.com/valyala/fasthttp v1.64.0 // indirect + github.com/valyala/tcplisten v1.0.0 // indirect + golang.org/x/crypto v0.41.0 // indirect + golang.org/x/mod v0.27.0 // indirect + golang.org/x/sync v0.16.0 // indirect + golang.org/x/sys v0.35.0 // indirect + golang.org/x/text v0.28.0 // indirect + golang.org/x/tools v0.36.0 // indirect + gorm.io/datatypes v1.2.6 // indirect + gorm.io/driver/mysql v1.6.0 // indirect + gorm.io/hints v1.1.2 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..84683d6 --- /dev/null +++ b/go.sum @@ -0,0 +1,116 @@ +filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA= +filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4= +github.com/andybalholm/brotli v1.1.0 h1:eLKJA0d02Lf0mVpIDgYnqXcUn0GqVmEFny3VuID1U3M= +github.com/andybalholm/brotli v1.1.0/go.mod h1:sms7XGricyQI9K10gOSf56VKKWS4oLer58Q+mhRPtnY= +github.com/andybalholm/brotli v1.2.0 h1:ukwgCxwYrmACq68yiUqwIWnGY0cTPox/M94sVwToPjQ= +github.com/andybalholm/brotli v1.2.0/go.mod h1:rzTDkvFWvIrjDXZHkuS16NPggd91W3kUSvPlQ1pLaKY= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/go-sql-driver/mysql v1.9.3 h1:U/N249h2WzJ3Ukj8SowVFjdtZKfu9vlLZxjPXV1aweo= +github.com/go-sql-driver/mysql v1.9.3/go.mod h1:qn46aNg1333BRMNU69Lq93t8du/dwxI64Gl8i5p1WMU= +github.com/gofiber/fiber/v2 v2.52.9 h1:YjKl5DOiyP3j0mO61u3NTmK7or8GzzWzCFzkboyP5cw= +github.com/gofiber/fiber/v2 v2.52.9/go.mod h1:YEcBbO/FB+5M1IZNBP9FO3J9281zgPAreiI1oqg8nDw= +github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9 h1:au07oEsX2xN0ktxqI+Sida1w446QrXBRJ0nee3SNZlA= +github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9/go.mod h1:8vg3r2VgvsThLBIFL93Qb5yWzgyZWhEmBwUJWevAkK0= +github.com/golang-sql/sqlexp v0.1.0 h1:ZCD6MBpcuOVfGVqsEmY5/4FtYiKz6tSyUv9LPEDei6A= +github.com/golang-sql/sqlexp v0.1.0/go.mod h1:J4ad9Vo8ZCWQ2GMrC4UCQy1JpCbwU9m3EOqtpKwwwHI= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= +github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM= +github.com/jackc/pgx/v5 v5.7.5 h1:JHGfMnQY+IEtGM63d+NGMjoRpysB2JBwDr5fsngwmJs= +github.com/jackc/pgx/v5 v5.7.5/go.mod h1:aruU7o91Tc2q2cFp5h4uP3f6ztExVpyVv88Xl/8Vl8M= +github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo= +github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= +github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E= +github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc= +github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ= +github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8= +github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA= +github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw= +github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo= +github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ= +github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= +github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= +github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE= +github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8= +github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= +github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= +github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc= +github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= +github.com/mattn/go-sqlite3 v1.14.15/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg= +github.com/mattn/go-sqlite3 v1.14.16 h1:yOQRA0RpS5PFz/oikGwBEqvAWhWg5ufRz4ETLjwpU1Y= +github.com/mattn/go-sqlite3 v1.14.16/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg= +github.com/microsoft/go-mssqldb v1.7.2 h1:CHkFJiObW7ItKTJfHo1QX7QBBD1iV+mn1eOyRP3b/PA= +github.com/microsoft/go-mssqldb v1.7.2/go.mod h1:kOvZKUdrhhFQmxLZqbwUV0rHkNkZpthMITIb2Ko1IoA= +github.com/philhofer/fwd v1.1.3-0.20240916144458-20a13a1f6b7c h1:dAMKvw0MlJT1GshSTtih8C2gDs04w8dReiOGXrGLNoY= +github.com/philhofer/fwd v1.1.3-0.20240916144458-20a13a1f6b7c/go.mod h1:RqIHx9QI14HlwKwm98g9Re5prTQ6LdeRQn+gXJFxsJM= +github.com/philhofer/fwd v1.2.0 h1:e6DnBTl7vGY+Gz322/ASL4Gyp1FspeMvx1RNDoToZuM= +github.com/philhofer/fwd v1.2.0/go.mod h1:RqIHx9QI14HlwKwm98g9Re5prTQ6LdeRQn+gXJFxsJM= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY= +github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= +github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ= +github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk= +github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +github.com/tinylib/msgp v1.2.5 h1:WeQg1whrXRFiZusidTQqzETkRpGjFjcIhW6uqWH09po= +github.com/tinylib/msgp v1.2.5/go.mod h1:ykjzy2wzgrlvpDCRc4LA8UXy6D8bzMSuAF3WD57Gok0= +github.com/tinylib/msgp v1.3.0 h1:ULuf7GPooDaIlbyvgAxBV/FI7ynli6LZ1/nVUNu+0ww= +github.com/tinylib/msgp v1.3.0/go.mod h1:ykjzy2wzgrlvpDCRc4LA8UXy6D8bzMSuAF3WD57Gok0= +github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw= +github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= +github.com/valyala/fasthttp v1.51.0 h1:8b30A5JlZ6C7AS81RsWjYMQmrZG6feChmgAolCl1SqA= +github.com/valyala/fasthttp v1.51.0/go.mod h1:oI2XroL+lI7vdXyYoQk03bXBThfFl2cVdIA3Xl7cH8g= +github.com/valyala/fasthttp v1.64.0 h1:QBygLLQmiAyiXuRhthf0tuRkqAFcrC42dckN2S+N3og= +github.com/valyala/fasthttp v1.64.0/go.mod h1:dGmFxwkWXSK0NbOSJuF7AMVzU+lkHz0wQVvVITv2UQA= +github.com/valyala/tcplisten v1.0.0 h1:rBHj/Xf+E1tRGZyWIWwJDiRY0zc1Js+CV5DqwacVSA8= +github.com/valyala/tcplisten v1.0.0/go.mod h1:T0xQ8SeCZGxckz9qRXTfG43PvQ/mcWh7FwZEA7Ioqkc= +golang.org/x/crypto v0.41.0 h1:WKYxWedPGCTVVl5+WHSSrOBT0O8lx32+zxmHxijgXp4= +golang.org/x/crypto v0.41.0/go.mod h1:pO5AFd7FA68rFak7rOAGVuygIISepHftHnr8dr6+sUc= +golang.org/x/mod v0.27.0 h1:kb+q2PyFnEADO2IEF935ehFUXlWiNjJWtRNgBLSfbxQ= +golang.org/x/mod v0.27.0/go.mod h1:rWI627Fq0DEoudcK+MBkNkCe0EetEaDSwJJkCcjpazc= +golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw= +golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= +golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI= +golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= +golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng= +golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU= +golang.org/x/tools v0.36.0 h1:kWS0uv/zsvHEle1LbV5LE8QujrxB3wfQyxHfhOk0Qkg= +golang.org/x/tools v0.36.0/go.mod h1:WBDiHKJK8YgLHlcQPYQzNCkUxUypCaa5ZegCVutKm+s= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gorm.io/datatypes v1.2.6 h1:KafLdXvFUhzNeL2ncm03Gl3eTLONQfNKZ+wJ+9Y4Nck= +gorm.io/datatypes v1.2.6/go.mod h1:M2iO+6S3hhi4nAyYe444Pcb0dcIiOMJ7QHaUXxyiNZY= +gorm.io/driver/mysql v1.6.0 h1:eNbLmNTpPpTOVZi8MMxCi2aaIm0ZpInbORNXDwyLGvg= +gorm.io/driver/mysql v1.6.0/go.mod h1:D/oCC2GWK3M/dqoLxnOlaNKmXz8WNTfcS9y5ovaSqKo= +gorm.io/driver/postgres v1.6.0 h1:2dxzU8xJ+ivvqTRph34QX+WrRaJlmfyPqXmoGVjMBa4= +gorm.io/driver/postgres v1.6.0/go.mod h1:vUw0mrGgrTK+uPHEhAdV4sfFELrByKVGnaVRkXDhtWo= +gorm.io/driver/sqlite v1.5.0 h1:zKYbzRCpBrT1bNijRnxLDJWPjVfImGEn0lSnUY5gZ+c= +gorm.io/driver/sqlite v1.5.0/go.mod h1:kDMDfntV9u/vuMmz8APHtHF0b4nyBB7sfCieC6G8k8I= +gorm.io/driver/sqlserver v1.6.0 h1:VZOBQVsVhkHU/NzNhRJKoANt5pZGQAS1Bwc6m6dgfnc= +gorm.io/driver/sqlserver v1.6.0/go.mod h1:WQzt4IJo/WHKnckU9jXBLMJIVNMVeTu25dnOzehntWw= +gorm.io/gen v0.3.27 h1:ziocAFLpE7e0g4Rum69pGfB9S6DweTxK8gAun7cU8as= +gorm.io/gen v0.3.27/go.mod h1:9zquz2xD1f3Eb/eHq4oLn2z6vDVvQlCY5S3uMBLv4EA= +gorm.io/gorm v1.24.7-0.20230306060331-85eaf9eeda11/go.mod h1:L4uxeKpfBml98NYqVqwAdmV1a2nBtAec/cf3fpucW/k= +gorm.io/gorm v1.25.0/go.mod h1:L4uxeKpfBml98NYqVqwAdmV1a2nBtAec/cf3fpucW/k= +gorm.io/gorm v1.30.1 h1:lSHg33jJTBxs2mgJRfRZeLDG+WZaHYCk3Wtfl6Ngzo4= +gorm.io/gorm v1.30.1/go.mod h1:8Z33v652h4//uMA76KjeDH8mJXPm1QNCYrMeatR0DOE= +gorm.io/hints v1.1.2 h1:b5j0kwk5p4+3BtDtYqqfY+ATSxjj+6ptPgVveuynn9o= +gorm.io/hints v1.1.2/go.mod h1:/ARdpUHAtyEMCh5NNi3tI7FsGh+Cj/MIUlvNxCNCFWg= +gorm.io/plugin/dbresolver v1.6.2 h1:F4b85TenghUeITqe3+epPSUtHH7RIk3fXr5l83DF8Pc= +gorm.io/plugin/dbresolver v1.6.2/go.mod h1:tctw63jdrOezFR9HmrKnPkmig3m5Edem9fdxk9bQSzM= diff --git a/main.go b/main.go new file mode 100644 index 0000000..762a83d --- /dev/null +++ b/main.go @@ -0,0 +1,113 @@ +package main + +import ( + "errors" + "log" + "log/slog" + "os" + "strconv" + + "git.kocoder.xyz/kocoded/vt/model" + "git.kocoder.xyz/kocoded/vt/query" + "git.kocoder.xyz/kocoded/vt/routers" + "git.kocoder.xyz/kocoded/vt/utils" + "github.com/gofiber/fiber/v2" + "github.com/gofiber/fiber/v2/middleware/compress" + "github.com/gofiber/fiber/v2/middleware/cors" + "github.com/gofiber/fiber/v2/middleware/helmet" + "github.com/gofiber/fiber/v2/middleware/idempotency" + "github.com/gofiber/fiber/v2/middleware/logger" + "github.com/gofiber/fiber/v2/middleware/monitor" + "github.com/gofiber/fiber/v2/middleware/pprof" + "github.com/gofiber/fiber/v2/middleware/recover" + "github.com/gofiber/fiber/v2/middleware/requestid" + "github.com/gofiber/fiber/v2/middleware/skip" + "gorm.io/driver/postgres" + "gorm.io/gen" + "gorm.io/gorm" +) + +func main() { + logger := slog.New(slog.NewTextHandler(os.Stdout, nil)) + + SetupDatabase() + + app := fiber.New() + + RegisterMiddlewares(app) + + routers.RegisterAnsprechpartnerRouter(app.Group("/v1/ansprechpartner"), logger) + routers.RegisterFirmaRouter(app.Group("/v1/firma"), logger) + + log.Fatalln(app.Listen(":3000")) +} + +func RegisterMiddlewares(app *fiber.App) { + app.Use(requestid.New()) + app.Use(compress.New()) + app.Use(helmet.New()) + app.Use(cors.New()) + // app.Use(csrf.New()) + // app.Use(healthcheck.New(healthcheck.Config{})) + app.Use(idempotency.New()) + // app.Use(limiter.New()) + app.Use(logger.New()) + app.Use("/dbg/monitor", monitor.New()) + app.Use(pprof.New()) + app.Use(recover.New()) + app.Use(skip.New(AddPaginationParams, func(c *fiber.Ctx) bool { + return c.Method() != fiber.MethodGet + })) +} + +func AddPaginationParams(c *fiber.Ctx) error { + err := c.Next() + if err != nil { + var offset *utils.OffsetPaginationError + if errors.As(err, &offset) { + c.Append("X-Page", strconv.Itoa(offset.Page)) + c.Append("X-Pages", strconv.Itoa(offset.Pages)) + c.Append("X-Next-Page", strconv.Itoa(offset.NextPage)) + c.Append("X-Last-Page", strconv.Itoa(offset.LastPage)) + return nil + } + + var keyset *utils.KeysetPaginationError + if errors.As(err, &keyset) { + c.Append("X-Key", strconv.Itoa(keyset.Key)) + c.Append("X-Previous-Key", strconv.Itoa(keyset.PreviousKey)) + c.Append("X-Next-Key", strconv.Itoa(keyset.NextKey)) + return nil + } + } + return err +} + +func SetupDatabase() { + dsn := "host=10.1.0.2 user=vt password=20a1c7809cd065bc5afe7c36fde26abf625316c8a83cc841b435c9acf3619b1f dbname=vt port=5432 sslmode=prefer TimeZone=Europe/Vienna" + db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{}) + if err != nil { + panic(err) + } + + db.SetupJoinTable(model.Ansprechpartner{}, "Firmen", model.FirmaAnsprechpartner{}) + db.SetupJoinTable(model.Firma{}, "Ansprechpartner", model.FirmaAnsprechpartner{}) + + db.AutoMigrate(&model.Ansprechpartner{}, &model.FirmaAnsprechpartner{}, &model.Firma{}) + + g := gen.NewGenerator(gen.Config{ + OutPath: "./query", + Mode: gen.WithoutContext | gen.WithDefaultQuery | gen.WithQueryInterface, // generate mode + }) + + // gormdb, _ := gorm.Open(mysql.Open("root:@(127.0.0.1:3306)/demo?charset=utf8mb4&parseTime=True&loc=Local")) + g.UseDB(db) // reuse your gorm db + + // Generate basic type-safe DAO API for struct `model.User` following conventions + g.ApplyBasic(model.Ansprechpartner{}, model.Dokument{}, model.Firma{}, model.Kalender{}, model.Kalendereintrag{}, model.Kostenstelle{}, model.Lager{}, model.Lagerplatz{}, model.Material{}, model.Nachricht{}, model.Projekt{}, model.Rechnung{}, model.Rechnungsposition{}, model.Scanobject{}, model.User{}, model.Zahlung{}, model.FirmaAnsprechpartner{}) + + // Generate the code + g.Execute() + + query.SetDefault(db) +} diff --git a/model/ansprechpartner.go b/model/ansprechpartner.go new file mode 100644 index 0000000..3275b51 --- /dev/null +++ b/model/ansprechpartner.go @@ -0,0 +1,29 @@ +package model + +import "gorm.io/gorm" + +type Gender int + +const ( + _ Gender = iota + Male + Female + Other +) + +type Ansprechpartner struct { + gorm.Model + ImageURL string `json:"image_url"` + Title string `json:"title"` + FirstName string `json:"first_name"` + LastName string `json:"last_name"` + LastTitle string `json:"last_title"` + EMail string `json:"e_mail" gorm:"email;unique;not null"` + Phone string `json:"phone"` + Mobile string `json:"mobile"` + Notes string `json:"notes"` + Description string `json:"description"` + Active bool `json:"active"` + Gender Gender `json:"gender"` + Firmen []*Firma `json:"firmen" gorm:"many2many:firma_ansprechpartner"` +} diff --git a/model/dokument.go b/model/dokument.go new file mode 100644 index 0000000..f4edcd8 --- /dev/null +++ b/model/dokument.go @@ -0,0 +1,7 @@ +package model + +import "gorm.io/gorm" + +type Dokument struct { + gorm.Model +} diff --git a/model/firma.go b/model/firma.go new file mode 100644 index 0000000..6e099f7 --- /dev/null +++ b/model/firma.go @@ -0,0 +1,23 @@ +package model + +import "gorm.io/gorm" + +type FirmaTyp int + +const ( + _ FirmaTyp = iota + Lieferant + Kunde +) + +type Firma struct { + gorm.Model + FirmaTyp FirmaTyp `json:"firma_typ"` + Name string `json:"name"` + InternerName string `json:"interner_name"` + Slug string `gorm:"unique;not null;index" json:"slug"` + Branche string `json:"branche"` + Tochergesellschaften []*Firma `gorm:"foreignkey:ParentCompany" json:"tochergesellschaften"` + ParentCompany *uint `json:"parent_company"` + Ansprechpartner []*Ansprechpartner `gorm:"many2many:firma_ansprechpartner" json:"ansprechpartner"` +} diff --git a/model/firmaansprechpartner.go b/model/firmaansprechpartner.go new file mode 100644 index 0000000..02d33cc --- /dev/null +++ b/model/firmaansprechpartner.go @@ -0,0 +1,16 @@ +package model + +import ( + "gorm.io/gorm" +) + +type FirmaAnsprechpartner struct { + gorm.Model + AnsprechpartnerId uint `gorm:"unique"` + FirmaId uint `gorm:"unique"` + Role string +} + +func (FirmaAnsprechpartner) TableName() string { + return "firma_ansprechpartner" +} diff --git a/model/kalender.go b/model/kalender.go new file mode 100644 index 0000000..4b2b5a3 --- /dev/null +++ b/model/kalender.go @@ -0,0 +1,7 @@ +package model + +import "gorm.io/gorm" + +type Kalender struct { + gorm.Model +} diff --git a/model/kalendereintrag.go b/model/kalendereintrag.go new file mode 100644 index 0000000..6720fea --- /dev/null +++ b/model/kalendereintrag.go @@ -0,0 +1,7 @@ +package model + +import "gorm.io/gorm" + +type Kalendereintrag struct { + gorm.Model +} diff --git a/model/kostenstelle.go b/model/kostenstelle.go new file mode 100644 index 0000000..0fa5fc9 --- /dev/null +++ b/model/kostenstelle.go @@ -0,0 +1,7 @@ +package model + +import "gorm.io/gorm" + +type Kostenstelle struct { + gorm.Model +} diff --git a/model/lager.go b/model/lager.go new file mode 100644 index 0000000..0f099d8 --- /dev/null +++ b/model/lager.go @@ -0,0 +1,7 @@ +package model + +import "gorm.io/gorm" + +type Lager struct { + gorm.Model +} diff --git a/model/lagerplatz.go b/model/lagerplatz.go new file mode 100644 index 0000000..11e64c7 --- /dev/null +++ b/model/lagerplatz.go @@ -0,0 +1,7 @@ +package model + +import "gorm.io/gorm" + +type Lagerplatz struct { + gorm.Model +} diff --git a/model/material.go b/model/material.go new file mode 100644 index 0000000..bb605a2 --- /dev/null +++ b/model/material.go @@ -0,0 +1,7 @@ +package model + +import "gorm.io/gorm" + +type Material struct { + gorm.Model +} diff --git a/model/nachricht.go b/model/nachricht.go new file mode 100644 index 0000000..468757b --- /dev/null +++ b/model/nachricht.go @@ -0,0 +1,7 @@ +package model + +import "gorm.io/gorm" + +type Nachricht struct { + gorm.Model +} diff --git a/model/projekt.go b/model/projekt.go new file mode 100644 index 0000000..4400f23 --- /dev/null +++ b/model/projekt.go @@ -0,0 +1,7 @@ +package model + +import "gorm.io/gorm" + +type Projekt struct { + gorm.Model +} diff --git a/model/rechnung.go b/model/rechnung.go new file mode 100644 index 0000000..71cd690 --- /dev/null +++ b/model/rechnung.go @@ -0,0 +1,7 @@ +package model + +import "gorm.io/gorm" + +type Rechnung struct { + gorm.Model +} diff --git a/model/rechnungsposition.go b/model/rechnungsposition.go new file mode 100644 index 0000000..38c906b --- /dev/null +++ b/model/rechnungsposition.go @@ -0,0 +1,7 @@ +package model + +import "gorm.io/gorm" + +type Rechnungsposition struct { + gorm.Model +} diff --git a/model/scanobject.go b/model/scanobject.go new file mode 100644 index 0000000..2857d00 --- /dev/null +++ b/model/scanobject.go @@ -0,0 +1,7 @@ +package model + +import "gorm.io/gorm" + +type Scanobject struct { + gorm.Model +} diff --git a/model/user.go b/model/user.go new file mode 100644 index 0000000..8c1930d --- /dev/null +++ b/model/user.go @@ -0,0 +1,7 @@ +package model + +import "gorm.io/gorm" + +type User struct { + gorm.Model +} diff --git a/model/zahlung.go b/model/zahlung.go new file mode 100644 index 0000000..4102172 --- /dev/null +++ b/model/zahlung.go @@ -0,0 +1,7 @@ +package model + +import "gorm.io/gorm" + +type Zahlung struct { + gorm.Model +} diff --git a/query/ansprechpartners.gen.go b/query/ansprechpartners.gen.go new file mode 100644 index 0000000..ba155b4 --- /dev/null +++ b/query/ansprechpartners.gen.go @@ -0,0 +1,562 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newAnsprechpartner(db *gorm.DB, opts ...gen.DOOption) ansprechpartner { + _ansprechpartner := ansprechpartner{} + + _ansprechpartner.ansprechpartnerDo.UseDB(db, opts...) + _ansprechpartner.ansprechpartnerDo.UseModel(&model.Ansprechpartner{}) + + tableName := _ansprechpartner.ansprechpartnerDo.TableName() + _ansprechpartner.ALL = field.NewAsterisk(tableName) + _ansprechpartner.ID = field.NewUint(tableName, "id") + _ansprechpartner.CreatedAt = field.NewTime(tableName, "created_at") + _ansprechpartner.UpdatedAt = field.NewTime(tableName, "updated_at") + _ansprechpartner.DeletedAt = field.NewField(tableName, "deleted_at") + _ansprechpartner.ImageURL = field.NewString(tableName, "image_url") + _ansprechpartner.Title = field.NewString(tableName, "title") + _ansprechpartner.FirstName = field.NewString(tableName, "first_name") + _ansprechpartner.LastName = field.NewString(tableName, "last_name") + _ansprechpartner.LastTitle = field.NewString(tableName, "last_title") + _ansprechpartner.EMail = field.NewString(tableName, "e_mail") + _ansprechpartner.Phone = field.NewString(tableName, "phone") + _ansprechpartner.Mobile = field.NewString(tableName, "mobile") + _ansprechpartner.Notes = field.NewString(tableName, "notes") + _ansprechpartner.Description = field.NewString(tableName, "description") + _ansprechpartner.Active = field.NewBool(tableName, "active") + _ansprechpartner.Gender = field.NewInt(tableName, "gender") + _ansprechpartner.Firmen = ansprechpartnerManyToManyFirmen{ + db: db.Session(&gorm.Session{}), + + RelationField: field.NewRelation("Firmen", "model.Firma"), + Tochergesellschaften: struct { + field.RelationField + }{ + RelationField: field.NewRelation("Firmen.Tochergesellschaften", "model.Firma"), + }, + Ansprechpartner: struct { + field.RelationField + Firmen struct { + field.RelationField + } + }{ + RelationField: field.NewRelation("Firmen.Ansprechpartner", "model.Ansprechpartner"), + Firmen: struct { + field.RelationField + }{ + RelationField: field.NewRelation("Firmen.Ansprechpartner.Firmen", "model.Firma"), + }, + }, + } + + _ansprechpartner.fillFieldMap() + + return _ansprechpartner +} + +type ansprechpartner struct { + ansprechpartnerDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + ImageURL field.String + Title field.String + FirstName field.String + LastName field.String + LastTitle field.String + EMail field.String + Phone field.String + Mobile field.String + Notes field.String + Description field.String + Active field.Bool + Gender field.Int + Firmen ansprechpartnerManyToManyFirmen + + fieldMap map[string]field.Expr +} + +func (a ansprechpartner) Table(newTableName string) *ansprechpartner { + a.ansprechpartnerDo.UseTable(newTableName) + return a.updateTableName(newTableName) +} + +func (a ansprechpartner) As(alias string) *ansprechpartner { + a.ansprechpartnerDo.DO = *(a.ansprechpartnerDo.As(alias).(*gen.DO)) + return a.updateTableName(alias) +} + +func (a *ansprechpartner) updateTableName(table string) *ansprechpartner { + a.ALL = field.NewAsterisk(table) + a.ID = field.NewUint(table, "id") + a.CreatedAt = field.NewTime(table, "created_at") + a.UpdatedAt = field.NewTime(table, "updated_at") + a.DeletedAt = field.NewField(table, "deleted_at") + a.ImageURL = field.NewString(table, "image_url") + a.Title = field.NewString(table, "title") + a.FirstName = field.NewString(table, "first_name") + a.LastName = field.NewString(table, "last_name") + a.LastTitle = field.NewString(table, "last_title") + a.EMail = field.NewString(table, "e_mail") + a.Phone = field.NewString(table, "phone") + a.Mobile = field.NewString(table, "mobile") + a.Notes = field.NewString(table, "notes") + a.Description = field.NewString(table, "description") + a.Active = field.NewBool(table, "active") + a.Gender = field.NewInt(table, "gender") + + a.fillFieldMap() + + return a +} + +func (a *ansprechpartner) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := a.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (a *ansprechpartner) fillFieldMap() { + a.fieldMap = make(map[string]field.Expr, 17) + a.fieldMap["id"] = a.ID + a.fieldMap["created_at"] = a.CreatedAt + a.fieldMap["updated_at"] = a.UpdatedAt + a.fieldMap["deleted_at"] = a.DeletedAt + a.fieldMap["image_url"] = a.ImageURL + a.fieldMap["title"] = a.Title + a.fieldMap["first_name"] = a.FirstName + a.fieldMap["last_name"] = a.LastName + a.fieldMap["last_title"] = a.LastTitle + a.fieldMap["e_mail"] = a.EMail + a.fieldMap["phone"] = a.Phone + a.fieldMap["mobile"] = a.Mobile + a.fieldMap["notes"] = a.Notes + a.fieldMap["description"] = a.Description + a.fieldMap["active"] = a.Active + a.fieldMap["gender"] = a.Gender + +} + +func (a ansprechpartner) clone(db *gorm.DB) ansprechpartner { + a.ansprechpartnerDo.ReplaceConnPool(db.Statement.ConnPool) + a.Firmen.db = db.Session(&gorm.Session{Initialized: true}) + a.Firmen.db.Statement.ConnPool = db.Statement.ConnPool + return a +} + +func (a ansprechpartner) replaceDB(db *gorm.DB) ansprechpartner { + a.ansprechpartnerDo.ReplaceDB(db) + a.Firmen.db = db.Session(&gorm.Session{}) + return a +} + +type ansprechpartnerManyToManyFirmen struct { + db *gorm.DB + + field.RelationField + + Tochergesellschaften struct { + field.RelationField + } + Ansprechpartner struct { + field.RelationField + Firmen struct { + field.RelationField + } + } +} + +func (a ansprechpartnerManyToManyFirmen) Where(conds ...field.Expr) *ansprechpartnerManyToManyFirmen { + if len(conds) == 0 { + return &a + } + + exprs := make([]clause.Expression, 0, len(conds)) + for _, cond := range conds { + exprs = append(exprs, cond.BeCond().(clause.Expression)) + } + a.db = a.db.Clauses(clause.Where{Exprs: exprs}) + return &a +} + +func (a ansprechpartnerManyToManyFirmen) WithContext(ctx context.Context) *ansprechpartnerManyToManyFirmen { + a.db = a.db.WithContext(ctx) + return &a +} + +func (a ansprechpartnerManyToManyFirmen) Session(session *gorm.Session) *ansprechpartnerManyToManyFirmen { + a.db = a.db.Session(session) + return &a +} + +func (a ansprechpartnerManyToManyFirmen) Model(m *model.Ansprechpartner) *ansprechpartnerManyToManyFirmenTx { + return &ansprechpartnerManyToManyFirmenTx{a.db.Model(m).Association(a.Name())} +} + +func (a ansprechpartnerManyToManyFirmen) Unscoped() *ansprechpartnerManyToManyFirmen { + a.db = a.db.Unscoped() + return &a +} + +type ansprechpartnerManyToManyFirmenTx struct{ tx *gorm.Association } + +func (a ansprechpartnerManyToManyFirmenTx) Find() (result []*model.Firma, err error) { + return result, a.tx.Find(&result) +} + +func (a ansprechpartnerManyToManyFirmenTx) Append(values ...*model.Firma) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Append(targetValues...) +} + +func (a ansprechpartnerManyToManyFirmenTx) Replace(values ...*model.Firma) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Replace(targetValues...) +} + +func (a ansprechpartnerManyToManyFirmenTx) Delete(values ...*model.Firma) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Delete(targetValues...) +} + +func (a ansprechpartnerManyToManyFirmenTx) Clear() error { + return a.tx.Clear() +} + +func (a ansprechpartnerManyToManyFirmenTx) Count() int64 { + return a.tx.Count() +} + +func (a ansprechpartnerManyToManyFirmenTx) Unscoped() *ansprechpartnerManyToManyFirmenTx { + a.tx = a.tx.Unscoped() + return &a +} + +type ansprechpartnerDo struct{ gen.DO } + +type IAnsprechpartnerDo interface { + gen.SubQuery + Debug() IAnsprechpartnerDo + WithContext(ctx context.Context) IAnsprechpartnerDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IAnsprechpartnerDo + WriteDB() IAnsprechpartnerDo + As(alias string) gen.Dao + Session(config *gorm.Session) IAnsprechpartnerDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IAnsprechpartnerDo + Not(conds ...gen.Condition) IAnsprechpartnerDo + Or(conds ...gen.Condition) IAnsprechpartnerDo + Select(conds ...field.Expr) IAnsprechpartnerDo + Where(conds ...gen.Condition) IAnsprechpartnerDo + Order(conds ...field.Expr) IAnsprechpartnerDo + Distinct(cols ...field.Expr) IAnsprechpartnerDo + Omit(cols ...field.Expr) IAnsprechpartnerDo + Join(table schema.Tabler, on ...field.Expr) IAnsprechpartnerDo + LeftJoin(table schema.Tabler, on ...field.Expr) IAnsprechpartnerDo + RightJoin(table schema.Tabler, on ...field.Expr) IAnsprechpartnerDo + Group(cols ...field.Expr) IAnsprechpartnerDo + Having(conds ...gen.Condition) IAnsprechpartnerDo + Limit(limit int) IAnsprechpartnerDo + Offset(offset int) IAnsprechpartnerDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IAnsprechpartnerDo + Unscoped() IAnsprechpartnerDo + Create(values ...*model.Ansprechpartner) error + CreateInBatches(values []*model.Ansprechpartner, batchSize int) error + Save(values ...*model.Ansprechpartner) error + First() (*model.Ansprechpartner, error) + Take() (*model.Ansprechpartner, error) + Last() (*model.Ansprechpartner, error) + Find() ([]*model.Ansprechpartner, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Ansprechpartner, err error) + FindInBatches(result *[]*model.Ansprechpartner, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Ansprechpartner) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IAnsprechpartnerDo + Assign(attrs ...field.AssignExpr) IAnsprechpartnerDo + Joins(fields ...field.RelationField) IAnsprechpartnerDo + Preload(fields ...field.RelationField) IAnsprechpartnerDo + FirstOrInit() (*model.Ansprechpartner, error) + FirstOrCreate() (*model.Ansprechpartner, error) + FindByPage(offset int, limit int) (result []*model.Ansprechpartner, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IAnsprechpartnerDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (a ansprechpartnerDo) Debug() IAnsprechpartnerDo { + return a.withDO(a.DO.Debug()) +} + +func (a ansprechpartnerDo) WithContext(ctx context.Context) IAnsprechpartnerDo { + return a.withDO(a.DO.WithContext(ctx)) +} + +func (a ansprechpartnerDo) ReadDB() IAnsprechpartnerDo { + return a.Clauses(dbresolver.Read) +} + +func (a ansprechpartnerDo) WriteDB() IAnsprechpartnerDo { + return a.Clauses(dbresolver.Write) +} + +func (a ansprechpartnerDo) Session(config *gorm.Session) IAnsprechpartnerDo { + return a.withDO(a.DO.Session(config)) +} + +func (a ansprechpartnerDo) Clauses(conds ...clause.Expression) IAnsprechpartnerDo { + return a.withDO(a.DO.Clauses(conds...)) +} + +func (a ansprechpartnerDo) Returning(value interface{}, columns ...string) IAnsprechpartnerDo { + return a.withDO(a.DO.Returning(value, columns...)) +} + +func (a ansprechpartnerDo) Not(conds ...gen.Condition) IAnsprechpartnerDo { + return a.withDO(a.DO.Not(conds...)) +} + +func (a ansprechpartnerDo) Or(conds ...gen.Condition) IAnsprechpartnerDo { + return a.withDO(a.DO.Or(conds...)) +} + +func (a ansprechpartnerDo) Select(conds ...field.Expr) IAnsprechpartnerDo { + return a.withDO(a.DO.Select(conds...)) +} + +func (a ansprechpartnerDo) Where(conds ...gen.Condition) IAnsprechpartnerDo { + return a.withDO(a.DO.Where(conds...)) +} + +func (a ansprechpartnerDo) Order(conds ...field.Expr) IAnsprechpartnerDo { + return a.withDO(a.DO.Order(conds...)) +} + +func (a ansprechpartnerDo) Distinct(cols ...field.Expr) IAnsprechpartnerDo { + return a.withDO(a.DO.Distinct(cols...)) +} + +func (a ansprechpartnerDo) Omit(cols ...field.Expr) IAnsprechpartnerDo { + return a.withDO(a.DO.Omit(cols...)) +} + +func (a ansprechpartnerDo) Join(table schema.Tabler, on ...field.Expr) IAnsprechpartnerDo { + return a.withDO(a.DO.Join(table, on...)) +} + +func (a ansprechpartnerDo) LeftJoin(table schema.Tabler, on ...field.Expr) IAnsprechpartnerDo { + return a.withDO(a.DO.LeftJoin(table, on...)) +} + +func (a ansprechpartnerDo) RightJoin(table schema.Tabler, on ...field.Expr) IAnsprechpartnerDo { + return a.withDO(a.DO.RightJoin(table, on...)) +} + +func (a ansprechpartnerDo) Group(cols ...field.Expr) IAnsprechpartnerDo { + return a.withDO(a.DO.Group(cols...)) +} + +func (a ansprechpartnerDo) Having(conds ...gen.Condition) IAnsprechpartnerDo { + return a.withDO(a.DO.Having(conds...)) +} + +func (a ansprechpartnerDo) Limit(limit int) IAnsprechpartnerDo { + return a.withDO(a.DO.Limit(limit)) +} + +func (a ansprechpartnerDo) Offset(offset int) IAnsprechpartnerDo { + return a.withDO(a.DO.Offset(offset)) +} + +func (a ansprechpartnerDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IAnsprechpartnerDo { + return a.withDO(a.DO.Scopes(funcs...)) +} + +func (a ansprechpartnerDo) Unscoped() IAnsprechpartnerDo { + return a.withDO(a.DO.Unscoped()) +} + +func (a ansprechpartnerDo) Create(values ...*model.Ansprechpartner) error { + if len(values) == 0 { + return nil + } + return a.DO.Create(values) +} + +func (a ansprechpartnerDo) CreateInBatches(values []*model.Ansprechpartner, batchSize int) error { + return a.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (a ansprechpartnerDo) Save(values ...*model.Ansprechpartner) error { + if len(values) == 0 { + return nil + } + return a.DO.Save(values) +} + +func (a ansprechpartnerDo) First() (*model.Ansprechpartner, error) { + if result, err := a.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Ansprechpartner), nil + } +} + +func (a ansprechpartnerDo) Take() (*model.Ansprechpartner, error) { + if result, err := a.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Ansprechpartner), nil + } +} + +func (a ansprechpartnerDo) Last() (*model.Ansprechpartner, error) { + if result, err := a.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Ansprechpartner), nil + } +} + +func (a ansprechpartnerDo) Find() ([]*model.Ansprechpartner, error) { + result, err := a.DO.Find() + return result.([]*model.Ansprechpartner), err +} + +func (a ansprechpartnerDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Ansprechpartner, err error) { + buf := make([]*model.Ansprechpartner, 0, batchSize) + err = a.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (a ansprechpartnerDo) FindInBatches(result *[]*model.Ansprechpartner, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return a.DO.FindInBatches(result, batchSize, fc) +} + +func (a ansprechpartnerDo) Attrs(attrs ...field.AssignExpr) IAnsprechpartnerDo { + return a.withDO(a.DO.Attrs(attrs...)) +} + +func (a ansprechpartnerDo) Assign(attrs ...field.AssignExpr) IAnsprechpartnerDo { + return a.withDO(a.DO.Assign(attrs...)) +} + +func (a ansprechpartnerDo) Joins(fields ...field.RelationField) IAnsprechpartnerDo { + for _, _f := range fields { + a = *a.withDO(a.DO.Joins(_f)) + } + return &a +} + +func (a ansprechpartnerDo) Preload(fields ...field.RelationField) IAnsprechpartnerDo { + for _, _f := range fields { + a = *a.withDO(a.DO.Preload(_f)) + } + return &a +} + +func (a ansprechpartnerDo) FirstOrInit() (*model.Ansprechpartner, error) { + if result, err := a.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Ansprechpartner), nil + } +} + +func (a ansprechpartnerDo) FirstOrCreate() (*model.Ansprechpartner, error) { + if result, err := a.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Ansprechpartner), nil + } +} + +func (a ansprechpartnerDo) FindByPage(offset int, limit int) (result []*model.Ansprechpartner, count int64, err error) { + result, err = a.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = a.Offset(-1).Limit(-1).Count() + return +} + +func (a ansprechpartnerDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = a.Count() + if err != nil { + return + } + + err = a.Offset(offset).Limit(limit).Scan(result) + return +} + +func (a ansprechpartnerDo) Scan(result interface{}) (err error) { + return a.DO.Scan(result) +} + +func (a ansprechpartnerDo) Delete(models ...*model.Ansprechpartner) (result gen.ResultInfo, err error) { + return a.DO.Delete(models) +} + +func (a *ansprechpartnerDo) withDO(do gen.Dao) *ansprechpartnerDo { + a.DO = *do.(*gen.DO) + return a +} diff --git a/query/dokuments.gen.go b/query/dokuments.gen.go new file mode 100644 index 0000000..ac04910 --- /dev/null +++ b/query/dokuments.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newDokument(db *gorm.DB, opts ...gen.DOOption) dokument { + _dokument := dokument{} + + _dokument.dokumentDo.UseDB(db, opts...) + _dokument.dokumentDo.UseModel(&model.Dokument{}) + + tableName := _dokument.dokumentDo.TableName() + _dokument.ALL = field.NewAsterisk(tableName) + _dokument.ID = field.NewUint(tableName, "id") + _dokument.CreatedAt = field.NewTime(tableName, "created_at") + _dokument.UpdatedAt = field.NewTime(tableName, "updated_at") + _dokument.DeletedAt = field.NewField(tableName, "deleted_at") + + _dokument.fillFieldMap() + + return _dokument +} + +type dokument struct { + dokumentDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (d dokument) Table(newTableName string) *dokument { + d.dokumentDo.UseTable(newTableName) + return d.updateTableName(newTableName) +} + +func (d dokument) As(alias string) *dokument { + d.dokumentDo.DO = *(d.dokumentDo.As(alias).(*gen.DO)) + return d.updateTableName(alias) +} + +func (d *dokument) updateTableName(table string) *dokument { + d.ALL = field.NewAsterisk(table) + d.ID = field.NewUint(table, "id") + d.CreatedAt = field.NewTime(table, "created_at") + d.UpdatedAt = field.NewTime(table, "updated_at") + d.DeletedAt = field.NewField(table, "deleted_at") + + d.fillFieldMap() + + return d +} + +func (d *dokument) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := d.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (d *dokument) fillFieldMap() { + d.fieldMap = make(map[string]field.Expr, 4) + d.fieldMap["id"] = d.ID + d.fieldMap["created_at"] = d.CreatedAt + d.fieldMap["updated_at"] = d.UpdatedAt + d.fieldMap["deleted_at"] = d.DeletedAt +} + +func (d dokument) clone(db *gorm.DB) dokument { + d.dokumentDo.ReplaceConnPool(db.Statement.ConnPool) + return d +} + +func (d dokument) replaceDB(db *gorm.DB) dokument { + d.dokumentDo.ReplaceDB(db) + return d +} + +type dokumentDo struct{ gen.DO } + +type IDokumentDo interface { + gen.SubQuery + Debug() IDokumentDo + WithContext(ctx context.Context) IDokumentDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IDokumentDo + WriteDB() IDokumentDo + As(alias string) gen.Dao + Session(config *gorm.Session) IDokumentDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IDokumentDo + Not(conds ...gen.Condition) IDokumentDo + Or(conds ...gen.Condition) IDokumentDo + Select(conds ...field.Expr) IDokumentDo + Where(conds ...gen.Condition) IDokumentDo + Order(conds ...field.Expr) IDokumentDo + Distinct(cols ...field.Expr) IDokumentDo + Omit(cols ...field.Expr) IDokumentDo + Join(table schema.Tabler, on ...field.Expr) IDokumentDo + LeftJoin(table schema.Tabler, on ...field.Expr) IDokumentDo + RightJoin(table schema.Tabler, on ...field.Expr) IDokumentDo + Group(cols ...field.Expr) IDokumentDo + Having(conds ...gen.Condition) IDokumentDo + Limit(limit int) IDokumentDo + Offset(offset int) IDokumentDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IDokumentDo + Unscoped() IDokumentDo + Create(values ...*model.Dokument) error + CreateInBatches(values []*model.Dokument, batchSize int) error + Save(values ...*model.Dokument) error + First() (*model.Dokument, error) + Take() (*model.Dokument, error) + Last() (*model.Dokument, error) + Find() ([]*model.Dokument, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Dokument, err error) + FindInBatches(result *[]*model.Dokument, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Dokument) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IDokumentDo + Assign(attrs ...field.AssignExpr) IDokumentDo + Joins(fields ...field.RelationField) IDokumentDo + Preload(fields ...field.RelationField) IDokumentDo + FirstOrInit() (*model.Dokument, error) + FirstOrCreate() (*model.Dokument, error) + FindByPage(offset int, limit int) (result []*model.Dokument, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IDokumentDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (d dokumentDo) Debug() IDokumentDo { + return d.withDO(d.DO.Debug()) +} + +func (d dokumentDo) WithContext(ctx context.Context) IDokumentDo { + return d.withDO(d.DO.WithContext(ctx)) +} + +func (d dokumentDo) ReadDB() IDokumentDo { + return d.Clauses(dbresolver.Read) +} + +func (d dokumentDo) WriteDB() IDokumentDo { + return d.Clauses(dbresolver.Write) +} + +func (d dokumentDo) Session(config *gorm.Session) IDokumentDo { + return d.withDO(d.DO.Session(config)) +} + +func (d dokumentDo) Clauses(conds ...clause.Expression) IDokumentDo { + return d.withDO(d.DO.Clauses(conds...)) +} + +func (d dokumentDo) Returning(value interface{}, columns ...string) IDokumentDo { + return d.withDO(d.DO.Returning(value, columns...)) +} + +func (d dokumentDo) Not(conds ...gen.Condition) IDokumentDo { + return d.withDO(d.DO.Not(conds...)) +} + +func (d dokumentDo) Or(conds ...gen.Condition) IDokumentDo { + return d.withDO(d.DO.Or(conds...)) +} + +func (d dokumentDo) Select(conds ...field.Expr) IDokumentDo { + return d.withDO(d.DO.Select(conds...)) +} + +func (d dokumentDo) Where(conds ...gen.Condition) IDokumentDo { + return d.withDO(d.DO.Where(conds...)) +} + +func (d dokumentDo) Order(conds ...field.Expr) IDokumentDo { + return d.withDO(d.DO.Order(conds...)) +} + +func (d dokumentDo) Distinct(cols ...field.Expr) IDokumentDo { + return d.withDO(d.DO.Distinct(cols...)) +} + +func (d dokumentDo) Omit(cols ...field.Expr) IDokumentDo { + return d.withDO(d.DO.Omit(cols...)) +} + +func (d dokumentDo) Join(table schema.Tabler, on ...field.Expr) IDokumentDo { + return d.withDO(d.DO.Join(table, on...)) +} + +func (d dokumentDo) LeftJoin(table schema.Tabler, on ...field.Expr) IDokumentDo { + return d.withDO(d.DO.LeftJoin(table, on...)) +} + +func (d dokumentDo) RightJoin(table schema.Tabler, on ...field.Expr) IDokumentDo { + return d.withDO(d.DO.RightJoin(table, on...)) +} + +func (d dokumentDo) Group(cols ...field.Expr) IDokumentDo { + return d.withDO(d.DO.Group(cols...)) +} + +func (d dokumentDo) Having(conds ...gen.Condition) IDokumentDo { + return d.withDO(d.DO.Having(conds...)) +} + +func (d dokumentDo) Limit(limit int) IDokumentDo { + return d.withDO(d.DO.Limit(limit)) +} + +func (d dokumentDo) Offset(offset int) IDokumentDo { + return d.withDO(d.DO.Offset(offset)) +} + +func (d dokumentDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IDokumentDo { + return d.withDO(d.DO.Scopes(funcs...)) +} + +func (d dokumentDo) Unscoped() IDokumentDo { + return d.withDO(d.DO.Unscoped()) +} + +func (d dokumentDo) Create(values ...*model.Dokument) error { + if len(values) == 0 { + return nil + } + return d.DO.Create(values) +} + +func (d dokumentDo) CreateInBatches(values []*model.Dokument, batchSize int) error { + return d.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (d dokumentDo) Save(values ...*model.Dokument) error { + if len(values) == 0 { + return nil + } + return d.DO.Save(values) +} + +func (d dokumentDo) First() (*model.Dokument, error) { + if result, err := d.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Dokument), nil + } +} + +func (d dokumentDo) Take() (*model.Dokument, error) { + if result, err := d.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Dokument), nil + } +} + +func (d dokumentDo) Last() (*model.Dokument, error) { + if result, err := d.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Dokument), nil + } +} + +func (d dokumentDo) Find() ([]*model.Dokument, error) { + result, err := d.DO.Find() + return result.([]*model.Dokument), err +} + +func (d dokumentDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Dokument, err error) { + buf := make([]*model.Dokument, 0, batchSize) + err = d.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (d dokumentDo) FindInBatches(result *[]*model.Dokument, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return d.DO.FindInBatches(result, batchSize, fc) +} + +func (d dokumentDo) Attrs(attrs ...field.AssignExpr) IDokumentDo { + return d.withDO(d.DO.Attrs(attrs...)) +} + +func (d dokumentDo) Assign(attrs ...field.AssignExpr) IDokumentDo { + return d.withDO(d.DO.Assign(attrs...)) +} + +func (d dokumentDo) Joins(fields ...field.RelationField) IDokumentDo { + for _, _f := range fields { + d = *d.withDO(d.DO.Joins(_f)) + } + return &d +} + +func (d dokumentDo) Preload(fields ...field.RelationField) IDokumentDo { + for _, _f := range fields { + d = *d.withDO(d.DO.Preload(_f)) + } + return &d +} + +func (d dokumentDo) FirstOrInit() (*model.Dokument, error) { + if result, err := d.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Dokument), nil + } +} + +func (d dokumentDo) FirstOrCreate() (*model.Dokument, error) { + if result, err := d.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Dokument), nil + } +} + +func (d dokumentDo) FindByPage(offset int, limit int) (result []*model.Dokument, count int64, err error) { + result, err = d.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = d.Offset(-1).Limit(-1).Count() + return +} + +func (d dokumentDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = d.Count() + if err != nil { + return + } + + err = d.Offset(offset).Limit(limit).Scan(result) + return +} + +func (d dokumentDo) Scan(result interface{}) (err error) { + return d.DO.Scan(result) +} + +func (d dokumentDo) Delete(models ...*model.Dokument) (result gen.ResultInfo, err error) { + return d.DO.Delete(models) +} + +func (d *dokumentDo) withDO(do gen.Dao) *dokumentDo { + d.DO = *do.(*gen.DO) + return d +} diff --git a/query/firma_ansprechpartner.gen.go b/query/firma_ansprechpartner.gen.go new file mode 100644 index 0000000..c8a5461 --- /dev/null +++ b/query/firma_ansprechpartner.gen.go @@ -0,0 +1,407 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newFirmaAnsprechpartner(db *gorm.DB, opts ...gen.DOOption) firmaAnsprechpartner { + _firmaAnsprechpartner := firmaAnsprechpartner{} + + _firmaAnsprechpartner.firmaAnsprechpartnerDo.UseDB(db, opts...) + _firmaAnsprechpartner.firmaAnsprechpartnerDo.UseModel(&model.FirmaAnsprechpartner{}) + + tableName := _firmaAnsprechpartner.firmaAnsprechpartnerDo.TableName() + _firmaAnsprechpartner.ALL = field.NewAsterisk(tableName) + _firmaAnsprechpartner.ID = field.NewUint(tableName, "id") + _firmaAnsprechpartner.CreatedAt = field.NewTime(tableName, "created_at") + _firmaAnsprechpartner.UpdatedAt = field.NewTime(tableName, "updated_at") + _firmaAnsprechpartner.DeletedAt = field.NewField(tableName, "deleted_at") + _firmaAnsprechpartner.AnsprechpartnerId = field.NewUint(tableName, "ansprechpartner_id") + _firmaAnsprechpartner.FirmaId = field.NewUint(tableName, "firma_id") + _firmaAnsprechpartner.Role = field.NewString(tableName, "role") + + _firmaAnsprechpartner.fillFieldMap() + + return _firmaAnsprechpartner +} + +type firmaAnsprechpartner struct { + firmaAnsprechpartnerDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + AnsprechpartnerId field.Uint + FirmaId field.Uint + Role field.String + + fieldMap map[string]field.Expr +} + +func (f firmaAnsprechpartner) Table(newTableName string) *firmaAnsprechpartner { + f.firmaAnsprechpartnerDo.UseTable(newTableName) + return f.updateTableName(newTableName) +} + +func (f firmaAnsprechpartner) As(alias string) *firmaAnsprechpartner { + f.firmaAnsprechpartnerDo.DO = *(f.firmaAnsprechpartnerDo.As(alias).(*gen.DO)) + return f.updateTableName(alias) +} + +func (f *firmaAnsprechpartner) updateTableName(table string) *firmaAnsprechpartner { + f.ALL = field.NewAsterisk(table) + f.ID = field.NewUint(table, "id") + f.CreatedAt = field.NewTime(table, "created_at") + f.UpdatedAt = field.NewTime(table, "updated_at") + f.DeletedAt = field.NewField(table, "deleted_at") + f.AnsprechpartnerId = field.NewUint(table, "ansprechpartner_id") + f.FirmaId = field.NewUint(table, "firma_id") + f.Role = field.NewString(table, "role") + + f.fillFieldMap() + + return f +} + +func (f *firmaAnsprechpartner) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := f.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (f *firmaAnsprechpartner) fillFieldMap() { + f.fieldMap = make(map[string]field.Expr, 7) + f.fieldMap["id"] = f.ID + f.fieldMap["created_at"] = f.CreatedAt + f.fieldMap["updated_at"] = f.UpdatedAt + f.fieldMap["deleted_at"] = f.DeletedAt + f.fieldMap["ansprechpartner_id"] = f.AnsprechpartnerId + f.fieldMap["firma_id"] = f.FirmaId + f.fieldMap["role"] = f.Role +} + +func (f firmaAnsprechpartner) clone(db *gorm.DB) firmaAnsprechpartner { + f.firmaAnsprechpartnerDo.ReplaceConnPool(db.Statement.ConnPool) + return f +} + +func (f firmaAnsprechpartner) replaceDB(db *gorm.DB) firmaAnsprechpartner { + f.firmaAnsprechpartnerDo.ReplaceDB(db) + return f +} + +type firmaAnsprechpartnerDo struct{ gen.DO } + +type IFirmaAnsprechpartnerDo interface { + gen.SubQuery + Debug() IFirmaAnsprechpartnerDo + WithContext(ctx context.Context) IFirmaAnsprechpartnerDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IFirmaAnsprechpartnerDo + WriteDB() IFirmaAnsprechpartnerDo + As(alias string) gen.Dao + Session(config *gorm.Session) IFirmaAnsprechpartnerDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IFirmaAnsprechpartnerDo + Not(conds ...gen.Condition) IFirmaAnsprechpartnerDo + Or(conds ...gen.Condition) IFirmaAnsprechpartnerDo + Select(conds ...field.Expr) IFirmaAnsprechpartnerDo + Where(conds ...gen.Condition) IFirmaAnsprechpartnerDo + Order(conds ...field.Expr) IFirmaAnsprechpartnerDo + Distinct(cols ...field.Expr) IFirmaAnsprechpartnerDo + Omit(cols ...field.Expr) IFirmaAnsprechpartnerDo + Join(table schema.Tabler, on ...field.Expr) IFirmaAnsprechpartnerDo + LeftJoin(table schema.Tabler, on ...field.Expr) IFirmaAnsprechpartnerDo + RightJoin(table schema.Tabler, on ...field.Expr) IFirmaAnsprechpartnerDo + Group(cols ...field.Expr) IFirmaAnsprechpartnerDo + Having(conds ...gen.Condition) IFirmaAnsprechpartnerDo + Limit(limit int) IFirmaAnsprechpartnerDo + Offset(offset int) IFirmaAnsprechpartnerDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IFirmaAnsprechpartnerDo + Unscoped() IFirmaAnsprechpartnerDo + Create(values ...*model.FirmaAnsprechpartner) error + CreateInBatches(values []*model.FirmaAnsprechpartner, batchSize int) error + Save(values ...*model.FirmaAnsprechpartner) error + First() (*model.FirmaAnsprechpartner, error) + Take() (*model.FirmaAnsprechpartner, error) + Last() (*model.FirmaAnsprechpartner, error) + Find() ([]*model.FirmaAnsprechpartner, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.FirmaAnsprechpartner, err error) + FindInBatches(result *[]*model.FirmaAnsprechpartner, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.FirmaAnsprechpartner) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IFirmaAnsprechpartnerDo + Assign(attrs ...field.AssignExpr) IFirmaAnsprechpartnerDo + Joins(fields ...field.RelationField) IFirmaAnsprechpartnerDo + Preload(fields ...field.RelationField) IFirmaAnsprechpartnerDo + FirstOrInit() (*model.FirmaAnsprechpartner, error) + FirstOrCreate() (*model.FirmaAnsprechpartner, error) + FindByPage(offset int, limit int) (result []*model.FirmaAnsprechpartner, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IFirmaAnsprechpartnerDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (f firmaAnsprechpartnerDo) Debug() IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Debug()) +} + +func (f firmaAnsprechpartnerDo) WithContext(ctx context.Context) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.WithContext(ctx)) +} + +func (f firmaAnsprechpartnerDo) ReadDB() IFirmaAnsprechpartnerDo { + return f.Clauses(dbresolver.Read) +} + +func (f firmaAnsprechpartnerDo) WriteDB() IFirmaAnsprechpartnerDo { + return f.Clauses(dbresolver.Write) +} + +func (f firmaAnsprechpartnerDo) Session(config *gorm.Session) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Session(config)) +} + +func (f firmaAnsprechpartnerDo) Clauses(conds ...clause.Expression) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Clauses(conds...)) +} + +func (f firmaAnsprechpartnerDo) Returning(value interface{}, columns ...string) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Returning(value, columns...)) +} + +func (f firmaAnsprechpartnerDo) Not(conds ...gen.Condition) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Not(conds...)) +} + +func (f firmaAnsprechpartnerDo) Or(conds ...gen.Condition) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Or(conds...)) +} + +func (f firmaAnsprechpartnerDo) Select(conds ...field.Expr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Select(conds...)) +} + +func (f firmaAnsprechpartnerDo) Where(conds ...gen.Condition) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Where(conds...)) +} + +func (f firmaAnsprechpartnerDo) Order(conds ...field.Expr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Order(conds...)) +} + +func (f firmaAnsprechpartnerDo) Distinct(cols ...field.Expr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Distinct(cols...)) +} + +func (f firmaAnsprechpartnerDo) Omit(cols ...field.Expr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Omit(cols...)) +} + +func (f firmaAnsprechpartnerDo) Join(table schema.Tabler, on ...field.Expr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Join(table, on...)) +} + +func (f firmaAnsprechpartnerDo) LeftJoin(table schema.Tabler, on ...field.Expr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.LeftJoin(table, on...)) +} + +func (f firmaAnsprechpartnerDo) RightJoin(table schema.Tabler, on ...field.Expr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.RightJoin(table, on...)) +} + +func (f firmaAnsprechpartnerDo) Group(cols ...field.Expr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Group(cols...)) +} + +func (f firmaAnsprechpartnerDo) Having(conds ...gen.Condition) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Having(conds...)) +} + +func (f firmaAnsprechpartnerDo) Limit(limit int) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Limit(limit)) +} + +func (f firmaAnsprechpartnerDo) Offset(offset int) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Offset(offset)) +} + +func (f firmaAnsprechpartnerDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Scopes(funcs...)) +} + +func (f firmaAnsprechpartnerDo) Unscoped() IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Unscoped()) +} + +func (f firmaAnsprechpartnerDo) Create(values ...*model.FirmaAnsprechpartner) error { + if len(values) == 0 { + return nil + } + return f.DO.Create(values) +} + +func (f firmaAnsprechpartnerDo) CreateInBatches(values []*model.FirmaAnsprechpartner, batchSize int) error { + return f.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (f firmaAnsprechpartnerDo) Save(values ...*model.FirmaAnsprechpartner) error { + if len(values) == 0 { + return nil + } + return f.DO.Save(values) +} + +func (f firmaAnsprechpartnerDo) First() (*model.FirmaAnsprechpartner, error) { + if result, err := f.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.FirmaAnsprechpartner), nil + } +} + +func (f firmaAnsprechpartnerDo) Take() (*model.FirmaAnsprechpartner, error) { + if result, err := f.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.FirmaAnsprechpartner), nil + } +} + +func (f firmaAnsprechpartnerDo) Last() (*model.FirmaAnsprechpartner, error) { + if result, err := f.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.FirmaAnsprechpartner), nil + } +} + +func (f firmaAnsprechpartnerDo) Find() ([]*model.FirmaAnsprechpartner, error) { + result, err := f.DO.Find() + return result.([]*model.FirmaAnsprechpartner), err +} + +func (f firmaAnsprechpartnerDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.FirmaAnsprechpartner, err error) { + buf := make([]*model.FirmaAnsprechpartner, 0, batchSize) + err = f.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (f firmaAnsprechpartnerDo) FindInBatches(result *[]*model.FirmaAnsprechpartner, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return f.DO.FindInBatches(result, batchSize, fc) +} + +func (f firmaAnsprechpartnerDo) Attrs(attrs ...field.AssignExpr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Attrs(attrs...)) +} + +func (f firmaAnsprechpartnerDo) Assign(attrs ...field.AssignExpr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Assign(attrs...)) +} + +func (f firmaAnsprechpartnerDo) Joins(fields ...field.RelationField) IFirmaAnsprechpartnerDo { + for _, _f := range fields { + f = *f.withDO(f.DO.Joins(_f)) + } + return &f +} + +func (f firmaAnsprechpartnerDo) Preload(fields ...field.RelationField) IFirmaAnsprechpartnerDo { + for _, _f := range fields { + f = *f.withDO(f.DO.Preload(_f)) + } + return &f +} + +func (f firmaAnsprechpartnerDo) FirstOrInit() (*model.FirmaAnsprechpartner, error) { + if result, err := f.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.FirmaAnsprechpartner), nil + } +} + +func (f firmaAnsprechpartnerDo) FirstOrCreate() (*model.FirmaAnsprechpartner, error) { + if result, err := f.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.FirmaAnsprechpartner), nil + } +} + +func (f firmaAnsprechpartnerDo) FindByPage(offset int, limit int) (result []*model.FirmaAnsprechpartner, count int64, err error) { + result, err = f.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = f.Offset(-1).Limit(-1).Count() + return +} + +func (f firmaAnsprechpartnerDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = f.Count() + if err != nil { + return + } + + err = f.Offset(offset).Limit(limit).Scan(result) + return +} + +func (f firmaAnsprechpartnerDo) Scan(result interface{}) (err error) { + return f.DO.Scan(result) +} + +func (f firmaAnsprechpartnerDo) Delete(models ...*model.FirmaAnsprechpartner) (result gen.ResultInfo, err error) { + return f.DO.Delete(models) +} + +func (f *firmaAnsprechpartnerDo) withDO(do gen.Dao) *firmaAnsprechpartnerDo { + f.DO = *do.(*gen.DO) + return f +} diff --git a/query/firmas.gen.go b/query/firmas.gen.go new file mode 100644 index 0000000..5177cf1 --- /dev/null +++ b/query/firmas.gen.go @@ -0,0 +1,630 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newFirma(db *gorm.DB, opts ...gen.DOOption) firma { + _firma := firma{} + + _firma.firmaDo.UseDB(db, opts...) + _firma.firmaDo.UseModel(&model.Firma{}) + + tableName := _firma.firmaDo.TableName() + _firma.ALL = field.NewAsterisk(tableName) + _firma.ID = field.NewUint(tableName, "id") + _firma.CreatedAt = field.NewTime(tableName, "created_at") + _firma.UpdatedAt = field.NewTime(tableName, "updated_at") + _firma.DeletedAt = field.NewField(tableName, "deleted_at") + _firma.FirmaTyp = field.NewInt(tableName, "firma_typ") + _firma.Name = field.NewString(tableName, "name") + _firma.InternerName = field.NewString(tableName, "interner_name") + _firma.Slug = field.NewString(tableName, "slug") + _firma.Branche = field.NewString(tableName, "branche") + _firma.ParentCompany = field.NewUint(tableName, "parent_company") + _firma.Tochergesellschaften = firmaHasManyTochergesellschaften{ + db: db.Session(&gorm.Session{}), + + RelationField: field.NewRelation("Tochergesellschaften", "model.Firma"), + Tochergesellschaften: struct { + field.RelationField + }{ + RelationField: field.NewRelation("Tochergesellschaften.Tochergesellschaften", "model.Firma"), + }, + Ansprechpartner: struct { + field.RelationField + Firmen struct { + field.RelationField + } + }{ + RelationField: field.NewRelation("Tochergesellschaften.Ansprechpartner", "model.Ansprechpartner"), + Firmen: struct { + field.RelationField + }{ + RelationField: field.NewRelation("Tochergesellschaften.Ansprechpartner.Firmen", "model.Firma"), + }, + }, + } + + _firma.Ansprechpartner = firmaManyToManyAnsprechpartner{ + db: db.Session(&gorm.Session{}), + + RelationField: field.NewRelation("Ansprechpartner", "model.Ansprechpartner"), + } + + _firma.fillFieldMap() + + return _firma +} + +type firma struct { + firmaDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + FirmaTyp field.Int + Name field.String + InternerName field.String + Slug field.String + Branche field.String + ParentCompany field.Uint + Tochergesellschaften firmaHasManyTochergesellschaften + + Ansprechpartner firmaManyToManyAnsprechpartner + + fieldMap map[string]field.Expr +} + +func (f firma) Table(newTableName string) *firma { + f.firmaDo.UseTable(newTableName) + return f.updateTableName(newTableName) +} + +func (f firma) As(alias string) *firma { + f.firmaDo.DO = *(f.firmaDo.As(alias).(*gen.DO)) + return f.updateTableName(alias) +} + +func (f *firma) updateTableName(table string) *firma { + f.ALL = field.NewAsterisk(table) + f.ID = field.NewUint(table, "id") + f.CreatedAt = field.NewTime(table, "created_at") + f.UpdatedAt = field.NewTime(table, "updated_at") + f.DeletedAt = field.NewField(table, "deleted_at") + f.FirmaTyp = field.NewInt(table, "firma_typ") + f.Name = field.NewString(table, "name") + f.InternerName = field.NewString(table, "interner_name") + f.Slug = field.NewString(table, "slug") + f.Branche = field.NewString(table, "branche") + f.ParentCompany = field.NewUint(table, "parent_company") + + f.fillFieldMap() + + return f +} + +func (f *firma) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := f.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (f *firma) fillFieldMap() { + f.fieldMap = make(map[string]field.Expr, 12) + f.fieldMap["id"] = f.ID + f.fieldMap["created_at"] = f.CreatedAt + f.fieldMap["updated_at"] = f.UpdatedAt + f.fieldMap["deleted_at"] = f.DeletedAt + f.fieldMap["firma_typ"] = f.FirmaTyp + f.fieldMap["name"] = f.Name + f.fieldMap["interner_name"] = f.InternerName + f.fieldMap["slug"] = f.Slug + f.fieldMap["branche"] = f.Branche + f.fieldMap["parent_company"] = f.ParentCompany + +} + +func (f firma) clone(db *gorm.DB) firma { + f.firmaDo.ReplaceConnPool(db.Statement.ConnPool) + f.Tochergesellschaften.db = db.Session(&gorm.Session{Initialized: true}) + f.Tochergesellschaften.db.Statement.ConnPool = db.Statement.ConnPool + f.Ansprechpartner.db = db.Session(&gorm.Session{Initialized: true}) + f.Ansprechpartner.db.Statement.ConnPool = db.Statement.ConnPool + return f +} + +func (f firma) replaceDB(db *gorm.DB) firma { + f.firmaDo.ReplaceDB(db) + f.Tochergesellschaften.db = db.Session(&gorm.Session{}) + f.Ansprechpartner.db = db.Session(&gorm.Session{}) + return f +} + +type firmaHasManyTochergesellschaften struct { + db *gorm.DB + + field.RelationField + + Tochergesellschaften struct { + field.RelationField + } + Ansprechpartner struct { + field.RelationField + Firmen struct { + field.RelationField + } + } +} + +func (a firmaHasManyTochergesellschaften) Where(conds ...field.Expr) *firmaHasManyTochergesellschaften { + if len(conds) == 0 { + return &a + } + + exprs := make([]clause.Expression, 0, len(conds)) + for _, cond := range conds { + exprs = append(exprs, cond.BeCond().(clause.Expression)) + } + a.db = a.db.Clauses(clause.Where{Exprs: exprs}) + return &a +} + +func (a firmaHasManyTochergesellschaften) WithContext(ctx context.Context) *firmaHasManyTochergesellschaften { + a.db = a.db.WithContext(ctx) + return &a +} + +func (a firmaHasManyTochergesellschaften) Session(session *gorm.Session) *firmaHasManyTochergesellschaften { + a.db = a.db.Session(session) + return &a +} + +func (a firmaHasManyTochergesellschaften) Model(m *model.Firma) *firmaHasManyTochergesellschaftenTx { + return &firmaHasManyTochergesellschaftenTx{a.db.Model(m).Association(a.Name())} +} + +func (a firmaHasManyTochergesellschaften) Unscoped() *firmaHasManyTochergesellschaften { + a.db = a.db.Unscoped() + return &a +} + +type firmaHasManyTochergesellschaftenTx struct{ tx *gorm.Association } + +func (a firmaHasManyTochergesellschaftenTx) Find() (result []*model.Firma, err error) { + return result, a.tx.Find(&result) +} + +func (a firmaHasManyTochergesellschaftenTx) Append(values ...*model.Firma) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Append(targetValues...) +} + +func (a firmaHasManyTochergesellschaftenTx) Replace(values ...*model.Firma) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Replace(targetValues...) +} + +func (a firmaHasManyTochergesellschaftenTx) Delete(values ...*model.Firma) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Delete(targetValues...) +} + +func (a firmaHasManyTochergesellschaftenTx) Clear() error { + return a.tx.Clear() +} + +func (a firmaHasManyTochergesellschaftenTx) Count() int64 { + return a.tx.Count() +} + +func (a firmaHasManyTochergesellschaftenTx) Unscoped() *firmaHasManyTochergesellschaftenTx { + a.tx = a.tx.Unscoped() + return &a +} + +type firmaManyToManyAnsprechpartner struct { + db *gorm.DB + + field.RelationField +} + +func (a firmaManyToManyAnsprechpartner) Where(conds ...field.Expr) *firmaManyToManyAnsprechpartner { + if len(conds) == 0 { + return &a + } + + exprs := make([]clause.Expression, 0, len(conds)) + for _, cond := range conds { + exprs = append(exprs, cond.BeCond().(clause.Expression)) + } + a.db = a.db.Clauses(clause.Where{Exprs: exprs}) + return &a +} + +func (a firmaManyToManyAnsprechpartner) WithContext(ctx context.Context) *firmaManyToManyAnsprechpartner { + a.db = a.db.WithContext(ctx) + return &a +} + +func (a firmaManyToManyAnsprechpartner) Session(session *gorm.Session) *firmaManyToManyAnsprechpartner { + a.db = a.db.Session(session) + return &a +} + +func (a firmaManyToManyAnsprechpartner) Model(m *model.Firma) *firmaManyToManyAnsprechpartnerTx { + return &firmaManyToManyAnsprechpartnerTx{a.db.Model(m).Association(a.Name())} +} + +func (a firmaManyToManyAnsprechpartner) Unscoped() *firmaManyToManyAnsprechpartner { + a.db = a.db.Unscoped() + return &a +} + +type firmaManyToManyAnsprechpartnerTx struct{ tx *gorm.Association } + +func (a firmaManyToManyAnsprechpartnerTx) Find() (result []*model.Ansprechpartner, err error) { + return result, a.tx.Find(&result) +} + +func (a firmaManyToManyAnsprechpartnerTx) Append(values ...*model.Ansprechpartner) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Append(targetValues...) +} + +func (a firmaManyToManyAnsprechpartnerTx) Replace(values ...*model.Ansprechpartner) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Replace(targetValues...) +} + +func (a firmaManyToManyAnsprechpartnerTx) Delete(values ...*model.Ansprechpartner) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Delete(targetValues...) +} + +func (a firmaManyToManyAnsprechpartnerTx) Clear() error { + return a.tx.Clear() +} + +func (a firmaManyToManyAnsprechpartnerTx) Count() int64 { + return a.tx.Count() +} + +func (a firmaManyToManyAnsprechpartnerTx) Unscoped() *firmaManyToManyAnsprechpartnerTx { + a.tx = a.tx.Unscoped() + return &a +} + +type firmaDo struct{ gen.DO } + +type IFirmaDo interface { + gen.SubQuery + Debug() IFirmaDo + WithContext(ctx context.Context) IFirmaDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IFirmaDo + WriteDB() IFirmaDo + As(alias string) gen.Dao + Session(config *gorm.Session) IFirmaDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IFirmaDo + Not(conds ...gen.Condition) IFirmaDo + Or(conds ...gen.Condition) IFirmaDo + Select(conds ...field.Expr) IFirmaDo + Where(conds ...gen.Condition) IFirmaDo + Order(conds ...field.Expr) IFirmaDo + Distinct(cols ...field.Expr) IFirmaDo + Omit(cols ...field.Expr) IFirmaDo + Join(table schema.Tabler, on ...field.Expr) IFirmaDo + LeftJoin(table schema.Tabler, on ...field.Expr) IFirmaDo + RightJoin(table schema.Tabler, on ...field.Expr) IFirmaDo + Group(cols ...field.Expr) IFirmaDo + Having(conds ...gen.Condition) IFirmaDo + Limit(limit int) IFirmaDo + Offset(offset int) IFirmaDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IFirmaDo + Unscoped() IFirmaDo + Create(values ...*model.Firma) error + CreateInBatches(values []*model.Firma, batchSize int) error + Save(values ...*model.Firma) error + First() (*model.Firma, error) + Take() (*model.Firma, error) + Last() (*model.Firma, error) + Find() ([]*model.Firma, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Firma, err error) + FindInBatches(result *[]*model.Firma, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Firma) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IFirmaDo + Assign(attrs ...field.AssignExpr) IFirmaDo + Joins(fields ...field.RelationField) IFirmaDo + Preload(fields ...field.RelationField) IFirmaDo + FirstOrInit() (*model.Firma, error) + FirstOrCreate() (*model.Firma, error) + FindByPage(offset int, limit int) (result []*model.Firma, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IFirmaDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (f firmaDo) Debug() IFirmaDo { + return f.withDO(f.DO.Debug()) +} + +func (f firmaDo) WithContext(ctx context.Context) IFirmaDo { + return f.withDO(f.DO.WithContext(ctx)) +} + +func (f firmaDo) ReadDB() IFirmaDo { + return f.Clauses(dbresolver.Read) +} + +func (f firmaDo) WriteDB() IFirmaDo { + return f.Clauses(dbresolver.Write) +} + +func (f firmaDo) Session(config *gorm.Session) IFirmaDo { + return f.withDO(f.DO.Session(config)) +} + +func (f firmaDo) Clauses(conds ...clause.Expression) IFirmaDo { + return f.withDO(f.DO.Clauses(conds...)) +} + +func (f firmaDo) Returning(value interface{}, columns ...string) IFirmaDo { + return f.withDO(f.DO.Returning(value, columns...)) +} + +func (f firmaDo) Not(conds ...gen.Condition) IFirmaDo { + return f.withDO(f.DO.Not(conds...)) +} + +func (f firmaDo) Or(conds ...gen.Condition) IFirmaDo { + return f.withDO(f.DO.Or(conds...)) +} + +func (f firmaDo) Select(conds ...field.Expr) IFirmaDo { + return f.withDO(f.DO.Select(conds...)) +} + +func (f firmaDo) Where(conds ...gen.Condition) IFirmaDo { + return f.withDO(f.DO.Where(conds...)) +} + +func (f firmaDo) Order(conds ...field.Expr) IFirmaDo { + return f.withDO(f.DO.Order(conds...)) +} + +func (f firmaDo) Distinct(cols ...field.Expr) IFirmaDo { + return f.withDO(f.DO.Distinct(cols...)) +} + +func (f firmaDo) Omit(cols ...field.Expr) IFirmaDo { + return f.withDO(f.DO.Omit(cols...)) +} + +func (f firmaDo) Join(table schema.Tabler, on ...field.Expr) IFirmaDo { + return f.withDO(f.DO.Join(table, on...)) +} + +func (f firmaDo) LeftJoin(table schema.Tabler, on ...field.Expr) IFirmaDo { + return f.withDO(f.DO.LeftJoin(table, on...)) +} + +func (f firmaDo) RightJoin(table schema.Tabler, on ...field.Expr) IFirmaDo { + return f.withDO(f.DO.RightJoin(table, on...)) +} + +func (f firmaDo) Group(cols ...field.Expr) IFirmaDo { + return f.withDO(f.DO.Group(cols...)) +} + +func (f firmaDo) Having(conds ...gen.Condition) IFirmaDo { + return f.withDO(f.DO.Having(conds...)) +} + +func (f firmaDo) Limit(limit int) IFirmaDo { + return f.withDO(f.DO.Limit(limit)) +} + +func (f firmaDo) Offset(offset int) IFirmaDo { + return f.withDO(f.DO.Offset(offset)) +} + +func (f firmaDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IFirmaDo { + return f.withDO(f.DO.Scopes(funcs...)) +} + +func (f firmaDo) Unscoped() IFirmaDo { + return f.withDO(f.DO.Unscoped()) +} + +func (f firmaDo) Create(values ...*model.Firma) error { + if len(values) == 0 { + return nil + } + return f.DO.Create(values) +} + +func (f firmaDo) CreateInBatches(values []*model.Firma, batchSize int) error { + return f.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (f firmaDo) Save(values ...*model.Firma) error { + if len(values) == 0 { + return nil + } + return f.DO.Save(values) +} + +func (f firmaDo) First() (*model.Firma, error) { + if result, err := f.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Firma), nil + } +} + +func (f firmaDo) Take() (*model.Firma, error) { + if result, err := f.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Firma), nil + } +} + +func (f firmaDo) Last() (*model.Firma, error) { + if result, err := f.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Firma), nil + } +} + +func (f firmaDo) Find() ([]*model.Firma, error) { + result, err := f.DO.Find() + return result.([]*model.Firma), err +} + +func (f firmaDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Firma, err error) { + buf := make([]*model.Firma, 0, batchSize) + err = f.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (f firmaDo) FindInBatches(result *[]*model.Firma, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return f.DO.FindInBatches(result, batchSize, fc) +} + +func (f firmaDo) Attrs(attrs ...field.AssignExpr) IFirmaDo { + return f.withDO(f.DO.Attrs(attrs...)) +} + +func (f firmaDo) Assign(attrs ...field.AssignExpr) IFirmaDo { + return f.withDO(f.DO.Assign(attrs...)) +} + +func (f firmaDo) Joins(fields ...field.RelationField) IFirmaDo { + for _, _f := range fields { + f = *f.withDO(f.DO.Joins(_f)) + } + return &f +} + +func (f firmaDo) Preload(fields ...field.RelationField) IFirmaDo { + for _, _f := range fields { + f = *f.withDO(f.DO.Preload(_f)) + } + return &f +} + +func (f firmaDo) FirstOrInit() (*model.Firma, error) { + if result, err := f.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Firma), nil + } +} + +func (f firmaDo) FirstOrCreate() (*model.Firma, error) { + if result, err := f.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Firma), nil + } +} + +func (f firmaDo) FindByPage(offset int, limit int) (result []*model.Firma, count int64, err error) { + result, err = f.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = f.Offset(-1).Limit(-1).Count() + return +} + +func (f firmaDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = f.Count() + if err != nil { + return + } + + err = f.Offset(offset).Limit(limit).Scan(result) + return +} + +func (f firmaDo) Scan(result interface{}) (err error) { + return f.DO.Scan(result) +} + +func (f firmaDo) Delete(models ...*model.Firma) (result gen.ResultInfo, err error) { + return f.DO.Delete(models) +} + +func (f *firmaDo) withDO(do gen.Dao) *firmaDo { + f.DO = *do.(*gen.DO) + return f +} diff --git a/query/gen.go b/query/gen.go new file mode 100644 index 0000000..fe42fea --- /dev/null +++ b/query/gen.go @@ -0,0 +1,231 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + + "gorm.io/gen" + + "gorm.io/plugin/dbresolver" +) + +var ( + Q = new(Query) + Ansprechpartner *ansprechpartner + Dokument *dokument + Firma *firma + FirmaAnsprechpartner *firmaAnsprechpartner + Kalender *kalender + Kalendereintrag *kalendereintrag + Kostenstelle *kostenstelle + Lager *lager + Lagerplatz *lagerplatz + Material *material + Nachricht *nachricht + Projekt *projekt + Rechnung *rechnung + Rechnungsposition *rechnungsposition + Scanobject *scanobject + User *user + Zahlung *zahlung +) + +func SetDefault(db *gorm.DB, opts ...gen.DOOption) { + *Q = *Use(db, opts...) + Ansprechpartner = &Q.Ansprechpartner + Dokument = &Q.Dokument + Firma = &Q.Firma + FirmaAnsprechpartner = &Q.FirmaAnsprechpartner + Kalender = &Q.Kalender + Kalendereintrag = &Q.Kalendereintrag + Kostenstelle = &Q.Kostenstelle + Lager = &Q.Lager + Lagerplatz = &Q.Lagerplatz + Material = &Q.Material + Nachricht = &Q.Nachricht + Projekt = &Q.Projekt + Rechnung = &Q.Rechnung + Rechnungsposition = &Q.Rechnungsposition + Scanobject = &Q.Scanobject + User = &Q.User + Zahlung = &Q.Zahlung +} + +func Use(db *gorm.DB, opts ...gen.DOOption) *Query { + return &Query{ + db: db, + Ansprechpartner: newAnsprechpartner(db, opts...), + Dokument: newDokument(db, opts...), + Firma: newFirma(db, opts...), + FirmaAnsprechpartner: newFirmaAnsprechpartner(db, opts...), + Kalender: newKalender(db, opts...), + Kalendereintrag: newKalendereintrag(db, opts...), + Kostenstelle: newKostenstelle(db, opts...), + Lager: newLager(db, opts...), + Lagerplatz: newLagerplatz(db, opts...), + Material: newMaterial(db, opts...), + Nachricht: newNachricht(db, opts...), + Projekt: newProjekt(db, opts...), + Rechnung: newRechnung(db, opts...), + Rechnungsposition: newRechnungsposition(db, opts...), + Scanobject: newScanobject(db, opts...), + User: newUser(db, opts...), + Zahlung: newZahlung(db, opts...), + } +} + +type Query struct { + db *gorm.DB + + Ansprechpartner ansprechpartner + Dokument dokument + Firma firma + FirmaAnsprechpartner firmaAnsprechpartner + Kalender kalender + Kalendereintrag kalendereintrag + Kostenstelle kostenstelle + Lager lager + Lagerplatz lagerplatz + Material material + Nachricht nachricht + Projekt projekt + Rechnung rechnung + Rechnungsposition rechnungsposition + Scanobject scanobject + User user + Zahlung zahlung +} + +func (q *Query) Available() bool { return q.db != nil } + +func (q *Query) clone(db *gorm.DB) *Query { + return &Query{ + db: db, + Ansprechpartner: q.Ansprechpartner.clone(db), + Dokument: q.Dokument.clone(db), + Firma: q.Firma.clone(db), + FirmaAnsprechpartner: q.FirmaAnsprechpartner.clone(db), + Kalender: q.Kalender.clone(db), + Kalendereintrag: q.Kalendereintrag.clone(db), + Kostenstelle: q.Kostenstelle.clone(db), + Lager: q.Lager.clone(db), + Lagerplatz: q.Lagerplatz.clone(db), + Material: q.Material.clone(db), + Nachricht: q.Nachricht.clone(db), + Projekt: q.Projekt.clone(db), + Rechnung: q.Rechnung.clone(db), + Rechnungsposition: q.Rechnungsposition.clone(db), + Scanobject: q.Scanobject.clone(db), + User: q.User.clone(db), + Zahlung: q.Zahlung.clone(db), + } +} + +func (q *Query) ReadDB() *Query { + return q.ReplaceDB(q.db.Clauses(dbresolver.Read)) +} + +func (q *Query) WriteDB() *Query { + return q.ReplaceDB(q.db.Clauses(dbresolver.Write)) +} + +func (q *Query) ReplaceDB(db *gorm.DB) *Query { + return &Query{ + db: db, + Ansprechpartner: q.Ansprechpartner.replaceDB(db), + Dokument: q.Dokument.replaceDB(db), + Firma: q.Firma.replaceDB(db), + FirmaAnsprechpartner: q.FirmaAnsprechpartner.replaceDB(db), + Kalender: q.Kalender.replaceDB(db), + Kalendereintrag: q.Kalendereintrag.replaceDB(db), + Kostenstelle: q.Kostenstelle.replaceDB(db), + Lager: q.Lager.replaceDB(db), + Lagerplatz: q.Lagerplatz.replaceDB(db), + Material: q.Material.replaceDB(db), + Nachricht: q.Nachricht.replaceDB(db), + Projekt: q.Projekt.replaceDB(db), + Rechnung: q.Rechnung.replaceDB(db), + Rechnungsposition: q.Rechnungsposition.replaceDB(db), + Scanobject: q.Scanobject.replaceDB(db), + User: q.User.replaceDB(db), + Zahlung: q.Zahlung.replaceDB(db), + } +} + +type queryCtx struct { + Ansprechpartner IAnsprechpartnerDo + Dokument IDokumentDo + Firma IFirmaDo + FirmaAnsprechpartner IFirmaAnsprechpartnerDo + Kalender IKalenderDo + Kalendereintrag IKalendereintragDo + Kostenstelle IKostenstelleDo + Lager ILagerDo + Lagerplatz ILagerplatzDo + Material IMaterialDo + Nachricht INachrichtDo + Projekt IProjektDo + Rechnung IRechnungDo + Rechnungsposition IRechnungspositionDo + Scanobject IScanobjectDo + User IUserDo + Zahlung IZahlungDo +} + +func (q *Query) WithContext(ctx context.Context) *queryCtx { + return &queryCtx{ + Ansprechpartner: q.Ansprechpartner.WithContext(ctx), + Dokument: q.Dokument.WithContext(ctx), + Firma: q.Firma.WithContext(ctx), + FirmaAnsprechpartner: q.FirmaAnsprechpartner.WithContext(ctx), + Kalender: q.Kalender.WithContext(ctx), + Kalendereintrag: q.Kalendereintrag.WithContext(ctx), + Kostenstelle: q.Kostenstelle.WithContext(ctx), + Lager: q.Lager.WithContext(ctx), + Lagerplatz: q.Lagerplatz.WithContext(ctx), + Material: q.Material.WithContext(ctx), + Nachricht: q.Nachricht.WithContext(ctx), + Projekt: q.Projekt.WithContext(ctx), + Rechnung: q.Rechnung.WithContext(ctx), + Rechnungsposition: q.Rechnungsposition.WithContext(ctx), + Scanobject: q.Scanobject.WithContext(ctx), + User: q.User.WithContext(ctx), + Zahlung: q.Zahlung.WithContext(ctx), + } +} + +func (q *Query) Transaction(fc func(tx *Query) error, opts ...*sql.TxOptions) error { + return q.db.Transaction(func(tx *gorm.DB) error { return fc(q.clone(tx)) }, opts...) +} + +func (q *Query) Begin(opts ...*sql.TxOptions) *QueryTx { + tx := q.db.Begin(opts...) + return &QueryTx{Query: q.clone(tx), Error: tx.Error} +} + +type QueryTx struct { + *Query + Error error +} + +func (q *QueryTx) Commit() error { + return q.db.Commit().Error +} + +func (q *QueryTx) Rollback() error { + return q.db.Rollback().Error +} + +func (q *QueryTx) SavePoint(name string) error { + return q.db.SavePoint(name).Error +} + +func (q *QueryTx) RollbackTo(name string) error { + return q.db.RollbackTo(name).Error +} diff --git a/query/kalendereintrags.gen.go b/query/kalendereintrags.gen.go new file mode 100644 index 0000000..dd5ea58 --- /dev/null +++ b/query/kalendereintrags.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newKalendereintrag(db *gorm.DB, opts ...gen.DOOption) kalendereintrag { + _kalendereintrag := kalendereintrag{} + + _kalendereintrag.kalendereintragDo.UseDB(db, opts...) + _kalendereintrag.kalendereintragDo.UseModel(&model.Kalendereintrag{}) + + tableName := _kalendereintrag.kalendereintragDo.TableName() + _kalendereintrag.ALL = field.NewAsterisk(tableName) + _kalendereintrag.ID = field.NewUint(tableName, "id") + _kalendereintrag.CreatedAt = field.NewTime(tableName, "created_at") + _kalendereintrag.UpdatedAt = field.NewTime(tableName, "updated_at") + _kalendereintrag.DeletedAt = field.NewField(tableName, "deleted_at") + + _kalendereintrag.fillFieldMap() + + return _kalendereintrag +} + +type kalendereintrag struct { + kalendereintragDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (k kalendereintrag) Table(newTableName string) *kalendereintrag { + k.kalendereintragDo.UseTable(newTableName) + return k.updateTableName(newTableName) +} + +func (k kalendereintrag) As(alias string) *kalendereintrag { + k.kalendereintragDo.DO = *(k.kalendereintragDo.As(alias).(*gen.DO)) + return k.updateTableName(alias) +} + +func (k *kalendereintrag) updateTableName(table string) *kalendereintrag { + k.ALL = field.NewAsterisk(table) + k.ID = field.NewUint(table, "id") + k.CreatedAt = field.NewTime(table, "created_at") + k.UpdatedAt = field.NewTime(table, "updated_at") + k.DeletedAt = field.NewField(table, "deleted_at") + + k.fillFieldMap() + + return k +} + +func (k *kalendereintrag) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := k.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (k *kalendereintrag) fillFieldMap() { + k.fieldMap = make(map[string]field.Expr, 4) + k.fieldMap["id"] = k.ID + k.fieldMap["created_at"] = k.CreatedAt + k.fieldMap["updated_at"] = k.UpdatedAt + k.fieldMap["deleted_at"] = k.DeletedAt +} + +func (k kalendereintrag) clone(db *gorm.DB) kalendereintrag { + k.kalendereintragDo.ReplaceConnPool(db.Statement.ConnPool) + return k +} + +func (k kalendereintrag) replaceDB(db *gorm.DB) kalendereintrag { + k.kalendereintragDo.ReplaceDB(db) + return k +} + +type kalendereintragDo struct{ gen.DO } + +type IKalendereintragDo interface { + gen.SubQuery + Debug() IKalendereintragDo + WithContext(ctx context.Context) IKalendereintragDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IKalendereintragDo + WriteDB() IKalendereintragDo + As(alias string) gen.Dao + Session(config *gorm.Session) IKalendereintragDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IKalendereintragDo + Not(conds ...gen.Condition) IKalendereintragDo + Or(conds ...gen.Condition) IKalendereintragDo + Select(conds ...field.Expr) IKalendereintragDo + Where(conds ...gen.Condition) IKalendereintragDo + Order(conds ...field.Expr) IKalendereintragDo + Distinct(cols ...field.Expr) IKalendereintragDo + Omit(cols ...field.Expr) IKalendereintragDo + Join(table schema.Tabler, on ...field.Expr) IKalendereintragDo + LeftJoin(table schema.Tabler, on ...field.Expr) IKalendereintragDo + RightJoin(table schema.Tabler, on ...field.Expr) IKalendereintragDo + Group(cols ...field.Expr) IKalendereintragDo + Having(conds ...gen.Condition) IKalendereintragDo + Limit(limit int) IKalendereintragDo + Offset(offset int) IKalendereintragDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IKalendereintragDo + Unscoped() IKalendereintragDo + Create(values ...*model.Kalendereintrag) error + CreateInBatches(values []*model.Kalendereintrag, batchSize int) error + Save(values ...*model.Kalendereintrag) error + First() (*model.Kalendereintrag, error) + Take() (*model.Kalendereintrag, error) + Last() (*model.Kalendereintrag, error) + Find() ([]*model.Kalendereintrag, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Kalendereintrag, err error) + FindInBatches(result *[]*model.Kalendereintrag, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Kalendereintrag) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IKalendereintragDo + Assign(attrs ...field.AssignExpr) IKalendereintragDo + Joins(fields ...field.RelationField) IKalendereintragDo + Preload(fields ...field.RelationField) IKalendereintragDo + FirstOrInit() (*model.Kalendereintrag, error) + FirstOrCreate() (*model.Kalendereintrag, error) + FindByPage(offset int, limit int) (result []*model.Kalendereintrag, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IKalendereintragDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (k kalendereintragDo) Debug() IKalendereintragDo { + return k.withDO(k.DO.Debug()) +} + +func (k kalendereintragDo) WithContext(ctx context.Context) IKalendereintragDo { + return k.withDO(k.DO.WithContext(ctx)) +} + +func (k kalendereintragDo) ReadDB() IKalendereintragDo { + return k.Clauses(dbresolver.Read) +} + +func (k kalendereintragDo) WriteDB() IKalendereintragDo { + return k.Clauses(dbresolver.Write) +} + +func (k kalendereintragDo) Session(config *gorm.Session) IKalendereintragDo { + return k.withDO(k.DO.Session(config)) +} + +func (k kalendereintragDo) Clauses(conds ...clause.Expression) IKalendereintragDo { + return k.withDO(k.DO.Clauses(conds...)) +} + +func (k kalendereintragDo) Returning(value interface{}, columns ...string) IKalendereintragDo { + return k.withDO(k.DO.Returning(value, columns...)) +} + +func (k kalendereintragDo) Not(conds ...gen.Condition) IKalendereintragDo { + return k.withDO(k.DO.Not(conds...)) +} + +func (k kalendereintragDo) Or(conds ...gen.Condition) IKalendereintragDo { + return k.withDO(k.DO.Or(conds...)) +} + +func (k kalendereintragDo) Select(conds ...field.Expr) IKalendereintragDo { + return k.withDO(k.DO.Select(conds...)) +} + +func (k kalendereintragDo) Where(conds ...gen.Condition) IKalendereintragDo { + return k.withDO(k.DO.Where(conds...)) +} + +func (k kalendereintragDo) Order(conds ...field.Expr) IKalendereintragDo { + return k.withDO(k.DO.Order(conds...)) +} + +func (k kalendereintragDo) Distinct(cols ...field.Expr) IKalendereintragDo { + return k.withDO(k.DO.Distinct(cols...)) +} + +func (k kalendereintragDo) Omit(cols ...field.Expr) IKalendereintragDo { + return k.withDO(k.DO.Omit(cols...)) +} + +func (k kalendereintragDo) Join(table schema.Tabler, on ...field.Expr) IKalendereintragDo { + return k.withDO(k.DO.Join(table, on...)) +} + +func (k kalendereintragDo) LeftJoin(table schema.Tabler, on ...field.Expr) IKalendereintragDo { + return k.withDO(k.DO.LeftJoin(table, on...)) +} + +func (k kalendereintragDo) RightJoin(table schema.Tabler, on ...field.Expr) IKalendereintragDo { + return k.withDO(k.DO.RightJoin(table, on...)) +} + +func (k kalendereintragDo) Group(cols ...field.Expr) IKalendereintragDo { + return k.withDO(k.DO.Group(cols...)) +} + +func (k kalendereintragDo) Having(conds ...gen.Condition) IKalendereintragDo { + return k.withDO(k.DO.Having(conds...)) +} + +func (k kalendereintragDo) Limit(limit int) IKalendereintragDo { + return k.withDO(k.DO.Limit(limit)) +} + +func (k kalendereintragDo) Offset(offset int) IKalendereintragDo { + return k.withDO(k.DO.Offset(offset)) +} + +func (k kalendereintragDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IKalendereintragDo { + return k.withDO(k.DO.Scopes(funcs...)) +} + +func (k kalendereintragDo) Unscoped() IKalendereintragDo { + return k.withDO(k.DO.Unscoped()) +} + +func (k kalendereintragDo) Create(values ...*model.Kalendereintrag) error { + if len(values) == 0 { + return nil + } + return k.DO.Create(values) +} + +func (k kalendereintragDo) CreateInBatches(values []*model.Kalendereintrag, batchSize int) error { + return k.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (k kalendereintragDo) Save(values ...*model.Kalendereintrag) error { + if len(values) == 0 { + return nil + } + return k.DO.Save(values) +} + +func (k kalendereintragDo) First() (*model.Kalendereintrag, error) { + if result, err := k.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Kalendereintrag), nil + } +} + +func (k kalendereintragDo) Take() (*model.Kalendereintrag, error) { + if result, err := k.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Kalendereintrag), nil + } +} + +func (k kalendereintragDo) Last() (*model.Kalendereintrag, error) { + if result, err := k.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Kalendereintrag), nil + } +} + +func (k kalendereintragDo) Find() ([]*model.Kalendereintrag, error) { + result, err := k.DO.Find() + return result.([]*model.Kalendereintrag), err +} + +func (k kalendereintragDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Kalendereintrag, err error) { + buf := make([]*model.Kalendereintrag, 0, batchSize) + err = k.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (k kalendereintragDo) FindInBatches(result *[]*model.Kalendereintrag, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return k.DO.FindInBatches(result, batchSize, fc) +} + +func (k kalendereintragDo) Attrs(attrs ...field.AssignExpr) IKalendereintragDo { + return k.withDO(k.DO.Attrs(attrs...)) +} + +func (k kalendereintragDo) Assign(attrs ...field.AssignExpr) IKalendereintragDo { + return k.withDO(k.DO.Assign(attrs...)) +} + +func (k kalendereintragDo) Joins(fields ...field.RelationField) IKalendereintragDo { + for _, _f := range fields { + k = *k.withDO(k.DO.Joins(_f)) + } + return &k +} + +func (k kalendereintragDo) Preload(fields ...field.RelationField) IKalendereintragDo { + for _, _f := range fields { + k = *k.withDO(k.DO.Preload(_f)) + } + return &k +} + +func (k kalendereintragDo) FirstOrInit() (*model.Kalendereintrag, error) { + if result, err := k.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Kalendereintrag), nil + } +} + +func (k kalendereintragDo) FirstOrCreate() (*model.Kalendereintrag, error) { + if result, err := k.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Kalendereintrag), nil + } +} + +func (k kalendereintragDo) FindByPage(offset int, limit int) (result []*model.Kalendereintrag, count int64, err error) { + result, err = k.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = k.Offset(-1).Limit(-1).Count() + return +} + +func (k kalendereintragDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = k.Count() + if err != nil { + return + } + + err = k.Offset(offset).Limit(limit).Scan(result) + return +} + +func (k kalendereintragDo) Scan(result interface{}) (err error) { + return k.DO.Scan(result) +} + +func (k kalendereintragDo) Delete(models ...*model.Kalendereintrag) (result gen.ResultInfo, err error) { + return k.DO.Delete(models) +} + +func (k *kalendereintragDo) withDO(do gen.Dao) *kalendereintragDo { + k.DO = *do.(*gen.DO) + return k +} diff --git a/query/kalenders.gen.go b/query/kalenders.gen.go new file mode 100644 index 0000000..2993174 --- /dev/null +++ b/query/kalenders.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newKalender(db *gorm.DB, opts ...gen.DOOption) kalender { + _kalender := kalender{} + + _kalender.kalenderDo.UseDB(db, opts...) + _kalender.kalenderDo.UseModel(&model.Kalender{}) + + tableName := _kalender.kalenderDo.TableName() + _kalender.ALL = field.NewAsterisk(tableName) + _kalender.ID = field.NewUint(tableName, "id") + _kalender.CreatedAt = field.NewTime(tableName, "created_at") + _kalender.UpdatedAt = field.NewTime(tableName, "updated_at") + _kalender.DeletedAt = field.NewField(tableName, "deleted_at") + + _kalender.fillFieldMap() + + return _kalender +} + +type kalender struct { + kalenderDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (k kalender) Table(newTableName string) *kalender { + k.kalenderDo.UseTable(newTableName) + return k.updateTableName(newTableName) +} + +func (k kalender) As(alias string) *kalender { + k.kalenderDo.DO = *(k.kalenderDo.As(alias).(*gen.DO)) + return k.updateTableName(alias) +} + +func (k *kalender) updateTableName(table string) *kalender { + k.ALL = field.NewAsterisk(table) + k.ID = field.NewUint(table, "id") + k.CreatedAt = field.NewTime(table, "created_at") + k.UpdatedAt = field.NewTime(table, "updated_at") + k.DeletedAt = field.NewField(table, "deleted_at") + + k.fillFieldMap() + + return k +} + +func (k *kalender) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := k.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (k *kalender) fillFieldMap() { + k.fieldMap = make(map[string]field.Expr, 4) + k.fieldMap["id"] = k.ID + k.fieldMap["created_at"] = k.CreatedAt + k.fieldMap["updated_at"] = k.UpdatedAt + k.fieldMap["deleted_at"] = k.DeletedAt +} + +func (k kalender) clone(db *gorm.DB) kalender { + k.kalenderDo.ReplaceConnPool(db.Statement.ConnPool) + return k +} + +func (k kalender) replaceDB(db *gorm.DB) kalender { + k.kalenderDo.ReplaceDB(db) + return k +} + +type kalenderDo struct{ gen.DO } + +type IKalenderDo interface { + gen.SubQuery + Debug() IKalenderDo + WithContext(ctx context.Context) IKalenderDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IKalenderDo + WriteDB() IKalenderDo + As(alias string) gen.Dao + Session(config *gorm.Session) IKalenderDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IKalenderDo + Not(conds ...gen.Condition) IKalenderDo + Or(conds ...gen.Condition) IKalenderDo + Select(conds ...field.Expr) IKalenderDo + Where(conds ...gen.Condition) IKalenderDo + Order(conds ...field.Expr) IKalenderDo + Distinct(cols ...field.Expr) IKalenderDo + Omit(cols ...field.Expr) IKalenderDo + Join(table schema.Tabler, on ...field.Expr) IKalenderDo + LeftJoin(table schema.Tabler, on ...field.Expr) IKalenderDo + RightJoin(table schema.Tabler, on ...field.Expr) IKalenderDo + Group(cols ...field.Expr) IKalenderDo + Having(conds ...gen.Condition) IKalenderDo + Limit(limit int) IKalenderDo + Offset(offset int) IKalenderDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IKalenderDo + Unscoped() IKalenderDo + Create(values ...*model.Kalender) error + CreateInBatches(values []*model.Kalender, batchSize int) error + Save(values ...*model.Kalender) error + First() (*model.Kalender, error) + Take() (*model.Kalender, error) + Last() (*model.Kalender, error) + Find() ([]*model.Kalender, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Kalender, err error) + FindInBatches(result *[]*model.Kalender, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Kalender) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IKalenderDo + Assign(attrs ...field.AssignExpr) IKalenderDo + Joins(fields ...field.RelationField) IKalenderDo + Preload(fields ...field.RelationField) IKalenderDo + FirstOrInit() (*model.Kalender, error) + FirstOrCreate() (*model.Kalender, error) + FindByPage(offset int, limit int) (result []*model.Kalender, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IKalenderDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (k kalenderDo) Debug() IKalenderDo { + return k.withDO(k.DO.Debug()) +} + +func (k kalenderDo) WithContext(ctx context.Context) IKalenderDo { + return k.withDO(k.DO.WithContext(ctx)) +} + +func (k kalenderDo) ReadDB() IKalenderDo { + return k.Clauses(dbresolver.Read) +} + +func (k kalenderDo) WriteDB() IKalenderDo { + return k.Clauses(dbresolver.Write) +} + +func (k kalenderDo) Session(config *gorm.Session) IKalenderDo { + return k.withDO(k.DO.Session(config)) +} + +func (k kalenderDo) Clauses(conds ...clause.Expression) IKalenderDo { + return k.withDO(k.DO.Clauses(conds...)) +} + +func (k kalenderDo) Returning(value interface{}, columns ...string) IKalenderDo { + return k.withDO(k.DO.Returning(value, columns...)) +} + +func (k kalenderDo) Not(conds ...gen.Condition) IKalenderDo { + return k.withDO(k.DO.Not(conds...)) +} + +func (k kalenderDo) Or(conds ...gen.Condition) IKalenderDo { + return k.withDO(k.DO.Or(conds...)) +} + +func (k kalenderDo) Select(conds ...field.Expr) IKalenderDo { + return k.withDO(k.DO.Select(conds...)) +} + +func (k kalenderDo) Where(conds ...gen.Condition) IKalenderDo { + return k.withDO(k.DO.Where(conds...)) +} + +func (k kalenderDo) Order(conds ...field.Expr) IKalenderDo { + return k.withDO(k.DO.Order(conds...)) +} + +func (k kalenderDo) Distinct(cols ...field.Expr) IKalenderDo { + return k.withDO(k.DO.Distinct(cols...)) +} + +func (k kalenderDo) Omit(cols ...field.Expr) IKalenderDo { + return k.withDO(k.DO.Omit(cols...)) +} + +func (k kalenderDo) Join(table schema.Tabler, on ...field.Expr) IKalenderDo { + return k.withDO(k.DO.Join(table, on...)) +} + +func (k kalenderDo) LeftJoin(table schema.Tabler, on ...field.Expr) IKalenderDo { + return k.withDO(k.DO.LeftJoin(table, on...)) +} + +func (k kalenderDo) RightJoin(table schema.Tabler, on ...field.Expr) IKalenderDo { + return k.withDO(k.DO.RightJoin(table, on...)) +} + +func (k kalenderDo) Group(cols ...field.Expr) IKalenderDo { + return k.withDO(k.DO.Group(cols...)) +} + +func (k kalenderDo) Having(conds ...gen.Condition) IKalenderDo { + return k.withDO(k.DO.Having(conds...)) +} + +func (k kalenderDo) Limit(limit int) IKalenderDo { + return k.withDO(k.DO.Limit(limit)) +} + +func (k kalenderDo) Offset(offset int) IKalenderDo { + return k.withDO(k.DO.Offset(offset)) +} + +func (k kalenderDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IKalenderDo { + return k.withDO(k.DO.Scopes(funcs...)) +} + +func (k kalenderDo) Unscoped() IKalenderDo { + return k.withDO(k.DO.Unscoped()) +} + +func (k kalenderDo) Create(values ...*model.Kalender) error { + if len(values) == 0 { + return nil + } + return k.DO.Create(values) +} + +func (k kalenderDo) CreateInBatches(values []*model.Kalender, batchSize int) error { + return k.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (k kalenderDo) Save(values ...*model.Kalender) error { + if len(values) == 0 { + return nil + } + return k.DO.Save(values) +} + +func (k kalenderDo) First() (*model.Kalender, error) { + if result, err := k.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Kalender), nil + } +} + +func (k kalenderDo) Take() (*model.Kalender, error) { + if result, err := k.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Kalender), nil + } +} + +func (k kalenderDo) Last() (*model.Kalender, error) { + if result, err := k.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Kalender), nil + } +} + +func (k kalenderDo) Find() ([]*model.Kalender, error) { + result, err := k.DO.Find() + return result.([]*model.Kalender), err +} + +func (k kalenderDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Kalender, err error) { + buf := make([]*model.Kalender, 0, batchSize) + err = k.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (k kalenderDo) FindInBatches(result *[]*model.Kalender, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return k.DO.FindInBatches(result, batchSize, fc) +} + +func (k kalenderDo) Attrs(attrs ...field.AssignExpr) IKalenderDo { + return k.withDO(k.DO.Attrs(attrs...)) +} + +func (k kalenderDo) Assign(attrs ...field.AssignExpr) IKalenderDo { + return k.withDO(k.DO.Assign(attrs...)) +} + +func (k kalenderDo) Joins(fields ...field.RelationField) IKalenderDo { + for _, _f := range fields { + k = *k.withDO(k.DO.Joins(_f)) + } + return &k +} + +func (k kalenderDo) Preload(fields ...field.RelationField) IKalenderDo { + for _, _f := range fields { + k = *k.withDO(k.DO.Preload(_f)) + } + return &k +} + +func (k kalenderDo) FirstOrInit() (*model.Kalender, error) { + if result, err := k.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Kalender), nil + } +} + +func (k kalenderDo) FirstOrCreate() (*model.Kalender, error) { + if result, err := k.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Kalender), nil + } +} + +func (k kalenderDo) FindByPage(offset int, limit int) (result []*model.Kalender, count int64, err error) { + result, err = k.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = k.Offset(-1).Limit(-1).Count() + return +} + +func (k kalenderDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = k.Count() + if err != nil { + return + } + + err = k.Offset(offset).Limit(limit).Scan(result) + return +} + +func (k kalenderDo) Scan(result interface{}) (err error) { + return k.DO.Scan(result) +} + +func (k kalenderDo) Delete(models ...*model.Kalender) (result gen.ResultInfo, err error) { + return k.DO.Delete(models) +} + +func (k *kalenderDo) withDO(do gen.Dao) *kalenderDo { + k.DO = *do.(*gen.DO) + return k +} diff --git a/query/kostenstelles.gen.go b/query/kostenstelles.gen.go new file mode 100644 index 0000000..ffbbbae --- /dev/null +++ b/query/kostenstelles.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newKostenstelle(db *gorm.DB, opts ...gen.DOOption) kostenstelle { + _kostenstelle := kostenstelle{} + + _kostenstelle.kostenstelleDo.UseDB(db, opts...) + _kostenstelle.kostenstelleDo.UseModel(&model.Kostenstelle{}) + + tableName := _kostenstelle.kostenstelleDo.TableName() + _kostenstelle.ALL = field.NewAsterisk(tableName) + _kostenstelle.ID = field.NewUint(tableName, "id") + _kostenstelle.CreatedAt = field.NewTime(tableName, "created_at") + _kostenstelle.UpdatedAt = field.NewTime(tableName, "updated_at") + _kostenstelle.DeletedAt = field.NewField(tableName, "deleted_at") + + _kostenstelle.fillFieldMap() + + return _kostenstelle +} + +type kostenstelle struct { + kostenstelleDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (k kostenstelle) Table(newTableName string) *kostenstelle { + k.kostenstelleDo.UseTable(newTableName) + return k.updateTableName(newTableName) +} + +func (k kostenstelle) As(alias string) *kostenstelle { + k.kostenstelleDo.DO = *(k.kostenstelleDo.As(alias).(*gen.DO)) + return k.updateTableName(alias) +} + +func (k *kostenstelle) updateTableName(table string) *kostenstelle { + k.ALL = field.NewAsterisk(table) + k.ID = field.NewUint(table, "id") + k.CreatedAt = field.NewTime(table, "created_at") + k.UpdatedAt = field.NewTime(table, "updated_at") + k.DeletedAt = field.NewField(table, "deleted_at") + + k.fillFieldMap() + + return k +} + +func (k *kostenstelle) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := k.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (k *kostenstelle) fillFieldMap() { + k.fieldMap = make(map[string]field.Expr, 4) + k.fieldMap["id"] = k.ID + k.fieldMap["created_at"] = k.CreatedAt + k.fieldMap["updated_at"] = k.UpdatedAt + k.fieldMap["deleted_at"] = k.DeletedAt +} + +func (k kostenstelle) clone(db *gorm.DB) kostenstelle { + k.kostenstelleDo.ReplaceConnPool(db.Statement.ConnPool) + return k +} + +func (k kostenstelle) replaceDB(db *gorm.DB) kostenstelle { + k.kostenstelleDo.ReplaceDB(db) + return k +} + +type kostenstelleDo struct{ gen.DO } + +type IKostenstelleDo interface { + gen.SubQuery + Debug() IKostenstelleDo + WithContext(ctx context.Context) IKostenstelleDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IKostenstelleDo + WriteDB() IKostenstelleDo + As(alias string) gen.Dao + Session(config *gorm.Session) IKostenstelleDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IKostenstelleDo + Not(conds ...gen.Condition) IKostenstelleDo + Or(conds ...gen.Condition) IKostenstelleDo + Select(conds ...field.Expr) IKostenstelleDo + Where(conds ...gen.Condition) IKostenstelleDo + Order(conds ...field.Expr) IKostenstelleDo + Distinct(cols ...field.Expr) IKostenstelleDo + Omit(cols ...field.Expr) IKostenstelleDo + Join(table schema.Tabler, on ...field.Expr) IKostenstelleDo + LeftJoin(table schema.Tabler, on ...field.Expr) IKostenstelleDo + RightJoin(table schema.Tabler, on ...field.Expr) IKostenstelleDo + Group(cols ...field.Expr) IKostenstelleDo + Having(conds ...gen.Condition) IKostenstelleDo + Limit(limit int) IKostenstelleDo + Offset(offset int) IKostenstelleDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IKostenstelleDo + Unscoped() IKostenstelleDo + Create(values ...*model.Kostenstelle) error + CreateInBatches(values []*model.Kostenstelle, batchSize int) error + Save(values ...*model.Kostenstelle) error + First() (*model.Kostenstelle, error) + Take() (*model.Kostenstelle, error) + Last() (*model.Kostenstelle, error) + Find() ([]*model.Kostenstelle, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Kostenstelle, err error) + FindInBatches(result *[]*model.Kostenstelle, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Kostenstelle) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IKostenstelleDo + Assign(attrs ...field.AssignExpr) IKostenstelleDo + Joins(fields ...field.RelationField) IKostenstelleDo + Preload(fields ...field.RelationField) IKostenstelleDo + FirstOrInit() (*model.Kostenstelle, error) + FirstOrCreate() (*model.Kostenstelle, error) + FindByPage(offset int, limit int) (result []*model.Kostenstelle, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IKostenstelleDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (k kostenstelleDo) Debug() IKostenstelleDo { + return k.withDO(k.DO.Debug()) +} + +func (k kostenstelleDo) WithContext(ctx context.Context) IKostenstelleDo { + return k.withDO(k.DO.WithContext(ctx)) +} + +func (k kostenstelleDo) ReadDB() IKostenstelleDo { + return k.Clauses(dbresolver.Read) +} + +func (k kostenstelleDo) WriteDB() IKostenstelleDo { + return k.Clauses(dbresolver.Write) +} + +func (k kostenstelleDo) Session(config *gorm.Session) IKostenstelleDo { + return k.withDO(k.DO.Session(config)) +} + +func (k kostenstelleDo) Clauses(conds ...clause.Expression) IKostenstelleDo { + return k.withDO(k.DO.Clauses(conds...)) +} + +func (k kostenstelleDo) Returning(value interface{}, columns ...string) IKostenstelleDo { + return k.withDO(k.DO.Returning(value, columns...)) +} + +func (k kostenstelleDo) Not(conds ...gen.Condition) IKostenstelleDo { + return k.withDO(k.DO.Not(conds...)) +} + +func (k kostenstelleDo) Or(conds ...gen.Condition) IKostenstelleDo { + return k.withDO(k.DO.Or(conds...)) +} + +func (k kostenstelleDo) Select(conds ...field.Expr) IKostenstelleDo { + return k.withDO(k.DO.Select(conds...)) +} + +func (k kostenstelleDo) Where(conds ...gen.Condition) IKostenstelleDo { + return k.withDO(k.DO.Where(conds...)) +} + +func (k kostenstelleDo) Order(conds ...field.Expr) IKostenstelleDo { + return k.withDO(k.DO.Order(conds...)) +} + +func (k kostenstelleDo) Distinct(cols ...field.Expr) IKostenstelleDo { + return k.withDO(k.DO.Distinct(cols...)) +} + +func (k kostenstelleDo) Omit(cols ...field.Expr) IKostenstelleDo { + return k.withDO(k.DO.Omit(cols...)) +} + +func (k kostenstelleDo) Join(table schema.Tabler, on ...field.Expr) IKostenstelleDo { + return k.withDO(k.DO.Join(table, on...)) +} + +func (k kostenstelleDo) LeftJoin(table schema.Tabler, on ...field.Expr) IKostenstelleDo { + return k.withDO(k.DO.LeftJoin(table, on...)) +} + +func (k kostenstelleDo) RightJoin(table schema.Tabler, on ...field.Expr) IKostenstelleDo { + return k.withDO(k.DO.RightJoin(table, on...)) +} + +func (k kostenstelleDo) Group(cols ...field.Expr) IKostenstelleDo { + return k.withDO(k.DO.Group(cols...)) +} + +func (k kostenstelleDo) Having(conds ...gen.Condition) IKostenstelleDo { + return k.withDO(k.DO.Having(conds...)) +} + +func (k kostenstelleDo) Limit(limit int) IKostenstelleDo { + return k.withDO(k.DO.Limit(limit)) +} + +func (k kostenstelleDo) Offset(offset int) IKostenstelleDo { + return k.withDO(k.DO.Offset(offset)) +} + +func (k kostenstelleDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IKostenstelleDo { + return k.withDO(k.DO.Scopes(funcs...)) +} + +func (k kostenstelleDo) Unscoped() IKostenstelleDo { + return k.withDO(k.DO.Unscoped()) +} + +func (k kostenstelleDo) Create(values ...*model.Kostenstelle) error { + if len(values) == 0 { + return nil + } + return k.DO.Create(values) +} + +func (k kostenstelleDo) CreateInBatches(values []*model.Kostenstelle, batchSize int) error { + return k.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (k kostenstelleDo) Save(values ...*model.Kostenstelle) error { + if len(values) == 0 { + return nil + } + return k.DO.Save(values) +} + +func (k kostenstelleDo) First() (*model.Kostenstelle, error) { + if result, err := k.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Kostenstelle), nil + } +} + +func (k kostenstelleDo) Take() (*model.Kostenstelle, error) { + if result, err := k.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Kostenstelle), nil + } +} + +func (k kostenstelleDo) Last() (*model.Kostenstelle, error) { + if result, err := k.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Kostenstelle), nil + } +} + +func (k kostenstelleDo) Find() ([]*model.Kostenstelle, error) { + result, err := k.DO.Find() + return result.([]*model.Kostenstelle), err +} + +func (k kostenstelleDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Kostenstelle, err error) { + buf := make([]*model.Kostenstelle, 0, batchSize) + err = k.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (k kostenstelleDo) FindInBatches(result *[]*model.Kostenstelle, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return k.DO.FindInBatches(result, batchSize, fc) +} + +func (k kostenstelleDo) Attrs(attrs ...field.AssignExpr) IKostenstelleDo { + return k.withDO(k.DO.Attrs(attrs...)) +} + +func (k kostenstelleDo) Assign(attrs ...field.AssignExpr) IKostenstelleDo { + return k.withDO(k.DO.Assign(attrs...)) +} + +func (k kostenstelleDo) Joins(fields ...field.RelationField) IKostenstelleDo { + for _, _f := range fields { + k = *k.withDO(k.DO.Joins(_f)) + } + return &k +} + +func (k kostenstelleDo) Preload(fields ...field.RelationField) IKostenstelleDo { + for _, _f := range fields { + k = *k.withDO(k.DO.Preload(_f)) + } + return &k +} + +func (k kostenstelleDo) FirstOrInit() (*model.Kostenstelle, error) { + if result, err := k.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Kostenstelle), nil + } +} + +func (k kostenstelleDo) FirstOrCreate() (*model.Kostenstelle, error) { + if result, err := k.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Kostenstelle), nil + } +} + +func (k kostenstelleDo) FindByPage(offset int, limit int) (result []*model.Kostenstelle, count int64, err error) { + result, err = k.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = k.Offset(-1).Limit(-1).Count() + return +} + +func (k kostenstelleDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = k.Count() + if err != nil { + return + } + + err = k.Offset(offset).Limit(limit).Scan(result) + return +} + +func (k kostenstelleDo) Scan(result interface{}) (err error) { + return k.DO.Scan(result) +} + +func (k kostenstelleDo) Delete(models ...*model.Kostenstelle) (result gen.ResultInfo, err error) { + return k.DO.Delete(models) +} + +func (k *kostenstelleDo) withDO(do gen.Dao) *kostenstelleDo { + k.DO = *do.(*gen.DO) + return k +} diff --git a/query/lagerplatzs.gen.go b/query/lagerplatzs.gen.go new file mode 100644 index 0000000..e83e134 --- /dev/null +++ b/query/lagerplatzs.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newLagerplatz(db *gorm.DB, opts ...gen.DOOption) lagerplatz { + _lagerplatz := lagerplatz{} + + _lagerplatz.lagerplatzDo.UseDB(db, opts...) + _lagerplatz.lagerplatzDo.UseModel(&model.Lagerplatz{}) + + tableName := _lagerplatz.lagerplatzDo.TableName() + _lagerplatz.ALL = field.NewAsterisk(tableName) + _lagerplatz.ID = field.NewUint(tableName, "id") + _lagerplatz.CreatedAt = field.NewTime(tableName, "created_at") + _lagerplatz.UpdatedAt = field.NewTime(tableName, "updated_at") + _lagerplatz.DeletedAt = field.NewField(tableName, "deleted_at") + + _lagerplatz.fillFieldMap() + + return _lagerplatz +} + +type lagerplatz struct { + lagerplatzDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (l lagerplatz) Table(newTableName string) *lagerplatz { + l.lagerplatzDo.UseTable(newTableName) + return l.updateTableName(newTableName) +} + +func (l lagerplatz) As(alias string) *lagerplatz { + l.lagerplatzDo.DO = *(l.lagerplatzDo.As(alias).(*gen.DO)) + return l.updateTableName(alias) +} + +func (l *lagerplatz) updateTableName(table string) *lagerplatz { + l.ALL = field.NewAsterisk(table) + l.ID = field.NewUint(table, "id") + l.CreatedAt = field.NewTime(table, "created_at") + l.UpdatedAt = field.NewTime(table, "updated_at") + l.DeletedAt = field.NewField(table, "deleted_at") + + l.fillFieldMap() + + return l +} + +func (l *lagerplatz) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := l.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (l *lagerplatz) fillFieldMap() { + l.fieldMap = make(map[string]field.Expr, 4) + l.fieldMap["id"] = l.ID + l.fieldMap["created_at"] = l.CreatedAt + l.fieldMap["updated_at"] = l.UpdatedAt + l.fieldMap["deleted_at"] = l.DeletedAt +} + +func (l lagerplatz) clone(db *gorm.DB) lagerplatz { + l.lagerplatzDo.ReplaceConnPool(db.Statement.ConnPool) + return l +} + +func (l lagerplatz) replaceDB(db *gorm.DB) lagerplatz { + l.lagerplatzDo.ReplaceDB(db) + return l +} + +type lagerplatzDo struct{ gen.DO } + +type ILagerplatzDo interface { + gen.SubQuery + Debug() ILagerplatzDo + WithContext(ctx context.Context) ILagerplatzDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() ILagerplatzDo + WriteDB() ILagerplatzDo + As(alias string) gen.Dao + Session(config *gorm.Session) ILagerplatzDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) ILagerplatzDo + Not(conds ...gen.Condition) ILagerplatzDo + Or(conds ...gen.Condition) ILagerplatzDo + Select(conds ...field.Expr) ILagerplatzDo + Where(conds ...gen.Condition) ILagerplatzDo + Order(conds ...field.Expr) ILagerplatzDo + Distinct(cols ...field.Expr) ILagerplatzDo + Omit(cols ...field.Expr) ILagerplatzDo + Join(table schema.Tabler, on ...field.Expr) ILagerplatzDo + LeftJoin(table schema.Tabler, on ...field.Expr) ILagerplatzDo + RightJoin(table schema.Tabler, on ...field.Expr) ILagerplatzDo + Group(cols ...field.Expr) ILagerplatzDo + Having(conds ...gen.Condition) ILagerplatzDo + Limit(limit int) ILagerplatzDo + Offset(offset int) ILagerplatzDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) ILagerplatzDo + Unscoped() ILagerplatzDo + Create(values ...*model.Lagerplatz) error + CreateInBatches(values []*model.Lagerplatz, batchSize int) error + Save(values ...*model.Lagerplatz) error + First() (*model.Lagerplatz, error) + Take() (*model.Lagerplatz, error) + Last() (*model.Lagerplatz, error) + Find() ([]*model.Lagerplatz, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Lagerplatz, err error) + FindInBatches(result *[]*model.Lagerplatz, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Lagerplatz) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) ILagerplatzDo + Assign(attrs ...field.AssignExpr) ILagerplatzDo + Joins(fields ...field.RelationField) ILagerplatzDo + Preload(fields ...field.RelationField) ILagerplatzDo + FirstOrInit() (*model.Lagerplatz, error) + FirstOrCreate() (*model.Lagerplatz, error) + FindByPage(offset int, limit int) (result []*model.Lagerplatz, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) ILagerplatzDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (l lagerplatzDo) Debug() ILagerplatzDo { + return l.withDO(l.DO.Debug()) +} + +func (l lagerplatzDo) WithContext(ctx context.Context) ILagerplatzDo { + return l.withDO(l.DO.WithContext(ctx)) +} + +func (l lagerplatzDo) ReadDB() ILagerplatzDo { + return l.Clauses(dbresolver.Read) +} + +func (l lagerplatzDo) WriteDB() ILagerplatzDo { + return l.Clauses(dbresolver.Write) +} + +func (l lagerplatzDo) Session(config *gorm.Session) ILagerplatzDo { + return l.withDO(l.DO.Session(config)) +} + +func (l lagerplatzDo) Clauses(conds ...clause.Expression) ILagerplatzDo { + return l.withDO(l.DO.Clauses(conds...)) +} + +func (l lagerplatzDo) Returning(value interface{}, columns ...string) ILagerplatzDo { + return l.withDO(l.DO.Returning(value, columns...)) +} + +func (l lagerplatzDo) Not(conds ...gen.Condition) ILagerplatzDo { + return l.withDO(l.DO.Not(conds...)) +} + +func (l lagerplatzDo) Or(conds ...gen.Condition) ILagerplatzDo { + return l.withDO(l.DO.Or(conds...)) +} + +func (l lagerplatzDo) Select(conds ...field.Expr) ILagerplatzDo { + return l.withDO(l.DO.Select(conds...)) +} + +func (l lagerplatzDo) Where(conds ...gen.Condition) ILagerplatzDo { + return l.withDO(l.DO.Where(conds...)) +} + +func (l lagerplatzDo) Order(conds ...field.Expr) ILagerplatzDo { + return l.withDO(l.DO.Order(conds...)) +} + +func (l lagerplatzDo) Distinct(cols ...field.Expr) ILagerplatzDo { + return l.withDO(l.DO.Distinct(cols...)) +} + +func (l lagerplatzDo) Omit(cols ...field.Expr) ILagerplatzDo { + return l.withDO(l.DO.Omit(cols...)) +} + +func (l lagerplatzDo) Join(table schema.Tabler, on ...field.Expr) ILagerplatzDo { + return l.withDO(l.DO.Join(table, on...)) +} + +func (l lagerplatzDo) LeftJoin(table schema.Tabler, on ...field.Expr) ILagerplatzDo { + return l.withDO(l.DO.LeftJoin(table, on...)) +} + +func (l lagerplatzDo) RightJoin(table schema.Tabler, on ...field.Expr) ILagerplatzDo { + return l.withDO(l.DO.RightJoin(table, on...)) +} + +func (l lagerplatzDo) Group(cols ...field.Expr) ILagerplatzDo { + return l.withDO(l.DO.Group(cols...)) +} + +func (l lagerplatzDo) Having(conds ...gen.Condition) ILagerplatzDo { + return l.withDO(l.DO.Having(conds...)) +} + +func (l lagerplatzDo) Limit(limit int) ILagerplatzDo { + return l.withDO(l.DO.Limit(limit)) +} + +func (l lagerplatzDo) Offset(offset int) ILagerplatzDo { + return l.withDO(l.DO.Offset(offset)) +} + +func (l lagerplatzDo) Scopes(funcs ...func(gen.Dao) gen.Dao) ILagerplatzDo { + return l.withDO(l.DO.Scopes(funcs...)) +} + +func (l lagerplatzDo) Unscoped() ILagerplatzDo { + return l.withDO(l.DO.Unscoped()) +} + +func (l lagerplatzDo) Create(values ...*model.Lagerplatz) error { + if len(values) == 0 { + return nil + } + return l.DO.Create(values) +} + +func (l lagerplatzDo) CreateInBatches(values []*model.Lagerplatz, batchSize int) error { + return l.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (l lagerplatzDo) Save(values ...*model.Lagerplatz) error { + if len(values) == 0 { + return nil + } + return l.DO.Save(values) +} + +func (l lagerplatzDo) First() (*model.Lagerplatz, error) { + if result, err := l.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Lagerplatz), nil + } +} + +func (l lagerplatzDo) Take() (*model.Lagerplatz, error) { + if result, err := l.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Lagerplatz), nil + } +} + +func (l lagerplatzDo) Last() (*model.Lagerplatz, error) { + if result, err := l.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Lagerplatz), nil + } +} + +func (l lagerplatzDo) Find() ([]*model.Lagerplatz, error) { + result, err := l.DO.Find() + return result.([]*model.Lagerplatz), err +} + +func (l lagerplatzDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Lagerplatz, err error) { + buf := make([]*model.Lagerplatz, 0, batchSize) + err = l.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (l lagerplatzDo) FindInBatches(result *[]*model.Lagerplatz, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return l.DO.FindInBatches(result, batchSize, fc) +} + +func (l lagerplatzDo) Attrs(attrs ...field.AssignExpr) ILagerplatzDo { + return l.withDO(l.DO.Attrs(attrs...)) +} + +func (l lagerplatzDo) Assign(attrs ...field.AssignExpr) ILagerplatzDo { + return l.withDO(l.DO.Assign(attrs...)) +} + +func (l lagerplatzDo) Joins(fields ...field.RelationField) ILagerplatzDo { + for _, _f := range fields { + l = *l.withDO(l.DO.Joins(_f)) + } + return &l +} + +func (l lagerplatzDo) Preload(fields ...field.RelationField) ILagerplatzDo { + for _, _f := range fields { + l = *l.withDO(l.DO.Preload(_f)) + } + return &l +} + +func (l lagerplatzDo) FirstOrInit() (*model.Lagerplatz, error) { + if result, err := l.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Lagerplatz), nil + } +} + +func (l lagerplatzDo) FirstOrCreate() (*model.Lagerplatz, error) { + if result, err := l.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Lagerplatz), nil + } +} + +func (l lagerplatzDo) FindByPage(offset int, limit int) (result []*model.Lagerplatz, count int64, err error) { + result, err = l.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = l.Offset(-1).Limit(-1).Count() + return +} + +func (l lagerplatzDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = l.Count() + if err != nil { + return + } + + err = l.Offset(offset).Limit(limit).Scan(result) + return +} + +func (l lagerplatzDo) Scan(result interface{}) (err error) { + return l.DO.Scan(result) +} + +func (l lagerplatzDo) Delete(models ...*model.Lagerplatz) (result gen.ResultInfo, err error) { + return l.DO.Delete(models) +} + +func (l *lagerplatzDo) withDO(do gen.Dao) *lagerplatzDo { + l.DO = *do.(*gen.DO) + return l +} diff --git a/query/lagers.gen.go b/query/lagers.gen.go new file mode 100644 index 0000000..20a3da0 --- /dev/null +++ b/query/lagers.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newLager(db *gorm.DB, opts ...gen.DOOption) lager { + _lager := lager{} + + _lager.lagerDo.UseDB(db, opts...) + _lager.lagerDo.UseModel(&model.Lager{}) + + tableName := _lager.lagerDo.TableName() + _lager.ALL = field.NewAsterisk(tableName) + _lager.ID = field.NewUint(tableName, "id") + _lager.CreatedAt = field.NewTime(tableName, "created_at") + _lager.UpdatedAt = field.NewTime(tableName, "updated_at") + _lager.DeletedAt = field.NewField(tableName, "deleted_at") + + _lager.fillFieldMap() + + return _lager +} + +type lager struct { + lagerDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (l lager) Table(newTableName string) *lager { + l.lagerDo.UseTable(newTableName) + return l.updateTableName(newTableName) +} + +func (l lager) As(alias string) *lager { + l.lagerDo.DO = *(l.lagerDo.As(alias).(*gen.DO)) + return l.updateTableName(alias) +} + +func (l *lager) updateTableName(table string) *lager { + l.ALL = field.NewAsterisk(table) + l.ID = field.NewUint(table, "id") + l.CreatedAt = field.NewTime(table, "created_at") + l.UpdatedAt = field.NewTime(table, "updated_at") + l.DeletedAt = field.NewField(table, "deleted_at") + + l.fillFieldMap() + + return l +} + +func (l *lager) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := l.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (l *lager) fillFieldMap() { + l.fieldMap = make(map[string]field.Expr, 4) + l.fieldMap["id"] = l.ID + l.fieldMap["created_at"] = l.CreatedAt + l.fieldMap["updated_at"] = l.UpdatedAt + l.fieldMap["deleted_at"] = l.DeletedAt +} + +func (l lager) clone(db *gorm.DB) lager { + l.lagerDo.ReplaceConnPool(db.Statement.ConnPool) + return l +} + +func (l lager) replaceDB(db *gorm.DB) lager { + l.lagerDo.ReplaceDB(db) + return l +} + +type lagerDo struct{ gen.DO } + +type ILagerDo interface { + gen.SubQuery + Debug() ILagerDo + WithContext(ctx context.Context) ILagerDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() ILagerDo + WriteDB() ILagerDo + As(alias string) gen.Dao + Session(config *gorm.Session) ILagerDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) ILagerDo + Not(conds ...gen.Condition) ILagerDo + Or(conds ...gen.Condition) ILagerDo + Select(conds ...field.Expr) ILagerDo + Where(conds ...gen.Condition) ILagerDo + Order(conds ...field.Expr) ILagerDo + Distinct(cols ...field.Expr) ILagerDo + Omit(cols ...field.Expr) ILagerDo + Join(table schema.Tabler, on ...field.Expr) ILagerDo + LeftJoin(table schema.Tabler, on ...field.Expr) ILagerDo + RightJoin(table schema.Tabler, on ...field.Expr) ILagerDo + Group(cols ...field.Expr) ILagerDo + Having(conds ...gen.Condition) ILagerDo + Limit(limit int) ILagerDo + Offset(offset int) ILagerDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) ILagerDo + Unscoped() ILagerDo + Create(values ...*model.Lager) error + CreateInBatches(values []*model.Lager, batchSize int) error + Save(values ...*model.Lager) error + First() (*model.Lager, error) + Take() (*model.Lager, error) + Last() (*model.Lager, error) + Find() ([]*model.Lager, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Lager, err error) + FindInBatches(result *[]*model.Lager, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Lager) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) ILagerDo + Assign(attrs ...field.AssignExpr) ILagerDo + Joins(fields ...field.RelationField) ILagerDo + Preload(fields ...field.RelationField) ILagerDo + FirstOrInit() (*model.Lager, error) + FirstOrCreate() (*model.Lager, error) + FindByPage(offset int, limit int) (result []*model.Lager, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) ILagerDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (l lagerDo) Debug() ILagerDo { + return l.withDO(l.DO.Debug()) +} + +func (l lagerDo) WithContext(ctx context.Context) ILagerDo { + return l.withDO(l.DO.WithContext(ctx)) +} + +func (l lagerDo) ReadDB() ILagerDo { + return l.Clauses(dbresolver.Read) +} + +func (l lagerDo) WriteDB() ILagerDo { + return l.Clauses(dbresolver.Write) +} + +func (l lagerDo) Session(config *gorm.Session) ILagerDo { + return l.withDO(l.DO.Session(config)) +} + +func (l lagerDo) Clauses(conds ...clause.Expression) ILagerDo { + return l.withDO(l.DO.Clauses(conds...)) +} + +func (l lagerDo) Returning(value interface{}, columns ...string) ILagerDo { + return l.withDO(l.DO.Returning(value, columns...)) +} + +func (l lagerDo) Not(conds ...gen.Condition) ILagerDo { + return l.withDO(l.DO.Not(conds...)) +} + +func (l lagerDo) Or(conds ...gen.Condition) ILagerDo { + return l.withDO(l.DO.Or(conds...)) +} + +func (l lagerDo) Select(conds ...field.Expr) ILagerDo { + return l.withDO(l.DO.Select(conds...)) +} + +func (l lagerDo) Where(conds ...gen.Condition) ILagerDo { + return l.withDO(l.DO.Where(conds...)) +} + +func (l lagerDo) Order(conds ...field.Expr) ILagerDo { + return l.withDO(l.DO.Order(conds...)) +} + +func (l lagerDo) Distinct(cols ...field.Expr) ILagerDo { + return l.withDO(l.DO.Distinct(cols...)) +} + +func (l lagerDo) Omit(cols ...field.Expr) ILagerDo { + return l.withDO(l.DO.Omit(cols...)) +} + +func (l lagerDo) Join(table schema.Tabler, on ...field.Expr) ILagerDo { + return l.withDO(l.DO.Join(table, on...)) +} + +func (l lagerDo) LeftJoin(table schema.Tabler, on ...field.Expr) ILagerDo { + return l.withDO(l.DO.LeftJoin(table, on...)) +} + +func (l lagerDo) RightJoin(table schema.Tabler, on ...field.Expr) ILagerDo { + return l.withDO(l.DO.RightJoin(table, on...)) +} + +func (l lagerDo) Group(cols ...field.Expr) ILagerDo { + return l.withDO(l.DO.Group(cols...)) +} + +func (l lagerDo) Having(conds ...gen.Condition) ILagerDo { + return l.withDO(l.DO.Having(conds...)) +} + +func (l lagerDo) Limit(limit int) ILagerDo { + return l.withDO(l.DO.Limit(limit)) +} + +func (l lagerDo) Offset(offset int) ILagerDo { + return l.withDO(l.DO.Offset(offset)) +} + +func (l lagerDo) Scopes(funcs ...func(gen.Dao) gen.Dao) ILagerDo { + return l.withDO(l.DO.Scopes(funcs...)) +} + +func (l lagerDo) Unscoped() ILagerDo { + return l.withDO(l.DO.Unscoped()) +} + +func (l lagerDo) Create(values ...*model.Lager) error { + if len(values) == 0 { + return nil + } + return l.DO.Create(values) +} + +func (l lagerDo) CreateInBatches(values []*model.Lager, batchSize int) error { + return l.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (l lagerDo) Save(values ...*model.Lager) error { + if len(values) == 0 { + return nil + } + return l.DO.Save(values) +} + +func (l lagerDo) First() (*model.Lager, error) { + if result, err := l.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Lager), nil + } +} + +func (l lagerDo) Take() (*model.Lager, error) { + if result, err := l.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Lager), nil + } +} + +func (l lagerDo) Last() (*model.Lager, error) { + if result, err := l.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Lager), nil + } +} + +func (l lagerDo) Find() ([]*model.Lager, error) { + result, err := l.DO.Find() + return result.([]*model.Lager), err +} + +func (l lagerDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Lager, err error) { + buf := make([]*model.Lager, 0, batchSize) + err = l.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (l lagerDo) FindInBatches(result *[]*model.Lager, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return l.DO.FindInBatches(result, batchSize, fc) +} + +func (l lagerDo) Attrs(attrs ...field.AssignExpr) ILagerDo { + return l.withDO(l.DO.Attrs(attrs...)) +} + +func (l lagerDo) Assign(attrs ...field.AssignExpr) ILagerDo { + return l.withDO(l.DO.Assign(attrs...)) +} + +func (l lagerDo) Joins(fields ...field.RelationField) ILagerDo { + for _, _f := range fields { + l = *l.withDO(l.DO.Joins(_f)) + } + return &l +} + +func (l lagerDo) Preload(fields ...field.RelationField) ILagerDo { + for _, _f := range fields { + l = *l.withDO(l.DO.Preload(_f)) + } + return &l +} + +func (l lagerDo) FirstOrInit() (*model.Lager, error) { + if result, err := l.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Lager), nil + } +} + +func (l lagerDo) FirstOrCreate() (*model.Lager, error) { + if result, err := l.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Lager), nil + } +} + +func (l lagerDo) FindByPage(offset int, limit int) (result []*model.Lager, count int64, err error) { + result, err = l.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = l.Offset(-1).Limit(-1).Count() + return +} + +func (l lagerDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = l.Count() + if err != nil { + return + } + + err = l.Offset(offset).Limit(limit).Scan(result) + return +} + +func (l lagerDo) Scan(result interface{}) (err error) { + return l.DO.Scan(result) +} + +func (l lagerDo) Delete(models ...*model.Lager) (result gen.ResultInfo, err error) { + return l.DO.Delete(models) +} + +func (l *lagerDo) withDO(do gen.Dao) *lagerDo { + l.DO = *do.(*gen.DO) + return l +} diff --git a/query/materials.gen.go b/query/materials.gen.go new file mode 100644 index 0000000..1f6c21e --- /dev/null +++ b/query/materials.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newMaterial(db *gorm.DB, opts ...gen.DOOption) material { + _material := material{} + + _material.materialDo.UseDB(db, opts...) + _material.materialDo.UseModel(&model.Material{}) + + tableName := _material.materialDo.TableName() + _material.ALL = field.NewAsterisk(tableName) + _material.ID = field.NewUint(tableName, "id") + _material.CreatedAt = field.NewTime(tableName, "created_at") + _material.UpdatedAt = field.NewTime(tableName, "updated_at") + _material.DeletedAt = field.NewField(tableName, "deleted_at") + + _material.fillFieldMap() + + return _material +} + +type material struct { + materialDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (m material) Table(newTableName string) *material { + m.materialDo.UseTable(newTableName) + return m.updateTableName(newTableName) +} + +func (m material) As(alias string) *material { + m.materialDo.DO = *(m.materialDo.As(alias).(*gen.DO)) + return m.updateTableName(alias) +} + +func (m *material) updateTableName(table string) *material { + m.ALL = field.NewAsterisk(table) + m.ID = field.NewUint(table, "id") + m.CreatedAt = field.NewTime(table, "created_at") + m.UpdatedAt = field.NewTime(table, "updated_at") + m.DeletedAt = field.NewField(table, "deleted_at") + + m.fillFieldMap() + + return m +} + +func (m *material) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := m.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (m *material) fillFieldMap() { + m.fieldMap = make(map[string]field.Expr, 4) + m.fieldMap["id"] = m.ID + m.fieldMap["created_at"] = m.CreatedAt + m.fieldMap["updated_at"] = m.UpdatedAt + m.fieldMap["deleted_at"] = m.DeletedAt +} + +func (m material) clone(db *gorm.DB) material { + m.materialDo.ReplaceConnPool(db.Statement.ConnPool) + return m +} + +func (m material) replaceDB(db *gorm.DB) material { + m.materialDo.ReplaceDB(db) + return m +} + +type materialDo struct{ gen.DO } + +type IMaterialDo interface { + gen.SubQuery + Debug() IMaterialDo + WithContext(ctx context.Context) IMaterialDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IMaterialDo + WriteDB() IMaterialDo + As(alias string) gen.Dao + Session(config *gorm.Session) IMaterialDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IMaterialDo + Not(conds ...gen.Condition) IMaterialDo + Or(conds ...gen.Condition) IMaterialDo + Select(conds ...field.Expr) IMaterialDo + Where(conds ...gen.Condition) IMaterialDo + Order(conds ...field.Expr) IMaterialDo + Distinct(cols ...field.Expr) IMaterialDo + Omit(cols ...field.Expr) IMaterialDo + Join(table schema.Tabler, on ...field.Expr) IMaterialDo + LeftJoin(table schema.Tabler, on ...field.Expr) IMaterialDo + RightJoin(table schema.Tabler, on ...field.Expr) IMaterialDo + Group(cols ...field.Expr) IMaterialDo + Having(conds ...gen.Condition) IMaterialDo + Limit(limit int) IMaterialDo + Offset(offset int) IMaterialDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IMaterialDo + Unscoped() IMaterialDo + Create(values ...*model.Material) error + CreateInBatches(values []*model.Material, batchSize int) error + Save(values ...*model.Material) error + First() (*model.Material, error) + Take() (*model.Material, error) + Last() (*model.Material, error) + Find() ([]*model.Material, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Material, err error) + FindInBatches(result *[]*model.Material, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Material) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IMaterialDo + Assign(attrs ...field.AssignExpr) IMaterialDo + Joins(fields ...field.RelationField) IMaterialDo + Preload(fields ...field.RelationField) IMaterialDo + FirstOrInit() (*model.Material, error) + FirstOrCreate() (*model.Material, error) + FindByPage(offset int, limit int) (result []*model.Material, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IMaterialDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (m materialDo) Debug() IMaterialDo { + return m.withDO(m.DO.Debug()) +} + +func (m materialDo) WithContext(ctx context.Context) IMaterialDo { + return m.withDO(m.DO.WithContext(ctx)) +} + +func (m materialDo) ReadDB() IMaterialDo { + return m.Clauses(dbresolver.Read) +} + +func (m materialDo) WriteDB() IMaterialDo { + return m.Clauses(dbresolver.Write) +} + +func (m materialDo) Session(config *gorm.Session) IMaterialDo { + return m.withDO(m.DO.Session(config)) +} + +func (m materialDo) Clauses(conds ...clause.Expression) IMaterialDo { + return m.withDO(m.DO.Clauses(conds...)) +} + +func (m materialDo) Returning(value interface{}, columns ...string) IMaterialDo { + return m.withDO(m.DO.Returning(value, columns...)) +} + +func (m materialDo) Not(conds ...gen.Condition) IMaterialDo { + return m.withDO(m.DO.Not(conds...)) +} + +func (m materialDo) Or(conds ...gen.Condition) IMaterialDo { + return m.withDO(m.DO.Or(conds...)) +} + +func (m materialDo) Select(conds ...field.Expr) IMaterialDo { + return m.withDO(m.DO.Select(conds...)) +} + +func (m materialDo) Where(conds ...gen.Condition) IMaterialDo { + return m.withDO(m.DO.Where(conds...)) +} + +func (m materialDo) Order(conds ...field.Expr) IMaterialDo { + return m.withDO(m.DO.Order(conds...)) +} + +func (m materialDo) Distinct(cols ...field.Expr) IMaterialDo { + return m.withDO(m.DO.Distinct(cols...)) +} + +func (m materialDo) Omit(cols ...field.Expr) IMaterialDo { + return m.withDO(m.DO.Omit(cols...)) +} + +func (m materialDo) Join(table schema.Tabler, on ...field.Expr) IMaterialDo { + return m.withDO(m.DO.Join(table, on...)) +} + +func (m materialDo) LeftJoin(table schema.Tabler, on ...field.Expr) IMaterialDo { + return m.withDO(m.DO.LeftJoin(table, on...)) +} + +func (m materialDo) RightJoin(table schema.Tabler, on ...field.Expr) IMaterialDo { + return m.withDO(m.DO.RightJoin(table, on...)) +} + +func (m materialDo) Group(cols ...field.Expr) IMaterialDo { + return m.withDO(m.DO.Group(cols...)) +} + +func (m materialDo) Having(conds ...gen.Condition) IMaterialDo { + return m.withDO(m.DO.Having(conds...)) +} + +func (m materialDo) Limit(limit int) IMaterialDo { + return m.withDO(m.DO.Limit(limit)) +} + +func (m materialDo) Offset(offset int) IMaterialDo { + return m.withDO(m.DO.Offset(offset)) +} + +func (m materialDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IMaterialDo { + return m.withDO(m.DO.Scopes(funcs...)) +} + +func (m materialDo) Unscoped() IMaterialDo { + return m.withDO(m.DO.Unscoped()) +} + +func (m materialDo) Create(values ...*model.Material) error { + if len(values) == 0 { + return nil + } + return m.DO.Create(values) +} + +func (m materialDo) CreateInBatches(values []*model.Material, batchSize int) error { + return m.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (m materialDo) Save(values ...*model.Material) error { + if len(values) == 0 { + return nil + } + return m.DO.Save(values) +} + +func (m materialDo) First() (*model.Material, error) { + if result, err := m.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Material), nil + } +} + +func (m materialDo) Take() (*model.Material, error) { + if result, err := m.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Material), nil + } +} + +func (m materialDo) Last() (*model.Material, error) { + if result, err := m.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Material), nil + } +} + +func (m materialDo) Find() ([]*model.Material, error) { + result, err := m.DO.Find() + return result.([]*model.Material), err +} + +func (m materialDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Material, err error) { + buf := make([]*model.Material, 0, batchSize) + err = m.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (m materialDo) FindInBatches(result *[]*model.Material, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return m.DO.FindInBatches(result, batchSize, fc) +} + +func (m materialDo) Attrs(attrs ...field.AssignExpr) IMaterialDo { + return m.withDO(m.DO.Attrs(attrs...)) +} + +func (m materialDo) Assign(attrs ...field.AssignExpr) IMaterialDo { + return m.withDO(m.DO.Assign(attrs...)) +} + +func (m materialDo) Joins(fields ...field.RelationField) IMaterialDo { + for _, _f := range fields { + m = *m.withDO(m.DO.Joins(_f)) + } + return &m +} + +func (m materialDo) Preload(fields ...field.RelationField) IMaterialDo { + for _, _f := range fields { + m = *m.withDO(m.DO.Preload(_f)) + } + return &m +} + +func (m materialDo) FirstOrInit() (*model.Material, error) { + if result, err := m.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Material), nil + } +} + +func (m materialDo) FirstOrCreate() (*model.Material, error) { + if result, err := m.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Material), nil + } +} + +func (m materialDo) FindByPage(offset int, limit int) (result []*model.Material, count int64, err error) { + result, err = m.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = m.Offset(-1).Limit(-1).Count() + return +} + +func (m materialDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = m.Count() + if err != nil { + return + } + + err = m.Offset(offset).Limit(limit).Scan(result) + return +} + +func (m materialDo) Scan(result interface{}) (err error) { + return m.DO.Scan(result) +} + +func (m materialDo) Delete(models ...*model.Material) (result gen.ResultInfo, err error) { + return m.DO.Delete(models) +} + +func (m *materialDo) withDO(do gen.Dao) *materialDo { + m.DO = *do.(*gen.DO) + return m +} diff --git a/query/nachrichts.gen.go b/query/nachrichts.gen.go new file mode 100644 index 0000000..19de00c --- /dev/null +++ b/query/nachrichts.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newNachricht(db *gorm.DB, opts ...gen.DOOption) nachricht { + _nachricht := nachricht{} + + _nachricht.nachrichtDo.UseDB(db, opts...) + _nachricht.nachrichtDo.UseModel(&model.Nachricht{}) + + tableName := _nachricht.nachrichtDo.TableName() + _nachricht.ALL = field.NewAsterisk(tableName) + _nachricht.ID = field.NewUint(tableName, "id") + _nachricht.CreatedAt = field.NewTime(tableName, "created_at") + _nachricht.UpdatedAt = field.NewTime(tableName, "updated_at") + _nachricht.DeletedAt = field.NewField(tableName, "deleted_at") + + _nachricht.fillFieldMap() + + return _nachricht +} + +type nachricht struct { + nachrichtDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (n nachricht) Table(newTableName string) *nachricht { + n.nachrichtDo.UseTable(newTableName) + return n.updateTableName(newTableName) +} + +func (n nachricht) As(alias string) *nachricht { + n.nachrichtDo.DO = *(n.nachrichtDo.As(alias).(*gen.DO)) + return n.updateTableName(alias) +} + +func (n *nachricht) updateTableName(table string) *nachricht { + n.ALL = field.NewAsterisk(table) + n.ID = field.NewUint(table, "id") + n.CreatedAt = field.NewTime(table, "created_at") + n.UpdatedAt = field.NewTime(table, "updated_at") + n.DeletedAt = field.NewField(table, "deleted_at") + + n.fillFieldMap() + + return n +} + +func (n *nachricht) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := n.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (n *nachricht) fillFieldMap() { + n.fieldMap = make(map[string]field.Expr, 4) + n.fieldMap["id"] = n.ID + n.fieldMap["created_at"] = n.CreatedAt + n.fieldMap["updated_at"] = n.UpdatedAt + n.fieldMap["deleted_at"] = n.DeletedAt +} + +func (n nachricht) clone(db *gorm.DB) nachricht { + n.nachrichtDo.ReplaceConnPool(db.Statement.ConnPool) + return n +} + +func (n nachricht) replaceDB(db *gorm.DB) nachricht { + n.nachrichtDo.ReplaceDB(db) + return n +} + +type nachrichtDo struct{ gen.DO } + +type INachrichtDo interface { + gen.SubQuery + Debug() INachrichtDo + WithContext(ctx context.Context) INachrichtDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() INachrichtDo + WriteDB() INachrichtDo + As(alias string) gen.Dao + Session(config *gorm.Session) INachrichtDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) INachrichtDo + Not(conds ...gen.Condition) INachrichtDo + Or(conds ...gen.Condition) INachrichtDo + Select(conds ...field.Expr) INachrichtDo + Where(conds ...gen.Condition) INachrichtDo + Order(conds ...field.Expr) INachrichtDo + Distinct(cols ...field.Expr) INachrichtDo + Omit(cols ...field.Expr) INachrichtDo + Join(table schema.Tabler, on ...field.Expr) INachrichtDo + LeftJoin(table schema.Tabler, on ...field.Expr) INachrichtDo + RightJoin(table schema.Tabler, on ...field.Expr) INachrichtDo + Group(cols ...field.Expr) INachrichtDo + Having(conds ...gen.Condition) INachrichtDo + Limit(limit int) INachrichtDo + Offset(offset int) INachrichtDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) INachrichtDo + Unscoped() INachrichtDo + Create(values ...*model.Nachricht) error + CreateInBatches(values []*model.Nachricht, batchSize int) error + Save(values ...*model.Nachricht) error + First() (*model.Nachricht, error) + Take() (*model.Nachricht, error) + Last() (*model.Nachricht, error) + Find() ([]*model.Nachricht, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Nachricht, err error) + FindInBatches(result *[]*model.Nachricht, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Nachricht) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) INachrichtDo + Assign(attrs ...field.AssignExpr) INachrichtDo + Joins(fields ...field.RelationField) INachrichtDo + Preload(fields ...field.RelationField) INachrichtDo + FirstOrInit() (*model.Nachricht, error) + FirstOrCreate() (*model.Nachricht, error) + FindByPage(offset int, limit int) (result []*model.Nachricht, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) INachrichtDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (n nachrichtDo) Debug() INachrichtDo { + return n.withDO(n.DO.Debug()) +} + +func (n nachrichtDo) WithContext(ctx context.Context) INachrichtDo { + return n.withDO(n.DO.WithContext(ctx)) +} + +func (n nachrichtDo) ReadDB() INachrichtDo { + return n.Clauses(dbresolver.Read) +} + +func (n nachrichtDo) WriteDB() INachrichtDo { + return n.Clauses(dbresolver.Write) +} + +func (n nachrichtDo) Session(config *gorm.Session) INachrichtDo { + return n.withDO(n.DO.Session(config)) +} + +func (n nachrichtDo) Clauses(conds ...clause.Expression) INachrichtDo { + return n.withDO(n.DO.Clauses(conds...)) +} + +func (n nachrichtDo) Returning(value interface{}, columns ...string) INachrichtDo { + return n.withDO(n.DO.Returning(value, columns...)) +} + +func (n nachrichtDo) Not(conds ...gen.Condition) INachrichtDo { + return n.withDO(n.DO.Not(conds...)) +} + +func (n nachrichtDo) Or(conds ...gen.Condition) INachrichtDo { + return n.withDO(n.DO.Or(conds...)) +} + +func (n nachrichtDo) Select(conds ...field.Expr) INachrichtDo { + return n.withDO(n.DO.Select(conds...)) +} + +func (n nachrichtDo) Where(conds ...gen.Condition) INachrichtDo { + return n.withDO(n.DO.Where(conds...)) +} + +func (n nachrichtDo) Order(conds ...field.Expr) INachrichtDo { + return n.withDO(n.DO.Order(conds...)) +} + +func (n nachrichtDo) Distinct(cols ...field.Expr) INachrichtDo { + return n.withDO(n.DO.Distinct(cols...)) +} + +func (n nachrichtDo) Omit(cols ...field.Expr) INachrichtDo { + return n.withDO(n.DO.Omit(cols...)) +} + +func (n nachrichtDo) Join(table schema.Tabler, on ...field.Expr) INachrichtDo { + return n.withDO(n.DO.Join(table, on...)) +} + +func (n nachrichtDo) LeftJoin(table schema.Tabler, on ...field.Expr) INachrichtDo { + return n.withDO(n.DO.LeftJoin(table, on...)) +} + +func (n nachrichtDo) RightJoin(table schema.Tabler, on ...field.Expr) INachrichtDo { + return n.withDO(n.DO.RightJoin(table, on...)) +} + +func (n nachrichtDo) Group(cols ...field.Expr) INachrichtDo { + return n.withDO(n.DO.Group(cols...)) +} + +func (n nachrichtDo) Having(conds ...gen.Condition) INachrichtDo { + return n.withDO(n.DO.Having(conds...)) +} + +func (n nachrichtDo) Limit(limit int) INachrichtDo { + return n.withDO(n.DO.Limit(limit)) +} + +func (n nachrichtDo) Offset(offset int) INachrichtDo { + return n.withDO(n.DO.Offset(offset)) +} + +func (n nachrichtDo) Scopes(funcs ...func(gen.Dao) gen.Dao) INachrichtDo { + return n.withDO(n.DO.Scopes(funcs...)) +} + +func (n nachrichtDo) Unscoped() INachrichtDo { + return n.withDO(n.DO.Unscoped()) +} + +func (n nachrichtDo) Create(values ...*model.Nachricht) error { + if len(values) == 0 { + return nil + } + return n.DO.Create(values) +} + +func (n nachrichtDo) CreateInBatches(values []*model.Nachricht, batchSize int) error { + return n.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (n nachrichtDo) Save(values ...*model.Nachricht) error { + if len(values) == 0 { + return nil + } + return n.DO.Save(values) +} + +func (n nachrichtDo) First() (*model.Nachricht, error) { + if result, err := n.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Nachricht), nil + } +} + +func (n nachrichtDo) Take() (*model.Nachricht, error) { + if result, err := n.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Nachricht), nil + } +} + +func (n nachrichtDo) Last() (*model.Nachricht, error) { + if result, err := n.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Nachricht), nil + } +} + +func (n nachrichtDo) Find() ([]*model.Nachricht, error) { + result, err := n.DO.Find() + return result.([]*model.Nachricht), err +} + +func (n nachrichtDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Nachricht, err error) { + buf := make([]*model.Nachricht, 0, batchSize) + err = n.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (n nachrichtDo) FindInBatches(result *[]*model.Nachricht, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return n.DO.FindInBatches(result, batchSize, fc) +} + +func (n nachrichtDo) Attrs(attrs ...field.AssignExpr) INachrichtDo { + return n.withDO(n.DO.Attrs(attrs...)) +} + +func (n nachrichtDo) Assign(attrs ...field.AssignExpr) INachrichtDo { + return n.withDO(n.DO.Assign(attrs...)) +} + +func (n nachrichtDo) Joins(fields ...field.RelationField) INachrichtDo { + for _, _f := range fields { + n = *n.withDO(n.DO.Joins(_f)) + } + return &n +} + +func (n nachrichtDo) Preload(fields ...field.RelationField) INachrichtDo { + for _, _f := range fields { + n = *n.withDO(n.DO.Preload(_f)) + } + return &n +} + +func (n nachrichtDo) FirstOrInit() (*model.Nachricht, error) { + if result, err := n.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Nachricht), nil + } +} + +func (n nachrichtDo) FirstOrCreate() (*model.Nachricht, error) { + if result, err := n.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Nachricht), nil + } +} + +func (n nachrichtDo) FindByPage(offset int, limit int) (result []*model.Nachricht, count int64, err error) { + result, err = n.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = n.Offset(-1).Limit(-1).Count() + return +} + +func (n nachrichtDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = n.Count() + if err != nil { + return + } + + err = n.Offset(offset).Limit(limit).Scan(result) + return +} + +func (n nachrichtDo) Scan(result interface{}) (err error) { + return n.DO.Scan(result) +} + +func (n nachrichtDo) Delete(models ...*model.Nachricht) (result gen.ResultInfo, err error) { + return n.DO.Delete(models) +} + +func (n *nachrichtDo) withDO(do gen.Dao) *nachrichtDo { + n.DO = *do.(*gen.DO) + return n +} diff --git a/query/projekts.gen.go b/query/projekts.gen.go new file mode 100644 index 0000000..5dfbd2b --- /dev/null +++ b/query/projekts.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newProjekt(db *gorm.DB, opts ...gen.DOOption) projekt { + _projekt := projekt{} + + _projekt.projektDo.UseDB(db, opts...) + _projekt.projektDo.UseModel(&model.Projekt{}) + + tableName := _projekt.projektDo.TableName() + _projekt.ALL = field.NewAsterisk(tableName) + _projekt.ID = field.NewUint(tableName, "id") + _projekt.CreatedAt = field.NewTime(tableName, "created_at") + _projekt.UpdatedAt = field.NewTime(tableName, "updated_at") + _projekt.DeletedAt = field.NewField(tableName, "deleted_at") + + _projekt.fillFieldMap() + + return _projekt +} + +type projekt struct { + projektDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (p projekt) Table(newTableName string) *projekt { + p.projektDo.UseTable(newTableName) + return p.updateTableName(newTableName) +} + +func (p projekt) As(alias string) *projekt { + p.projektDo.DO = *(p.projektDo.As(alias).(*gen.DO)) + return p.updateTableName(alias) +} + +func (p *projekt) updateTableName(table string) *projekt { + p.ALL = field.NewAsterisk(table) + p.ID = field.NewUint(table, "id") + p.CreatedAt = field.NewTime(table, "created_at") + p.UpdatedAt = field.NewTime(table, "updated_at") + p.DeletedAt = field.NewField(table, "deleted_at") + + p.fillFieldMap() + + return p +} + +func (p *projekt) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := p.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (p *projekt) fillFieldMap() { + p.fieldMap = make(map[string]field.Expr, 4) + p.fieldMap["id"] = p.ID + p.fieldMap["created_at"] = p.CreatedAt + p.fieldMap["updated_at"] = p.UpdatedAt + p.fieldMap["deleted_at"] = p.DeletedAt +} + +func (p projekt) clone(db *gorm.DB) projekt { + p.projektDo.ReplaceConnPool(db.Statement.ConnPool) + return p +} + +func (p projekt) replaceDB(db *gorm.DB) projekt { + p.projektDo.ReplaceDB(db) + return p +} + +type projektDo struct{ gen.DO } + +type IProjektDo interface { + gen.SubQuery + Debug() IProjektDo + WithContext(ctx context.Context) IProjektDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IProjektDo + WriteDB() IProjektDo + As(alias string) gen.Dao + Session(config *gorm.Session) IProjektDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IProjektDo + Not(conds ...gen.Condition) IProjektDo + Or(conds ...gen.Condition) IProjektDo + Select(conds ...field.Expr) IProjektDo + Where(conds ...gen.Condition) IProjektDo + Order(conds ...field.Expr) IProjektDo + Distinct(cols ...field.Expr) IProjektDo + Omit(cols ...field.Expr) IProjektDo + Join(table schema.Tabler, on ...field.Expr) IProjektDo + LeftJoin(table schema.Tabler, on ...field.Expr) IProjektDo + RightJoin(table schema.Tabler, on ...field.Expr) IProjektDo + Group(cols ...field.Expr) IProjektDo + Having(conds ...gen.Condition) IProjektDo + Limit(limit int) IProjektDo + Offset(offset int) IProjektDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IProjektDo + Unscoped() IProjektDo + Create(values ...*model.Projekt) error + CreateInBatches(values []*model.Projekt, batchSize int) error + Save(values ...*model.Projekt) error + First() (*model.Projekt, error) + Take() (*model.Projekt, error) + Last() (*model.Projekt, error) + Find() ([]*model.Projekt, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Projekt, err error) + FindInBatches(result *[]*model.Projekt, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Projekt) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IProjektDo + Assign(attrs ...field.AssignExpr) IProjektDo + Joins(fields ...field.RelationField) IProjektDo + Preload(fields ...field.RelationField) IProjektDo + FirstOrInit() (*model.Projekt, error) + FirstOrCreate() (*model.Projekt, error) + FindByPage(offset int, limit int) (result []*model.Projekt, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IProjektDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (p projektDo) Debug() IProjektDo { + return p.withDO(p.DO.Debug()) +} + +func (p projektDo) WithContext(ctx context.Context) IProjektDo { + return p.withDO(p.DO.WithContext(ctx)) +} + +func (p projektDo) ReadDB() IProjektDo { + return p.Clauses(dbresolver.Read) +} + +func (p projektDo) WriteDB() IProjektDo { + return p.Clauses(dbresolver.Write) +} + +func (p projektDo) Session(config *gorm.Session) IProjektDo { + return p.withDO(p.DO.Session(config)) +} + +func (p projektDo) Clauses(conds ...clause.Expression) IProjektDo { + return p.withDO(p.DO.Clauses(conds...)) +} + +func (p projektDo) Returning(value interface{}, columns ...string) IProjektDo { + return p.withDO(p.DO.Returning(value, columns...)) +} + +func (p projektDo) Not(conds ...gen.Condition) IProjektDo { + return p.withDO(p.DO.Not(conds...)) +} + +func (p projektDo) Or(conds ...gen.Condition) IProjektDo { + return p.withDO(p.DO.Or(conds...)) +} + +func (p projektDo) Select(conds ...field.Expr) IProjektDo { + return p.withDO(p.DO.Select(conds...)) +} + +func (p projektDo) Where(conds ...gen.Condition) IProjektDo { + return p.withDO(p.DO.Where(conds...)) +} + +func (p projektDo) Order(conds ...field.Expr) IProjektDo { + return p.withDO(p.DO.Order(conds...)) +} + +func (p projektDo) Distinct(cols ...field.Expr) IProjektDo { + return p.withDO(p.DO.Distinct(cols...)) +} + +func (p projektDo) Omit(cols ...field.Expr) IProjektDo { + return p.withDO(p.DO.Omit(cols...)) +} + +func (p projektDo) Join(table schema.Tabler, on ...field.Expr) IProjektDo { + return p.withDO(p.DO.Join(table, on...)) +} + +func (p projektDo) LeftJoin(table schema.Tabler, on ...field.Expr) IProjektDo { + return p.withDO(p.DO.LeftJoin(table, on...)) +} + +func (p projektDo) RightJoin(table schema.Tabler, on ...field.Expr) IProjektDo { + return p.withDO(p.DO.RightJoin(table, on...)) +} + +func (p projektDo) Group(cols ...field.Expr) IProjektDo { + return p.withDO(p.DO.Group(cols...)) +} + +func (p projektDo) Having(conds ...gen.Condition) IProjektDo { + return p.withDO(p.DO.Having(conds...)) +} + +func (p projektDo) Limit(limit int) IProjektDo { + return p.withDO(p.DO.Limit(limit)) +} + +func (p projektDo) Offset(offset int) IProjektDo { + return p.withDO(p.DO.Offset(offset)) +} + +func (p projektDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IProjektDo { + return p.withDO(p.DO.Scopes(funcs...)) +} + +func (p projektDo) Unscoped() IProjektDo { + return p.withDO(p.DO.Unscoped()) +} + +func (p projektDo) Create(values ...*model.Projekt) error { + if len(values) == 0 { + return nil + } + return p.DO.Create(values) +} + +func (p projektDo) CreateInBatches(values []*model.Projekt, batchSize int) error { + return p.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (p projektDo) Save(values ...*model.Projekt) error { + if len(values) == 0 { + return nil + } + return p.DO.Save(values) +} + +func (p projektDo) First() (*model.Projekt, error) { + if result, err := p.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Projekt), nil + } +} + +func (p projektDo) Take() (*model.Projekt, error) { + if result, err := p.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Projekt), nil + } +} + +func (p projektDo) Last() (*model.Projekt, error) { + if result, err := p.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Projekt), nil + } +} + +func (p projektDo) Find() ([]*model.Projekt, error) { + result, err := p.DO.Find() + return result.([]*model.Projekt), err +} + +func (p projektDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Projekt, err error) { + buf := make([]*model.Projekt, 0, batchSize) + err = p.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (p projektDo) FindInBatches(result *[]*model.Projekt, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return p.DO.FindInBatches(result, batchSize, fc) +} + +func (p projektDo) Attrs(attrs ...field.AssignExpr) IProjektDo { + return p.withDO(p.DO.Attrs(attrs...)) +} + +func (p projektDo) Assign(attrs ...field.AssignExpr) IProjektDo { + return p.withDO(p.DO.Assign(attrs...)) +} + +func (p projektDo) Joins(fields ...field.RelationField) IProjektDo { + for _, _f := range fields { + p = *p.withDO(p.DO.Joins(_f)) + } + return &p +} + +func (p projektDo) Preload(fields ...field.RelationField) IProjektDo { + for _, _f := range fields { + p = *p.withDO(p.DO.Preload(_f)) + } + return &p +} + +func (p projektDo) FirstOrInit() (*model.Projekt, error) { + if result, err := p.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Projekt), nil + } +} + +func (p projektDo) FirstOrCreate() (*model.Projekt, error) { + if result, err := p.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Projekt), nil + } +} + +func (p projektDo) FindByPage(offset int, limit int) (result []*model.Projekt, count int64, err error) { + result, err = p.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = p.Offset(-1).Limit(-1).Count() + return +} + +func (p projektDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = p.Count() + if err != nil { + return + } + + err = p.Offset(offset).Limit(limit).Scan(result) + return +} + +func (p projektDo) Scan(result interface{}) (err error) { + return p.DO.Scan(result) +} + +func (p projektDo) Delete(models ...*model.Projekt) (result gen.ResultInfo, err error) { + return p.DO.Delete(models) +} + +func (p *projektDo) withDO(do gen.Dao) *projektDo { + p.DO = *do.(*gen.DO) + return p +} diff --git a/query/rechnungs.gen.go b/query/rechnungs.gen.go new file mode 100644 index 0000000..c3e25ed --- /dev/null +++ b/query/rechnungs.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newRechnung(db *gorm.DB, opts ...gen.DOOption) rechnung { + _rechnung := rechnung{} + + _rechnung.rechnungDo.UseDB(db, opts...) + _rechnung.rechnungDo.UseModel(&model.Rechnung{}) + + tableName := _rechnung.rechnungDo.TableName() + _rechnung.ALL = field.NewAsterisk(tableName) + _rechnung.ID = field.NewUint(tableName, "id") + _rechnung.CreatedAt = field.NewTime(tableName, "created_at") + _rechnung.UpdatedAt = field.NewTime(tableName, "updated_at") + _rechnung.DeletedAt = field.NewField(tableName, "deleted_at") + + _rechnung.fillFieldMap() + + return _rechnung +} + +type rechnung struct { + rechnungDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (r rechnung) Table(newTableName string) *rechnung { + r.rechnungDo.UseTable(newTableName) + return r.updateTableName(newTableName) +} + +func (r rechnung) As(alias string) *rechnung { + r.rechnungDo.DO = *(r.rechnungDo.As(alias).(*gen.DO)) + return r.updateTableName(alias) +} + +func (r *rechnung) updateTableName(table string) *rechnung { + r.ALL = field.NewAsterisk(table) + r.ID = field.NewUint(table, "id") + r.CreatedAt = field.NewTime(table, "created_at") + r.UpdatedAt = field.NewTime(table, "updated_at") + r.DeletedAt = field.NewField(table, "deleted_at") + + r.fillFieldMap() + + return r +} + +func (r *rechnung) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := r.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (r *rechnung) fillFieldMap() { + r.fieldMap = make(map[string]field.Expr, 4) + r.fieldMap["id"] = r.ID + r.fieldMap["created_at"] = r.CreatedAt + r.fieldMap["updated_at"] = r.UpdatedAt + r.fieldMap["deleted_at"] = r.DeletedAt +} + +func (r rechnung) clone(db *gorm.DB) rechnung { + r.rechnungDo.ReplaceConnPool(db.Statement.ConnPool) + return r +} + +func (r rechnung) replaceDB(db *gorm.DB) rechnung { + r.rechnungDo.ReplaceDB(db) + return r +} + +type rechnungDo struct{ gen.DO } + +type IRechnungDo interface { + gen.SubQuery + Debug() IRechnungDo + WithContext(ctx context.Context) IRechnungDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IRechnungDo + WriteDB() IRechnungDo + As(alias string) gen.Dao + Session(config *gorm.Session) IRechnungDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IRechnungDo + Not(conds ...gen.Condition) IRechnungDo + Or(conds ...gen.Condition) IRechnungDo + Select(conds ...field.Expr) IRechnungDo + Where(conds ...gen.Condition) IRechnungDo + Order(conds ...field.Expr) IRechnungDo + Distinct(cols ...field.Expr) IRechnungDo + Omit(cols ...field.Expr) IRechnungDo + Join(table schema.Tabler, on ...field.Expr) IRechnungDo + LeftJoin(table schema.Tabler, on ...field.Expr) IRechnungDo + RightJoin(table schema.Tabler, on ...field.Expr) IRechnungDo + Group(cols ...field.Expr) IRechnungDo + Having(conds ...gen.Condition) IRechnungDo + Limit(limit int) IRechnungDo + Offset(offset int) IRechnungDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IRechnungDo + Unscoped() IRechnungDo + Create(values ...*model.Rechnung) error + CreateInBatches(values []*model.Rechnung, batchSize int) error + Save(values ...*model.Rechnung) error + First() (*model.Rechnung, error) + Take() (*model.Rechnung, error) + Last() (*model.Rechnung, error) + Find() ([]*model.Rechnung, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Rechnung, err error) + FindInBatches(result *[]*model.Rechnung, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Rechnung) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IRechnungDo + Assign(attrs ...field.AssignExpr) IRechnungDo + Joins(fields ...field.RelationField) IRechnungDo + Preload(fields ...field.RelationField) IRechnungDo + FirstOrInit() (*model.Rechnung, error) + FirstOrCreate() (*model.Rechnung, error) + FindByPage(offset int, limit int) (result []*model.Rechnung, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IRechnungDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (r rechnungDo) Debug() IRechnungDo { + return r.withDO(r.DO.Debug()) +} + +func (r rechnungDo) WithContext(ctx context.Context) IRechnungDo { + return r.withDO(r.DO.WithContext(ctx)) +} + +func (r rechnungDo) ReadDB() IRechnungDo { + return r.Clauses(dbresolver.Read) +} + +func (r rechnungDo) WriteDB() IRechnungDo { + return r.Clauses(dbresolver.Write) +} + +func (r rechnungDo) Session(config *gorm.Session) IRechnungDo { + return r.withDO(r.DO.Session(config)) +} + +func (r rechnungDo) Clauses(conds ...clause.Expression) IRechnungDo { + return r.withDO(r.DO.Clauses(conds...)) +} + +func (r rechnungDo) Returning(value interface{}, columns ...string) IRechnungDo { + return r.withDO(r.DO.Returning(value, columns...)) +} + +func (r rechnungDo) Not(conds ...gen.Condition) IRechnungDo { + return r.withDO(r.DO.Not(conds...)) +} + +func (r rechnungDo) Or(conds ...gen.Condition) IRechnungDo { + return r.withDO(r.DO.Or(conds...)) +} + +func (r rechnungDo) Select(conds ...field.Expr) IRechnungDo { + return r.withDO(r.DO.Select(conds...)) +} + +func (r rechnungDo) Where(conds ...gen.Condition) IRechnungDo { + return r.withDO(r.DO.Where(conds...)) +} + +func (r rechnungDo) Order(conds ...field.Expr) IRechnungDo { + return r.withDO(r.DO.Order(conds...)) +} + +func (r rechnungDo) Distinct(cols ...field.Expr) IRechnungDo { + return r.withDO(r.DO.Distinct(cols...)) +} + +func (r rechnungDo) Omit(cols ...field.Expr) IRechnungDo { + return r.withDO(r.DO.Omit(cols...)) +} + +func (r rechnungDo) Join(table schema.Tabler, on ...field.Expr) IRechnungDo { + return r.withDO(r.DO.Join(table, on...)) +} + +func (r rechnungDo) LeftJoin(table schema.Tabler, on ...field.Expr) IRechnungDo { + return r.withDO(r.DO.LeftJoin(table, on...)) +} + +func (r rechnungDo) RightJoin(table schema.Tabler, on ...field.Expr) IRechnungDo { + return r.withDO(r.DO.RightJoin(table, on...)) +} + +func (r rechnungDo) Group(cols ...field.Expr) IRechnungDo { + return r.withDO(r.DO.Group(cols...)) +} + +func (r rechnungDo) Having(conds ...gen.Condition) IRechnungDo { + return r.withDO(r.DO.Having(conds...)) +} + +func (r rechnungDo) Limit(limit int) IRechnungDo { + return r.withDO(r.DO.Limit(limit)) +} + +func (r rechnungDo) Offset(offset int) IRechnungDo { + return r.withDO(r.DO.Offset(offset)) +} + +func (r rechnungDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IRechnungDo { + return r.withDO(r.DO.Scopes(funcs...)) +} + +func (r rechnungDo) Unscoped() IRechnungDo { + return r.withDO(r.DO.Unscoped()) +} + +func (r rechnungDo) Create(values ...*model.Rechnung) error { + if len(values) == 0 { + return nil + } + return r.DO.Create(values) +} + +func (r rechnungDo) CreateInBatches(values []*model.Rechnung, batchSize int) error { + return r.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (r rechnungDo) Save(values ...*model.Rechnung) error { + if len(values) == 0 { + return nil + } + return r.DO.Save(values) +} + +func (r rechnungDo) First() (*model.Rechnung, error) { + if result, err := r.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Rechnung), nil + } +} + +func (r rechnungDo) Take() (*model.Rechnung, error) { + if result, err := r.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Rechnung), nil + } +} + +func (r rechnungDo) Last() (*model.Rechnung, error) { + if result, err := r.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Rechnung), nil + } +} + +func (r rechnungDo) Find() ([]*model.Rechnung, error) { + result, err := r.DO.Find() + return result.([]*model.Rechnung), err +} + +func (r rechnungDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Rechnung, err error) { + buf := make([]*model.Rechnung, 0, batchSize) + err = r.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (r rechnungDo) FindInBatches(result *[]*model.Rechnung, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return r.DO.FindInBatches(result, batchSize, fc) +} + +func (r rechnungDo) Attrs(attrs ...field.AssignExpr) IRechnungDo { + return r.withDO(r.DO.Attrs(attrs...)) +} + +func (r rechnungDo) Assign(attrs ...field.AssignExpr) IRechnungDo { + return r.withDO(r.DO.Assign(attrs...)) +} + +func (r rechnungDo) Joins(fields ...field.RelationField) IRechnungDo { + for _, _f := range fields { + r = *r.withDO(r.DO.Joins(_f)) + } + return &r +} + +func (r rechnungDo) Preload(fields ...field.RelationField) IRechnungDo { + for _, _f := range fields { + r = *r.withDO(r.DO.Preload(_f)) + } + return &r +} + +func (r rechnungDo) FirstOrInit() (*model.Rechnung, error) { + if result, err := r.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Rechnung), nil + } +} + +func (r rechnungDo) FirstOrCreate() (*model.Rechnung, error) { + if result, err := r.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Rechnung), nil + } +} + +func (r rechnungDo) FindByPage(offset int, limit int) (result []*model.Rechnung, count int64, err error) { + result, err = r.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = r.Offset(-1).Limit(-1).Count() + return +} + +func (r rechnungDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = r.Count() + if err != nil { + return + } + + err = r.Offset(offset).Limit(limit).Scan(result) + return +} + +func (r rechnungDo) Scan(result interface{}) (err error) { + return r.DO.Scan(result) +} + +func (r rechnungDo) Delete(models ...*model.Rechnung) (result gen.ResultInfo, err error) { + return r.DO.Delete(models) +} + +func (r *rechnungDo) withDO(do gen.Dao) *rechnungDo { + r.DO = *do.(*gen.DO) + return r +} diff --git a/query/rechnungspositions.gen.go b/query/rechnungspositions.gen.go new file mode 100644 index 0000000..de07dec --- /dev/null +++ b/query/rechnungspositions.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newRechnungsposition(db *gorm.DB, opts ...gen.DOOption) rechnungsposition { + _rechnungsposition := rechnungsposition{} + + _rechnungsposition.rechnungspositionDo.UseDB(db, opts...) + _rechnungsposition.rechnungspositionDo.UseModel(&model.Rechnungsposition{}) + + tableName := _rechnungsposition.rechnungspositionDo.TableName() + _rechnungsposition.ALL = field.NewAsterisk(tableName) + _rechnungsposition.ID = field.NewUint(tableName, "id") + _rechnungsposition.CreatedAt = field.NewTime(tableName, "created_at") + _rechnungsposition.UpdatedAt = field.NewTime(tableName, "updated_at") + _rechnungsposition.DeletedAt = field.NewField(tableName, "deleted_at") + + _rechnungsposition.fillFieldMap() + + return _rechnungsposition +} + +type rechnungsposition struct { + rechnungspositionDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (r rechnungsposition) Table(newTableName string) *rechnungsposition { + r.rechnungspositionDo.UseTable(newTableName) + return r.updateTableName(newTableName) +} + +func (r rechnungsposition) As(alias string) *rechnungsposition { + r.rechnungspositionDo.DO = *(r.rechnungspositionDo.As(alias).(*gen.DO)) + return r.updateTableName(alias) +} + +func (r *rechnungsposition) updateTableName(table string) *rechnungsposition { + r.ALL = field.NewAsterisk(table) + r.ID = field.NewUint(table, "id") + r.CreatedAt = field.NewTime(table, "created_at") + r.UpdatedAt = field.NewTime(table, "updated_at") + r.DeletedAt = field.NewField(table, "deleted_at") + + r.fillFieldMap() + + return r +} + +func (r *rechnungsposition) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := r.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (r *rechnungsposition) fillFieldMap() { + r.fieldMap = make(map[string]field.Expr, 4) + r.fieldMap["id"] = r.ID + r.fieldMap["created_at"] = r.CreatedAt + r.fieldMap["updated_at"] = r.UpdatedAt + r.fieldMap["deleted_at"] = r.DeletedAt +} + +func (r rechnungsposition) clone(db *gorm.DB) rechnungsposition { + r.rechnungspositionDo.ReplaceConnPool(db.Statement.ConnPool) + return r +} + +func (r rechnungsposition) replaceDB(db *gorm.DB) rechnungsposition { + r.rechnungspositionDo.ReplaceDB(db) + return r +} + +type rechnungspositionDo struct{ gen.DO } + +type IRechnungspositionDo interface { + gen.SubQuery + Debug() IRechnungspositionDo + WithContext(ctx context.Context) IRechnungspositionDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IRechnungspositionDo + WriteDB() IRechnungspositionDo + As(alias string) gen.Dao + Session(config *gorm.Session) IRechnungspositionDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IRechnungspositionDo + Not(conds ...gen.Condition) IRechnungspositionDo + Or(conds ...gen.Condition) IRechnungspositionDo + Select(conds ...field.Expr) IRechnungspositionDo + Where(conds ...gen.Condition) IRechnungspositionDo + Order(conds ...field.Expr) IRechnungspositionDo + Distinct(cols ...field.Expr) IRechnungspositionDo + Omit(cols ...field.Expr) IRechnungspositionDo + Join(table schema.Tabler, on ...field.Expr) IRechnungspositionDo + LeftJoin(table schema.Tabler, on ...field.Expr) IRechnungspositionDo + RightJoin(table schema.Tabler, on ...field.Expr) IRechnungspositionDo + Group(cols ...field.Expr) IRechnungspositionDo + Having(conds ...gen.Condition) IRechnungspositionDo + Limit(limit int) IRechnungspositionDo + Offset(offset int) IRechnungspositionDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IRechnungspositionDo + Unscoped() IRechnungspositionDo + Create(values ...*model.Rechnungsposition) error + CreateInBatches(values []*model.Rechnungsposition, batchSize int) error + Save(values ...*model.Rechnungsposition) error + First() (*model.Rechnungsposition, error) + Take() (*model.Rechnungsposition, error) + Last() (*model.Rechnungsposition, error) + Find() ([]*model.Rechnungsposition, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Rechnungsposition, err error) + FindInBatches(result *[]*model.Rechnungsposition, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Rechnungsposition) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IRechnungspositionDo + Assign(attrs ...field.AssignExpr) IRechnungspositionDo + Joins(fields ...field.RelationField) IRechnungspositionDo + Preload(fields ...field.RelationField) IRechnungspositionDo + FirstOrInit() (*model.Rechnungsposition, error) + FirstOrCreate() (*model.Rechnungsposition, error) + FindByPage(offset int, limit int) (result []*model.Rechnungsposition, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IRechnungspositionDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (r rechnungspositionDo) Debug() IRechnungspositionDo { + return r.withDO(r.DO.Debug()) +} + +func (r rechnungspositionDo) WithContext(ctx context.Context) IRechnungspositionDo { + return r.withDO(r.DO.WithContext(ctx)) +} + +func (r rechnungspositionDo) ReadDB() IRechnungspositionDo { + return r.Clauses(dbresolver.Read) +} + +func (r rechnungspositionDo) WriteDB() IRechnungspositionDo { + return r.Clauses(dbresolver.Write) +} + +func (r rechnungspositionDo) Session(config *gorm.Session) IRechnungspositionDo { + return r.withDO(r.DO.Session(config)) +} + +func (r rechnungspositionDo) Clauses(conds ...clause.Expression) IRechnungspositionDo { + return r.withDO(r.DO.Clauses(conds...)) +} + +func (r rechnungspositionDo) Returning(value interface{}, columns ...string) IRechnungspositionDo { + return r.withDO(r.DO.Returning(value, columns...)) +} + +func (r rechnungspositionDo) Not(conds ...gen.Condition) IRechnungspositionDo { + return r.withDO(r.DO.Not(conds...)) +} + +func (r rechnungspositionDo) Or(conds ...gen.Condition) IRechnungspositionDo { + return r.withDO(r.DO.Or(conds...)) +} + +func (r rechnungspositionDo) Select(conds ...field.Expr) IRechnungspositionDo { + return r.withDO(r.DO.Select(conds...)) +} + +func (r rechnungspositionDo) Where(conds ...gen.Condition) IRechnungspositionDo { + return r.withDO(r.DO.Where(conds...)) +} + +func (r rechnungspositionDo) Order(conds ...field.Expr) IRechnungspositionDo { + return r.withDO(r.DO.Order(conds...)) +} + +func (r rechnungspositionDo) Distinct(cols ...field.Expr) IRechnungspositionDo { + return r.withDO(r.DO.Distinct(cols...)) +} + +func (r rechnungspositionDo) Omit(cols ...field.Expr) IRechnungspositionDo { + return r.withDO(r.DO.Omit(cols...)) +} + +func (r rechnungspositionDo) Join(table schema.Tabler, on ...field.Expr) IRechnungspositionDo { + return r.withDO(r.DO.Join(table, on...)) +} + +func (r rechnungspositionDo) LeftJoin(table schema.Tabler, on ...field.Expr) IRechnungspositionDo { + return r.withDO(r.DO.LeftJoin(table, on...)) +} + +func (r rechnungspositionDo) RightJoin(table schema.Tabler, on ...field.Expr) IRechnungspositionDo { + return r.withDO(r.DO.RightJoin(table, on...)) +} + +func (r rechnungspositionDo) Group(cols ...field.Expr) IRechnungspositionDo { + return r.withDO(r.DO.Group(cols...)) +} + +func (r rechnungspositionDo) Having(conds ...gen.Condition) IRechnungspositionDo { + return r.withDO(r.DO.Having(conds...)) +} + +func (r rechnungspositionDo) Limit(limit int) IRechnungspositionDo { + return r.withDO(r.DO.Limit(limit)) +} + +func (r rechnungspositionDo) Offset(offset int) IRechnungspositionDo { + return r.withDO(r.DO.Offset(offset)) +} + +func (r rechnungspositionDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IRechnungspositionDo { + return r.withDO(r.DO.Scopes(funcs...)) +} + +func (r rechnungspositionDo) Unscoped() IRechnungspositionDo { + return r.withDO(r.DO.Unscoped()) +} + +func (r rechnungspositionDo) Create(values ...*model.Rechnungsposition) error { + if len(values) == 0 { + return nil + } + return r.DO.Create(values) +} + +func (r rechnungspositionDo) CreateInBatches(values []*model.Rechnungsposition, batchSize int) error { + return r.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (r rechnungspositionDo) Save(values ...*model.Rechnungsposition) error { + if len(values) == 0 { + return nil + } + return r.DO.Save(values) +} + +func (r rechnungspositionDo) First() (*model.Rechnungsposition, error) { + if result, err := r.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Rechnungsposition), nil + } +} + +func (r rechnungspositionDo) Take() (*model.Rechnungsposition, error) { + if result, err := r.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Rechnungsposition), nil + } +} + +func (r rechnungspositionDo) Last() (*model.Rechnungsposition, error) { + if result, err := r.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Rechnungsposition), nil + } +} + +func (r rechnungspositionDo) Find() ([]*model.Rechnungsposition, error) { + result, err := r.DO.Find() + return result.([]*model.Rechnungsposition), err +} + +func (r rechnungspositionDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Rechnungsposition, err error) { + buf := make([]*model.Rechnungsposition, 0, batchSize) + err = r.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (r rechnungspositionDo) FindInBatches(result *[]*model.Rechnungsposition, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return r.DO.FindInBatches(result, batchSize, fc) +} + +func (r rechnungspositionDo) Attrs(attrs ...field.AssignExpr) IRechnungspositionDo { + return r.withDO(r.DO.Attrs(attrs...)) +} + +func (r rechnungspositionDo) Assign(attrs ...field.AssignExpr) IRechnungspositionDo { + return r.withDO(r.DO.Assign(attrs...)) +} + +func (r rechnungspositionDo) Joins(fields ...field.RelationField) IRechnungspositionDo { + for _, _f := range fields { + r = *r.withDO(r.DO.Joins(_f)) + } + return &r +} + +func (r rechnungspositionDo) Preload(fields ...field.RelationField) IRechnungspositionDo { + for _, _f := range fields { + r = *r.withDO(r.DO.Preload(_f)) + } + return &r +} + +func (r rechnungspositionDo) FirstOrInit() (*model.Rechnungsposition, error) { + if result, err := r.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Rechnungsposition), nil + } +} + +func (r rechnungspositionDo) FirstOrCreate() (*model.Rechnungsposition, error) { + if result, err := r.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Rechnungsposition), nil + } +} + +func (r rechnungspositionDo) FindByPage(offset int, limit int) (result []*model.Rechnungsposition, count int64, err error) { + result, err = r.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = r.Offset(-1).Limit(-1).Count() + return +} + +func (r rechnungspositionDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = r.Count() + if err != nil { + return + } + + err = r.Offset(offset).Limit(limit).Scan(result) + return +} + +func (r rechnungspositionDo) Scan(result interface{}) (err error) { + return r.DO.Scan(result) +} + +func (r rechnungspositionDo) Delete(models ...*model.Rechnungsposition) (result gen.ResultInfo, err error) { + return r.DO.Delete(models) +} + +func (r *rechnungspositionDo) withDO(do gen.Dao) *rechnungspositionDo { + r.DO = *do.(*gen.DO) + return r +} diff --git a/query/scanobjects.gen.go b/query/scanobjects.gen.go new file mode 100644 index 0000000..661b4e9 --- /dev/null +++ b/query/scanobjects.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newScanobject(db *gorm.DB, opts ...gen.DOOption) scanobject { + _scanobject := scanobject{} + + _scanobject.scanobjectDo.UseDB(db, opts...) + _scanobject.scanobjectDo.UseModel(&model.Scanobject{}) + + tableName := _scanobject.scanobjectDo.TableName() + _scanobject.ALL = field.NewAsterisk(tableName) + _scanobject.ID = field.NewUint(tableName, "id") + _scanobject.CreatedAt = field.NewTime(tableName, "created_at") + _scanobject.UpdatedAt = field.NewTime(tableName, "updated_at") + _scanobject.DeletedAt = field.NewField(tableName, "deleted_at") + + _scanobject.fillFieldMap() + + return _scanobject +} + +type scanobject struct { + scanobjectDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (s scanobject) Table(newTableName string) *scanobject { + s.scanobjectDo.UseTable(newTableName) + return s.updateTableName(newTableName) +} + +func (s scanobject) As(alias string) *scanobject { + s.scanobjectDo.DO = *(s.scanobjectDo.As(alias).(*gen.DO)) + return s.updateTableName(alias) +} + +func (s *scanobject) updateTableName(table string) *scanobject { + s.ALL = field.NewAsterisk(table) + s.ID = field.NewUint(table, "id") + s.CreatedAt = field.NewTime(table, "created_at") + s.UpdatedAt = field.NewTime(table, "updated_at") + s.DeletedAt = field.NewField(table, "deleted_at") + + s.fillFieldMap() + + return s +} + +func (s *scanobject) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := s.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (s *scanobject) fillFieldMap() { + s.fieldMap = make(map[string]field.Expr, 4) + s.fieldMap["id"] = s.ID + s.fieldMap["created_at"] = s.CreatedAt + s.fieldMap["updated_at"] = s.UpdatedAt + s.fieldMap["deleted_at"] = s.DeletedAt +} + +func (s scanobject) clone(db *gorm.DB) scanobject { + s.scanobjectDo.ReplaceConnPool(db.Statement.ConnPool) + return s +} + +func (s scanobject) replaceDB(db *gorm.DB) scanobject { + s.scanobjectDo.ReplaceDB(db) + return s +} + +type scanobjectDo struct{ gen.DO } + +type IScanobjectDo interface { + gen.SubQuery + Debug() IScanobjectDo + WithContext(ctx context.Context) IScanobjectDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IScanobjectDo + WriteDB() IScanobjectDo + As(alias string) gen.Dao + Session(config *gorm.Session) IScanobjectDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IScanobjectDo + Not(conds ...gen.Condition) IScanobjectDo + Or(conds ...gen.Condition) IScanobjectDo + Select(conds ...field.Expr) IScanobjectDo + Where(conds ...gen.Condition) IScanobjectDo + Order(conds ...field.Expr) IScanobjectDo + Distinct(cols ...field.Expr) IScanobjectDo + Omit(cols ...field.Expr) IScanobjectDo + Join(table schema.Tabler, on ...field.Expr) IScanobjectDo + LeftJoin(table schema.Tabler, on ...field.Expr) IScanobjectDo + RightJoin(table schema.Tabler, on ...field.Expr) IScanobjectDo + Group(cols ...field.Expr) IScanobjectDo + Having(conds ...gen.Condition) IScanobjectDo + Limit(limit int) IScanobjectDo + Offset(offset int) IScanobjectDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IScanobjectDo + Unscoped() IScanobjectDo + Create(values ...*model.Scanobject) error + CreateInBatches(values []*model.Scanobject, batchSize int) error + Save(values ...*model.Scanobject) error + First() (*model.Scanobject, error) + Take() (*model.Scanobject, error) + Last() (*model.Scanobject, error) + Find() ([]*model.Scanobject, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Scanobject, err error) + FindInBatches(result *[]*model.Scanobject, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Scanobject) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IScanobjectDo + Assign(attrs ...field.AssignExpr) IScanobjectDo + Joins(fields ...field.RelationField) IScanobjectDo + Preload(fields ...field.RelationField) IScanobjectDo + FirstOrInit() (*model.Scanobject, error) + FirstOrCreate() (*model.Scanobject, error) + FindByPage(offset int, limit int) (result []*model.Scanobject, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IScanobjectDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (s scanobjectDo) Debug() IScanobjectDo { + return s.withDO(s.DO.Debug()) +} + +func (s scanobjectDo) WithContext(ctx context.Context) IScanobjectDo { + return s.withDO(s.DO.WithContext(ctx)) +} + +func (s scanobjectDo) ReadDB() IScanobjectDo { + return s.Clauses(dbresolver.Read) +} + +func (s scanobjectDo) WriteDB() IScanobjectDo { + return s.Clauses(dbresolver.Write) +} + +func (s scanobjectDo) Session(config *gorm.Session) IScanobjectDo { + return s.withDO(s.DO.Session(config)) +} + +func (s scanobjectDo) Clauses(conds ...clause.Expression) IScanobjectDo { + return s.withDO(s.DO.Clauses(conds...)) +} + +func (s scanobjectDo) Returning(value interface{}, columns ...string) IScanobjectDo { + return s.withDO(s.DO.Returning(value, columns...)) +} + +func (s scanobjectDo) Not(conds ...gen.Condition) IScanobjectDo { + return s.withDO(s.DO.Not(conds...)) +} + +func (s scanobjectDo) Or(conds ...gen.Condition) IScanobjectDo { + return s.withDO(s.DO.Or(conds...)) +} + +func (s scanobjectDo) Select(conds ...field.Expr) IScanobjectDo { + return s.withDO(s.DO.Select(conds...)) +} + +func (s scanobjectDo) Where(conds ...gen.Condition) IScanobjectDo { + return s.withDO(s.DO.Where(conds...)) +} + +func (s scanobjectDo) Order(conds ...field.Expr) IScanobjectDo { + return s.withDO(s.DO.Order(conds...)) +} + +func (s scanobjectDo) Distinct(cols ...field.Expr) IScanobjectDo { + return s.withDO(s.DO.Distinct(cols...)) +} + +func (s scanobjectDo) Omit(cols ...field.Expr) IScanobjectDo { + return s.withDO(s.DO.Omit(cols...)) +} + +func (s scanobjectDo) Join(table schema.Tabler, on ...field.Expr) IScanobjectDo { + return s.withDO(s.DO.Join(table, on...)) +} + +func (s scanobjectDo) LeftJoin(table schema.Tabler, on ...field.Expr) IScanobjectDo { + return s.withDO(s.DO.LeftJoin(table, on...)) +} + +func (s scanobjectDo) RightJoin(table schema.Tabler, on ...field.Expr) IScanobjectDo { + return s.withDO(s.DO.RightJoin(table, on...)) +} + +func (s scanobjectDo) Group(cols ...field.Expr) IScanobjectDo { + return s.withDO(s.DO.Group(cols...)) +} + +func (s scanobjectDo) Having(conds ...gen.Condition) IScanobjectDo { + return s.withDO(s.DO.Having(conds...)) +} + +func (s scanobjectDo) Limit(limit int) IScanobjectDo { + return s.withDO(s.DO.Limit(limit)) +} + +func (s scanobjectDo) Offset(offset int) IScanobjectDo { + return s.withDO(s.DO.Offset(offset)) +} + +func (s scanobjectDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IScanobjectDo { + return s.withDO(s.DO.Scopes(funcs...)) +} + +func (s scanobjectDo) Unscoped() IScanobjectDo { + return s.withDO(s.DO.Unscoped()) +} + +func (s scanobjectDo) Create(values ...*model.Scanobject) error { + if len(values) == 0 { + return nil + } + return s.DO.Create(values) +} + +func (s scanobjectDo) CreateInBatches(values []*model.Scanobject, batchSize int) error { + return s.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (s scanobjectDo) Save(values ...*model.Scanobject) error { + if len(values) == 0 { + return nil + } + return s.DO.Save(values) +} + +func (s scanobjectDo) First() (*model.Scanobject, error) { + if result, err := s.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Scanobject), nil + } +} + +func (s scanobjectDo) Take() (*model.Scanobject, error) { + if result, err := s.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Scanobject), nil + } +} + +func (s scanobjectDo) Last() (*model.Scanobject, error) { + if result, err := s.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Scanobject), nil + } +} + +func (s scanobjectDo) Find() ([]*model.Scanobject, error) { + result, err := s.DO.Find() + return result.([]*model.Scanobject), err +} + +func (s scanobjectDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Scanobject, err error) { + buf := make([]*model.Scanobject, 0, batchSize) + err = s.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (s scanobjectDo) FindInBatches(result *[]*model.Scanobject, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return s.DO.FindInBatches(result, batchSize, fc) +} + +func (s scanobjectDo) Attrs(attrs ...field.AssignExpr) IScanobjectDo { + return s.withDO(s.DO.Attrs(attrs...)) +} + +func (s scanobjectDo) Assign(attrs ...field.AssignExpr) IScanobjectDo { + return s.withDO(s.DO.Assign(attrs...)) +} + +func (s scanobjectDo) Joins(fields ...field.RelationField) IScanobjectDo { + for _, _f := range fields { + s = *s.withDO(s.DO.Joins(_f)) + } + return &s +} + +func (s scanobjectDo) Preload(fields ...field.RelationField) IScanobjectDo { + for _, _f := range fields { + s = *s.withDO(s.DO.Preload(_f)) + } + return &s +} + +func (s scanobjectDo) FirstOrInit() (*model.Scanobject, error) { + if result, err := s.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Scanobject), nil + } +} + +func (s scanobjectDo) FirstOrCreate() (*model.Scanobject, error) { + if result, err := s.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Scanobject), nil + } +} + +func (s scanobjectDo) FindByPage(offset int, limit int) (result []*model.Scanobject, count int64, err error) { + result, err = s.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = s.Offset(-1).Limit(-1).Count() + return +} + +func (s scanobjectDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = s.Count() + if err != nil { + return + } + + err = s.Offset(offset).Limit(limit).Scan(result) + return +} + +func (s scanobjectDo) Scan(result interface{}) (err error) { + return s.DO.Scan(result) +} + +func (s scanobjectDo) Delete(models ...*model.Scanobject) (result gen.ResultInfo, err error) { + return s.DO.Delete(models) +} + +func (s *scanobjectDo) withDO(do gen.Dao) *scanobjectDo { + s.DO = *do.(*gen.DO) + return s +} diff --git a/query/users.gen.go b/query/users.gen.go new file mode 100644 index 0000000..8c9a83d --- /dev/null +++ b/query/users.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newUser(db *gorm.DB, opts ...gen.DOOption) user { + _user := user{} + + _user.userDo.UseDB(db, opts...) + _user.userDo.UseModel(&model.User{}) + + tableName := _user.userDo.TableName() + _user.ALL = field.NewAsterisk(tableName) + _user.ID = field.NewUint(tableName, "id") + _user.CreatedAt = field.NewTime(tableName, "created_at") + _user.UpdatedAt = field.NewTime(tableName, "updated_at") + _user.DeletedAt = field.NewField(tableName, "deleted_at") + + _user.fillFieldMap() + + return _user +} + +type user struct { + userDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (u user) Table(newTableName string) *user { + u.userDo.UseTable(newTableName) + return u.updateTableName(newTableName) +} + +func (u user) As(alias string) *user { + u.userDo.DO = *(u.userDo.As(alias).(*gen.DO)) + return u.updateTableName(alias) +} + +func (u *user) updateTableName(table string) *user { + u.ALL = field.NewAsterisk(table) + u.ID = field.NewUint(table, "id") + u.CreatedAt = field.NewTime(table, "created_at") + u.UpdatedAt = field.NewTime(table, "updated_at") + u.DeletedAt = field.NewField(table, "deleted_at") + + u.fillFieldMap() + + return u +} + +func (u *user) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := u.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (u *user) fillFieldMap() { + u.fieldMap = make(map[string]field.Expr, 4) + u.fieldMap["id"] = u.ID + u.fieldMap["created_at"] = u.CreatedAt + u.fieldMap["updated_at"] = u.UpdatedAt + u.fieldMap["deleted_at"] = u.DeletedAt +} + +func (u user) clone(db *gorm.DB) user { + u.userDo.ReplaceConnPool(db.Statement.ConnPool) + return u +} + +func (u user) replaceDB(db *gorm.DB) user { + u.userDo.ReplaceDB(db) + return u +} + +type userDo struct{ gen.DO } + +type IUserDo interface { + gen.SubQuery + Debug() IUserDo + WithContext(ctx context.Context) IUserDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IUserDo + WriteDB() IUserDo + As(alias string) gen.Dao + Session(config *gorm.Session) IUserDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IUserDo + Not(conds ...gen.Condition) IUserDo + Or(conds ...gen.Condition) IUserDo + Select(conds ...field.Expr) IUserDo + Where(conds ...gen.Condition) IUserDo + Order(conds ...field.Expr) IUserDo + Distinct(cols ...field.Expr) IUserDo + Omit(cols ...field.Expr) IUserDo + Join(table schema.Tabler, on ...field.Expr) IUserDo + LeftJoin(table schema.Tabler, on ...field.Expr) IUserDo + RightJoin(table schema.Tabler, on ...field.Expr) IUserDo + Group(cols ...field.Expr) IUserDo + Having(conds ...gen.Condition) IUserDo + Limit(limit int) IUserDo + Offset(offset int) IUserDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IUserDo + Unscoped() IUserDo + Create(values ...*model.User) error + CreateInBatches(values []*model.User, batchSize int) error + Save(values ...*model.User) error + First() (*model.User, error) + Take() (*model.User, error) + Last() (*model.User, error) + Find() ([]*model.User, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.User, err error) + FindInBatches(result *[]*model.User, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.User) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IUserDo + Assign(attrs ...field.AssignExpr) IUserDo + Joins(fields ...field.RelationField) IUserDo + Preload(fields ...field.RelationField) IUserDo + FirstOrInit() (*model.User, error) + FirstOrCreate() (*model.User, error) + FindByPage(offset int, limit int) (result []*model.User, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IUserDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (u userDo) Debug() IUserDo { + return u.withDO(u.DO.Debug()) +} + +func (u userDo) WithContext(ctx context.Context) IUserDo { + return u.withDO(u.DO.WithContext(ctx)) +} + +func (u userDo) ReadDB() IUserDo { + return u.Clauses(dbresolver.Read) +} + +func (u userDo) WriteDB() IUserDo { + return u.Clauses(dbresolver.Write) +} + +func (u userDo) Session(config *gorm.Session) IUserDo { + return u.withDO(u.DO.Session(config)) +} + +func (u userDo) Clauses(conds ...clause.Expression) IUserDo { + return u.withDO(u.DO.Clauses(conds...)) +} + +func (u userDo) Returning(value interface{}, columns ...string) IUserDo { + return u.withDO(u.DO.Returning(value, columns...)) +} + +func (u userDo) Not(conds ...gen.Condition) IUserDo { + return u.withDO(u.DO.Not(conds...)) +} + +func (u userDo) Or(conds ...gen.Condition) IUserDo { + return u.withDO(u.DO.Or(conds...)) +} + +func (u userDo) Select(conds ...field.Expr) IUserDo { + return u.withDO(u.DO.Select(conds...)) +} + +func (u userDo) Where(conds ...gen.Condition) IUserDo { + return u.withDO(u.DO.Where(conds...)) +} + +func (u userDo) Order(conds ...field.Expr) IUserDo { + return u.withDO(u.DO.Order(conds...)) +} + +func (u userDo) Distinct(cols ...field.Expr) IUserDo { + return u.withDO(u.DO.Distinct(cols...)) +} + +func (u userDo) Omit(cols ...field.Expr) IUserDo { + return u.withDO(u.DO.Omit(cols...)) +} + +func (u userDo) Join(table schema.Tabler, on ...field.Expr) IUserDo { + return u.withDO(u.DO.Join(table, on...)) +} + +func (u userDo) LeftJoin(table schema.Tabler, on ...field.Expr) IUserDo { + return u.withDO(u.DO.LeftJoin(table, on...)) +} + +func (u userDo) RightJoin(table schema.Tabler, on ...field.Expr) IUserDo { + return u.withDO(u.DO.RightJoin(table, on...)) +} + +func (u userDo) Group(cols ...field.Expr) IUserDo { + return u.withDO(u.DO.Group(cols...)) +} + +func (u userDo) Having(conds ...gen.Condition) IUserDo { + return u.withDO(u.DO.Having(conds...)) +} + +func (u userDo) Limit(limit int) IUserDo { + return u.withDO(u.DO.Limit(limit)) +} + +func (u userDo) Offset(offset int) IUserDo { + return u.withDO(u.DO.Offset(offset)) +} + +func (u userDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IUserDo { + return u.withDO(u.DO.Scopes(funcs...)) +} + +func (u userDo) Unscoped() IUserDo { + return u.withDO(u.DO.Unscoped()) +} + +func (u userDo) Create(values ...*model.User) error { + if len(values) == 0 { + return nil + } + return u.DO.Create(values) +} + +func (u userDo) CreateInBatches(values []*model.User, batchSize int) error { + return u.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (u userDo) Save(values ...*model.User) error { + if len(values) == 0 { + return nil + } + return u.DO.Save(values) +} + +func (u userDo) First() (*model.User, error) { + if result, err := u.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.User), nil + } +} + +func (u userDo) Take() (*model.User, error) { + if result, err := u.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.User), nil + } +} + +func (u userDo) Last() (*model.User, error) { + if result, err := u.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.User), nil + } +} + +func (u userDo) Find() ([]*model.User, error) { + result, err := u.DO.Find() + return result.([]*model.User), err +} + +func (u userDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.User, err error) { + buf := make([]*model.User, 0, batchSize) + err = u.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (u userDo) FindInBatches(result *[]*model.User, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return u.DO.FindInBatches(result, batchSize, fc) +} + +func (u userDo) Attrs(attrs ...field.AssignExpr) IUserDo { + return u.withDO(u.DO.Attrs(attrs...)) +} + +func (u userDo) Assign(attrs ...field.AssignExpr) IUserDo { + return u.withDO(u.DO.Assign(attrs...)) +} + +func (u userDo) Joins(fields ...field.RelationField) IUserDo { + for _, _f := range fields { + u = *u.withDO(u.DO.Joins(_f)) + } + return &u +} + +func (u userDo) Preload(fields ...field.RelationField) IUserDo { + for _, _f := range fields { + u = *u.withDO(u.DO.Preload(_f)) + } + return &u +} + +func (u userDo) FirstOrInit() (*model.User, error) { + if result, err := u.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.User), nil + } +} + +func (u userDo) FirstOrCreate() (*model.User, error) { + if result, err := u.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.User), nil + } +} + +func (u userDo) FindByPage(offset int, limit int) (result []*model.User, count int64, err error) { + result, err = u.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = u.Offset(-1).Limit(-1).Count() + return +} + +func (u userDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = u.Count() + if err != nil { + return + } + + err = u.Offset(offset).Limit(limit).Scan(result) + return +} + +func (u userDo) Scan(result interface{}) (err error) { + return u.DO.Scan(result) +} + +func (u userDo) Delete(models ...*model.User) (result gen.ResultInfo, err error) { + return u.DO.Delete(models) +} + +func (u *userDo) withDO(do gen.Dao) *userDo { + u.DO = *do.(*gen.DO) + return u +} diff --git a/query/zahlungs.gen.go b/query/zahlungs.gen.go new file mode 100644 index 0000000..9526702 --- /dev/null +++ b/query/zahlungs.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newZahlung(db *gorm.DB, opts ...gen.DOOption) zahlung { + _zahlung := zahlung{} + + _zahlung.zahlungDo.UseDB(db, opts...) + _zahlung.zahlungDo.UseModel(&model.Zahlung{}) + + tableName := _zahlung.zahlungDo.TableName() + _zahlung.ALL = field.NewAsterisk(tableName) + _zahlung.ID = field.NewUint(tableName, "id") + _zahlung.CreatedAt = field.NewTime(tableName, "created_at") + _zahlung.UpdatedAt = field.NewTime(tableName, "updated_at") + _zahlung.DeletedAt = field.NewField(tableName, "deleted_at") + + _zahlung.fillFieldMap() + + return _zahlung +} + +type zahlung struct { + zahlungDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (z zahlung) Table(newTableName string) *zahlung { + z.zahlungDo.UseTable(newTableName) + return z.updateTableName(newTableName) +} + +func (z zahlung) As(alias string) *zahlung { + z.zahlungDo.DO = *(z.zahlungDo.As(alias).(*gen.DO)) + return z.updateTableName(alias) +} + +func (z *zahlung) updateTableName(table string) *zahlung { + z.ALL = field.NewAsterisk(table) + z.ID = field.NewUint(table, "id") + z.CreatedAt = field.NewTime(table, "created_at") + z.UpdatedAt = field.NewTime(table, "updated_at") + z.DeletedAt = field.NewField(table, "deleted_at") + + z.fillFieldMap() + + return z +} + +func (z *zahlung) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := z.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (z *zahlung) fillFieldMap() { + z.fieldMap = make(map[string]field.Expr, 4) + z.fieldMap["id"] = z.ID + z.fieldMap["created_at"] = z.CreatedAt + z.fieldMap["updated_at"] = z.UpdatedAt + z.fieldMap["deleted_at"] = z.DeletedAt +} + +func (z zahlung) clone(db *gorm.DB) zahlung { + z.zahlungDo.ReplaceConnPool(db.Statement.ConnPool) + return z +} + +func (z zahlung) replaceDB(db *gorm.DB) zahlung { + z.zahlungDo.ReplaceDB(db) + return z +} + +type zahlungDo struct{ gen.DO } + +type IZahlungDo interface { + gen.SubQuery + Debug() IZahlungDo + WithContext(ctx context.Context) IZahlungDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IZahlungDo + WriteDB() IZahlungDo + As(alias string) gen.Dao + Session(config *gorm.Session) IZahlungDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IZahlungDo + Not(conds ...gen.Condition) IZahlungDo + Or(conds ...gen.Condition) IZahlungDo + Select(conds ...field.Expr) IZahlungDo + Where(conds ...gen.Condition) IZahlungDo + Order(conds ...field.Expr) IZahlungDo + Distinct(cols ...field.Expr) IZahlungDo + Omit(cols ...field.Expr) IZahlungDo + Join(table schema.Tabler, on ...field.Expr) IZahlungDo + LeftJoin(table schema.Tabler, on ...field.Expr) IZahlungDo + RightJoin(table schema.Tabler, on ...field.Expr) IZahlungDo + Group(cols ...field.Expr) IZahlungDo + Having(conds ...gen.Condition) IZahlungDo + Limit(limit int) IZahlungDo + Offset(offset int) IZahlungDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IZahlungDo + Unscoped() IZahlungDo + Create(values ...*model.Zahlung) error + CreateInBatches(values []*model.Zahlung, batchSize int) error + Save(values ...*model.Zahlung) error + First() (*model.Zahlung, error) + Take() (*model.Zahlung, error) + Last() (*model.Zahlung, error) + Find() ([]*model.Zahlung, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Zahlung, err error) + FindInBatches(result *[]*model.Zahlung, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Zahlung) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IZahlungDo + Assign(attrs ...field.AssignExpr) IZahlungDo + Joins(fields ...field.RelationField) IZahlungDo + Preload(fields ...field.RelationField) IZahlungDo + FirstOrInit() (*model.Zahlung, error) + FirstOrCreate() (*model.Zahlung, error) + FindByPage(offset int, limit int) (result []*model.Zahlung, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IZahlungDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (z zahlungDo) Debug() IZahlungDo { + return z.withDO(z.DO.Debug()) +} + +func (z zahlungDo) WithContext(ctx context.Context) IZahlungDo { + return z.withDO(z.DO.WithContext(ctx)) +} + +func (z zahlungDo) ReadDB() IZahlungDo { + return z.Clauses(dbresolver.Read) +} + +func (z zahlungDo) WriteDB() IZahlungDo { + return z.Clauses(dbresolver.Write) +} + +func (z zahlungDo) Session(config *gorm.Session) IZahlungDo { + return z.withDO(z.DO.Session(config)) +} + +func (z zahlungDo) Clauses(conds ...clause.Expression) IZahlungDo { + return z.withDO(z.DO.Clauses(conds...)) +} + +func (z zahlungDo) Returning(value interface{}, columns ...string) IZahlungDo { + return z.withDO(z.DO.Returning(value, columns...)) +} + +func (z zahlungDo) Not(conds ...gen.Condition) IZahlungDo { + return z.withDO(z.DO.Not(conds...)) +} + +func (z zahlungDo) Or(conds ...gen.Condition) IZahlungDo { + return z.withDO(z.DO.Or(conds...)) +} + +func (z zahlungDo) Select(conds ...field.Expr) IZahlungDo { + return z.withDO(z.DO.Select(conds...)) +} + +func (z zahlungDo) Where(conds ...gen.Condition) IZahlungDo { + return z.withDO(z.DO.Where(conds...)) +} + +func (z zahlungDo) Order(conds ...field.Expr) IZahlungDo { + return z.withDO(z.DO.Order(conds...)) +} + +func (z zahlungDo) Distinct(cols ...field.Expr) IZahlungDo { + return z.withDO(z.DO.Distinct(cols...)) +} + +func (z zahlungDo) Omit(cols ...field.Expr) IZahlungDo { + return z.withDO(z.DO.Omit(cols...)) +} + +func (z zahlungDo) Join(table schema.Tabler, on ...field.Expr) IZahlungDo { + return z.withDO(z.DO.Join(table, on...)) +} + +func (z zahlungDo) LeftJoin(table schema.Tabler, on ...field.Expr) IZahlungDo { + return z.withDO(z.DO.LeftJoin(table, on...)) +} + +func (z zahlungDo) RightJoin(table schema.Tabler, on ...field.Expr) IZahlungDo { + return z.withDO(z.DO.RightJoin(table, on...)) +} + +func (z zahlungDo) Group(cols ...field.Expr) IZahlungDo { + return z.withDO(z.DO.Group(cols...)) +} + +func (z zahlungDo) Having(conds ...gen.Condition) IZahlungDo { + return z.withDO(z.DO.Having(conds...)) +} + +func (z zahlungDo) Limit(limit int) IZahlungDo { + return z.withDO(z.DO.Limit(limit)) +} + +func (z zahlungDo) Offset(offset int) IZahlungDo { + return z.withDO(z.DO.Offset(offset)) +} + +func (z zahlungDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IZahlungDo { + return z.withDO(z.DO.Scopes(funcs...)) +} + +func (z zahlungDo) Unscoped() IZahlungDo { + return z.withDO(z.DO.Unscoped()) +} + +func (z zahlungDo) Create(values ...*model.Zahlung) error { + if len(values) == 0 { + return nil + } + return z.DO.Create(values) +} + +func (z zahlungDo) CreateInBatches(values []*model.Zahlung, batchSize int) error { + return z.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (z zahlungDo) Save(values ...*model.Zahlung) error { + if len(values) == 0 { + return nil + } + return z.DO.Save(values) +} + +func (z zahlungDo) First() (*model.Zahlung, error) { + if result, err := z.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Zahlung), nil + } +} + +func (z zahlungDo) Take() (*model.Zahlung, error) { + if result, err := z.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Zahlung), nil + } +} + +func (z zahlungDo) Last() (*model.Zahlung, error) { + if result, err := z.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Zahlung), nil + } +} + +func (z zahlungDo) Find() ([]*model.Zahlung, error) { + result, err := z.DO.Find() + return result.([]*model.Zahlung), err +} + +func (z zahlungDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Zahlung, err error) { + buf := make([]*model.Zahlung, 0, batchSize) + err = z.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (z zahlungDo) FindInBatches(result *[]*model.Zahlung, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return z.DO.FindInBatches(result, batchSize, fc) +} + +func (z zahlungDo) Attrs(attrs ...field.AssignExpr) IZahlungDo { + return z.withDO(z.DO.Attrs(attrs...)) +} + +func (z zahlungDo) Assign(attrs ...field.AssignExpr) IZahlungDo { + return z.withDO(z.DO.Assign(attrs...)) +} + +func (z zahlungDo) Joins(fields ...field.RelationField) IZahlungDo { + for _, _f := range fields { + z = *z.withDO(z.DO.Joins(_f)) + } + return &z +} + +func (z zahlungDo) Preload(fields ...field.RelationField) IZahlungDo { + for _, _f := range fields { + z = *z.withDO(z.DO.Preload(_f)) + } + return &z +} + +func (z zahlungDo) FirstOrInit() (*model.Zahlung, error) { + if result, err := z.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Zahlung), nil + } +} + +func (z zahlungDo) FirstOrCreate() (*model.Zahlung, error) { + if result, err := z.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Zahlung), nil + } +} + +func (z zahlungDo) FindByPage(offset int, limit int) (result []*model.Zahlung, count int64, err error) { + result, err = z.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = z.Offset(-1).Limit(-1).Count() + return +} + +func (z zahlungDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = z.Count() + if err != nil { + return + } + + err = z.Offset(offset).Limit(limit).Scan(result) + return +} + +func (z zahlungDo) Scan(result interface{}) (err error) { + return z.DO.Scan(result) +} + +func (z zahlungDo) Delete(models ...*model.Zahlung) (result gen.ResultInfo, err error) { + return z.DO.Delete(models) +} + +func (z *zahlungDo) withDO(do gen.Dao) *zahlungDo { + z.DO = *do.(*gen.DO) + return z +} diff --git a/routers/ansprechpartner.go b/routers/ansprechpartner.go new file mode 100644 index 0000000..2ebe5d9 --- /dev/null +++ b/routers/ansprechpartner.go @@ -0,0 +1,128 @@ +package routers + +import ( + "log/slog" + + "git.kocoder.xyz/kocoded/vt/model" + "git.kocoder.xyz/kocoded/vt/query" + "github.com/gofiber/fiber/v2" +) + +type ansprechpartnerRouter struct { + logger *slog.Logger +} + +func RegisterAnsprechpartnerRouter(group fiber.Router, logger *slog.Logger) { + router := &ansprechpartnerRouter{logger: logger} + + group.Post("/new", router.createAnsprechpartner) + group.Get("/all", router.getAllAnsprechpartners) + group.Get("/:id", router.getAnsprechpartner) + group.Get("/:id/firmen", router.getAnsprechpartnerFirmen) + group.Put("/:id", router.updateAnsprechpartner) + group.Delete("/:id", router.deleteAnsprechpartner) +} + +func (r *ansprechpartnerRouter) createAnsprechpartner(c *fiber.Ctx) error { + ansprechpartner := new(model.Ansprechpartner) + + if err := c.BodyParser(ansprechpartner); err != nil { + return err + } + + ap := query.Ansprechpartner + + if err := ap.Omit(ap.UpdatedAt, ap.DeletedAt).Create(ansprechpartner); err != nil { + return err + } + + return c.SendString("Hello") +} + +func (r *ansprechpartnerRouter) getAllAnsprechpartners(c *fiber.Ctx) error { + aps, err := query.Ansprechpartner.Find() + if err != nil { + return err + } + + err = c.JSON(aps) + + if err != nil { + return err + } + return nil +} + +func (r *ansprechpartnerRouter) getAnsprechpartner(c *fiber.Ctx) error { + id, err := c.ParamsInt("id") + + if err != nil { + return err + } + + ap, err := query.Ansprechpartner.Where(query.Ansprechpartner.ID.Eq(uint(id))).First() + if err != nil { + return err + } + + return c.JSON(ap) +} + +func (r *ansprechpartnerRouter) getAnsprechpartnerFirmen(c *fiber.Ctx) error { + id, err := c.ParamsInt("id") + + if err != nil { + return err + } + + ap, err := query.Ansprechpartner.Where(query.Ansprechpartner.ID.Eq(uint(id))).First() + if err != nil { + return err + } + + firmen, err := query.Ansprechpartner.Firmen.Model(ap).Find() + if err != nil { + return err + } + + ap.Firmen = firmen + + return c.JSON(ap) +} + +func (r *ansprechpartnerRouter) updateAnsprechpartner(c *fiber.Ctx) error { + ansprechpartner := new(model.Ansprechpartner) + id, err := c.ParamsInt("id") + + if err != nil { + return err + } + + if err = c.BodyParser(ansprechpartner); err != nil { + return err + } + + ap := query.Ansprechpartner + + res, err := ap.Where(ap.ID.Eq(uint(id))).Omit(ap.ID, ap.CreatedAt, ap.UpdatedAt, ap.DeletedAt).Updates(ansprechpartner) + if err != nil { + return err + } + + return c.JSON(res) +} + +func (r *ansprechpartnerRouter) deleteAnsprechpartner(c *fiber.Ctx) error { + id, err := c.ParamsInt("id") + + if err != nil { + return err + } + + res, err := query.Ansprechpartner.Where(query.Ansprechpartner.ID.Value(uint(id))).Delete() + if err != nil { + return err + } + + return c.JSON(res) +} diff --git a/routers/firma.go b/routers/firma.go new file mode 100644 index 0000000..7a5770a --- /dev/null +++ b/routers/firma.go @@ -0,0 +1,105 @@ +package routers + +import ( + "log/slog" + + "git.kocoder.xyz/kocoded/vt/model" + "git.kocoder.xyz/kocoded/vt/query" + "github.com/gofiber/fiber/v2" +) + +type firmaRouter struct { + logger *slog.Logger +} + +func RegisterFirmaRouter(group fiber.Router, logger *slog.Logger) { + router := &firmaRouter{logger: logger} + + group.Post("/new", router.createFirma) + group.Get("/all", router.getAllFirmen) + group.Get("/:id", router.getFirma) + group.Put("/:id", router.updateFirma) + group.Delete("/:id", router.deleteFirma) +} + +func (r *firmaRouter) createFirma(c *fiber.Ctx) error { + firma := new(model.Firma) + + if err := c.BodyParser(firma); err != nil { + return err + } + + ap := query.Firma + + if err := ap.Omit(ap.UpdatedAt, ap.DeletedAt).Create(firma); err != nil { + return err + } + + return c.SendString("Hello") +} + +func (r *firmaRouter) getAllFirmen(c *fiber.Ctx) error { + aps, err := query.Firma.Find() + if err != nil { + return err + } + + err = c.JSON(aps) + + if err != nil { + return err + } + return nil +} + +func (r *firmaRouter) getFirma(c *fiber.Ctx) error { + id, err := c.ParamsInt("id") + + if err != nil { + return err + } + + ap, err := query.Firma.Where(query.Firma.ID.Eq(uint(id))).First() + if err != nil { + return err + } + + return c.JSON(ap) +} + +func (r *firmaRouter) updateFirma(c *fiber.Ctx) error { + firma := new(model.Firma) + id, err := c.ParamsInt("id") + + if err != nil { + return err + } + + if err = c.BodyParser(firma); err != nil { + return err + } + + ap := query.Firma + + res, err := ap.Where(ap.ID.Eq(uint(id))).Omit(ap.ID, ap.CreatedAt, ap.UpdatedAt, ap.DeletedAt).Updates(firma) + if err != nil { + return err + } + + return c.JSON(res) +} + +func (r *firmaRouter) deleteFirma(c *fiber.Ctx) error { + id, err := c.ParamsInt("id") + + if err != nil { + return err + } + + res, err := query.Firma.Where(query.Firma.ID.Value(uint(id))).Delete() + if err != nil { + return err + } + + return c.JSON(res) +} diff --git a/tmp/build-errors.log b/tmp/build-errors.log new file mode 100644 index 0000000..42e8950 --- /dev/null +++ b/tmp/build-errors.log @@ -0,0 +1 @@ +exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1 \ No newline at end of file diff --git a/tmp/main b/tmp/main new file mode 100755 index 0000000000000000000000000000000000000000..9f581930ef5580cead19ccbf2715094727f73375 GIT binary patch literal 20704205 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๕wjZmCijwhD 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�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%0DD! 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 z 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%0AP3)H8e^9X9JZI^RN>r-nZw~yD@QEpd2 zkT$acZ^zpTkMah;r8&O1w=z|v6%Pi94cGgd0+tBauh_XCgPQ4Rhpsz|yG09-`!Z#~ zI3j=KgX0C5LpKkp-k%?7P}+PRgT*zN;}>eE6F{f`^{-pegR?>?{ZoLUpZ4KIO8tii zyYus&Q!UPx?a(2KEyu5BmRrfb{2J(Q<;VPwnD$3tMC{shw1iYT|FW|}$#QSKM8+Eb z$$ye7v_M07pQsO_@Z-dX{FH|*M#mDn3nJ+YAuJeWR;>BmZe!UOQ=NW5%rrJ#a^BeV z3GY^?Zz`y)sLrW>b!_T{ccuSg6>roxpPj0DxA*AO(Dol!sEQ2Ljb=Yw#;vn|Y~=nEYdVgV^>vWhS!H*+bMu>@w2u$Z z#$pcrz^B*MD;9sPn)-e2ic@)aX#D^~dvsJ;KFP{Gx;)75TIl!xkRbxtLNNuPKalAL zNp*Xpp)C+gCR{rIAFp?M;?Mt_6I{#+zn!ZN15>^JtFLt&oDlh+jqi*0@u7J~*D@6g z<-6nu^Bt3!@UCgTDM*rALrLPbOOh()ZBBwjodhx8>4vK0QvV;E6R5AtwYm(*jc1t_ zg&qSoh7~EM1iBl>mi72vEln8~6^(^00NJ8U%&lPGFuim8Hf#O+R5vVK?(}Zwc`Zs8 zuNpP`5V`ob{yx(f2}`sI)9xmCrUM-PJ6`Pw!~Y<^ec{v-L;JnL8#t|($w4=TNv=x8 zGbiBPLL_|tPkLz+8w~?x*O3qXew|uvW5G=JzdMoRem7>{4*BZ#{b^s-v=ae$ztVBk zZS9)~$o_P{X4@WE`{DlLQjPzhP!DLVnWY^;@G0pRz8nO758Q?9gKdo+;3Bl_1=C{I z5+ZXHp%7V6h~M#0=078K++g6h8mh+G?yp0?ru0#ak#>)?Yy&&)u;$9-S{BTAY^q$_ zQZ;l{?f|}zS1gU({ycBQhb)Z`!E9O;7`3s%YeuE}VSmx&os@IN$FQ8pvmbPy!r3^s zWiETRIVsuuJq^$1=^kGX!JvFKh+FaoZ)0iR`IOuggcz%v@T63wE4vdtRF&L9`+Pm+ zIIYAKj!dqqOl+M+;?=5TbLIN2Rq64$RXtv<+`got{$=-m_AaEJfBh#xXrhyU+;K>i z3JR_A7?p1&0AT7+s_oZhWO99F;vK4exhlD`a{W84OGfrsL-y8&`q!1oRZ&$-MkZIZ zY+*vCc%hAck52XP`5WwW0K^23oc!#lADULqn2K{ZlrL;~mn-!q$JF zL#mBZBk_S>OZ+`I+c(kLt-d>o6A7CC90kfT&PqD6f8GTp1Ijny$z|fGycbb91rXpI zw0F#9&Z$)-@YHy@-XtBbF(9(wf|5ha*VaWy145nA>B^7WO8zC~QoW6nk@CCTh)Krm zCC9(|6Xjaa*NN%VUEv$DYHi2g$WDc`aPZ7);3Fw_r58EW+`{gWQuxt9jBo5#x?P;{ zkG<0MPWqMU-f0;czDu9e`%=AACWmG@Pk^dD;)L4C%X2%QhZv4{gQe>5&r|SBkhjAh z$<01khl~dL=@t889)&dU-{h~JdQ5U)TUPovd?v{veTWT&&5;` z^s!8BL?MBrf+nINZWIs@Vrj-K!|Jt}SuEZ-oN+dhbwwlwt~w*FFyl|Y+#$^(OYF?p z@p@AuGPDY1r93f|@hH!o5B=Pq_D7onkkk2(O$n|4(}~e?*z!Ln4Y`fF5fyVfc-1 zUzS&Y4S&1TU6lCXi|D*bJ?xvQQ)RV445JW9lM1~g>6CRogP%PDY&ugg@q@yg`W_kb zfy^COrnJc?j478A=BT9Y*;O_uR^2Gf`oWb|h05;`bDnmWIf8QkiFrbx6YK|f$ zR?L42cR|<{IsVj!GrCU;8?gyS_VIQSwfb-DM4S2qPe%XQFHK+&6>I8=B+S2C7;v zTk}|{Dj*%!f}o0%tcoLIseV*(KL2wDQHoe2BI4>u>LR$a(-y9nN~ZEk%H#vAD6H=x zKW)aFTUiDtdvY%0nf7PDPd`cY^>b+4c6}FK8;S{|IwyahThbA=E%Wywa^WvBCkYG# z_%rMEdTejbt)JX5y(jsvZbT3k=FGfCXeskw*}X57rSe!Gltv;^%&c!hwl^51ULex9 z`JUt-N{U;Q)GLek`94G9BtTc@-^IE!qbm-@d)KhvEth;11seSw5%e8#7|^k4V;PjC@J)Rs3 z$5pv%z|V8`{VDNOq}sUl^lVpsf=;sf3HA*$#!M=RCzsof_T^RGqn76(=hYL-e^ar0^7))FiPmqOd4$o9(LI_j7l;|~1!V##HEs?`N88ny zwqrrkv|SBc%_g<(8P-CyB7ggam45$(RnjU`bK`X zbRTH}*bhq8)LaYvXSU6X4(=>1n#Z+49@`6~Y6^6)0%W-k1%{rS?4>==SqsER`LT~B zBq->yf*u^4(fdXI6l!a)Wgf*QNSH|V^xqP(>I*&U%Ok?qn7=stD~%spWjMP`{L5{e zI=7rq-a5{AW?R?{HoP^%0y-;bn)$eJYSeAuJ#!wkJOPCxq!wNkt~M8Z+xTSB;XJ_F z%<*?z8FGdxMmH4bwpg@YD!R1|>gE2Oh+}mP&cr(d-P@nj;`#ev(5|z0&UZaxf~|L{MViV zvS119QkKB(7c9SI3Cx-zvlQ{iB1JD{Ca0T4bz1-x3=tK4#x5%$33mNQnV=e;|HJ)d zAJTRw`?L|6ENQ{;%1Hr0v$b|@a~(qe8WVic@T^4}N1AN1fUaWGexRUHCRkDYUzO;_(LB84l7j6^yOFm`FF;SFURuee*$pjPU{QYD zsE|O8<*W->6X>J*1#ZJ`)NF*+)jACkG`RHzonA5=1FK~*AQC6Q6Si@^uB6E7-RbX& zwQ;sA!@Nl2ZM>VYv0x2NJ={qfy?-$vj8J5Cei33+GDg#4!-K zrY{v6r%pk|V?cwiQOm2k2kJKMDns3N_uqLlRJU3j111--du-EWQYc)BgziW}J7IyA z>5>9w9UtH?Uc2?1Ksh0H6Ti|+~aCl$5n zPt7m1NZ&zGrp_4=J}47I=QhM=L&KdAx4I59{=MvI+;6>1v90J^6Jnu zOn+zg$i67tQ#Z_%_>lSbOjdvX?*ETYH=(~}W@{MN3DV`6><@`5yp>3?lfyZonK*MIQTq|-4MVB z*GuEddTEUs6aepB zv7CI2kD=nTNO~RI5lKX4r^vWuTLjavcq(sbtRe~{u~$83j+A&WdsZW%+5*Mk(K=u15s0>ia3&(ms$ovU1mkB#j`3J zuL(?PJV!E^&6bwD#97XrqX{iMZ$*HBM*kA~-QbVoR}vt`uVyvl)`hd0w=Oc7@K|vu z6PD?LR^LAJkFd9;HH`LAU`76Qf9y#AlBPv=PEW^)PjKz%AASqzADvMn9XqMa=u5QT zN3@RF7*M(_0x1rWysX`NHe?dNm+@e=eNfn6Gw?G;BB?BM_7 zY{v$ko5u7J14=)&SWh9|vY{*e2xbu>jM~Ve?WLfCugxQdHab$B%1%_BO+)n>Txz8_ehRXQU>VXgs&Hk7p*Zl4=a9 zH$SvLoe71jROIKnL2w|{btGg+Q}(pY`uKIo@#-Pes+6`i5)sY7H6hXb;(}0HIH7pn z?>iDjOIIfp!9V9;4{XPOkBZXS!Re7$^c-(9WVL(=C&XmFZippc_wM(0>}9~Y>;nDV%T?y>4*Po} z@l{!b_flRQx>Bi=ChFML@zNwrnq@)@vo;mhq_`YcVIkWh&NnB}nB1SNZ81@pwU(J!KI>bMhmF!sZlwhi3 zepou~dC5QOI~``SNT%0|bcyp}-etN^8r-IJqQvoRRX+$-f+Wj!bHA*_2@Khb1c-^1 zZf5EpogGU@@yT8MEk~0Rah@{xelN)G1e!P3w7x2d=+ll(;W+gX`74;F^G`mpJ|`9# zxzkITi;U-_05b)ps8n7mYkf25fEoA#kmJ^g)`j+m2Rnz_%>kDgBqt)~qt3p8A^8$_ zv%=hyYvRej+Y0TA0s-)UN4Um{Z|ss7o^E~JZKG5S2OnX<-yx9sZ>%;YY!ITrTYkG? zfEwyx%#45GH-SLnrAe@JI)C>7raTJylz(NF(irSwWF5L8a(8_66amB$m>&-;|q(A0ybW1!9som6=|N8y)p)OFgqpXnKr5_ zb2vAVk$=rTBhCXDw7z`T>pA{AQ8g^R?fk%hc!Io|)il~kOFRACK|UiS5EK|<>Ay3m zOeFChKOnO}&0(=Y8HZ!7mvL1)hXAS12Y*v8EY@~1r$*CJ3o&l`06AFGxk1Ne#`8GdhygS ziDtZFaothK9DQ+#eNpJITd6O)dgR!QvC%f3B-f^mTnTq)%^M%e*~tQl_A34 ztXA;`|HPo=w6FyFq^P5OzVY#nwD6zEXVw?CL&G6`w88gP$pQl^TP<(RRZ5`~7-b~! zTNNC@wMzhaTLFM_mBb{4-;v4V#{BWIB8LJ z)lKh3=Ci-M-TseNyc|iqqLz~H#+u*DW9oYBm=uP4fPc;}jwF6bxg5(_^xeVOul9iB zNaF}qHtRJ7E_crsgEu|ASkwyIe2FCN)oV-*``_9EmmQJub~ zBsaUBy;xZs6V2JV`usRPk0-bINAU|yC@0`s_GqpDLw-d#hb|8Y2mSHDXh&IphhSB< zXIV&8vnlCFIYS@oNI5O<*v1+0-_&?O8%0JNIKyW~oRySl-m8O4*mUSj6*u)=?LVsh z2WEt@Xb+DQl(_P?t>H`Z@VxY^pt0jDZZyf)h1vLbHz}&)lC8wFmFSp#yj1lW7 z()1$`DRKKjIV-7we0zI8quiWdo?9Q+N*V{fuq23$kEacT9V@$k2ZQR2vrKfGx2lgQ zN%p8&iN%s=xOwoAcu5w|GQZrnsf6V!v%l)rSh^)}M1f-zkkpaKI2M%&ZBB!ZQ>~1@ zwq9aCuCjO;=RmvV&TDX(3_69-O#js?pqkFV&OIvBqvv?!u@@SjUX87HIeQu<@gibF1lu`Y=^|?O-mHeC$r z@TT_!fl=5jO?hjyw+1f@x0o3_zI^kM_DgKtgA+^8dKUJO$uJJLKK?SH?P&MXKvnhS zZd9AdwwuS_JtJ_hwYwuXw%Ay;vS}V5amgD?LoT_@YlB}QkZ|zpMrRzQI{M7Cj~^a! z+`S94g1XbSC539)`s4F+3RKP|JmvG|IBVP(qC$582;nWkfYaf zK6O|6kh!D(1KhJuq3Iv=ND!KpLqHgl$f2z-*cP?BPDNUZ_JZgBJLT@ddHcM0126i# z1}O8tNu_4WFVFuLmm2M|{GA`saz@!sDlI`+EK;?`{HPd(uTX}K7Moj0SPJ)l;+`A- zCxm=0wEYS<5~R;;_H^;)M6uO)+5WX=cYN4uJ?9S&6YPeMXhc*qzB#k7aEFD~OranDPCuvK#Se34*gU^xZ-Y2(<63?aA2(=frn7Z8DtjBt*&varbl z+y4f;W@oc`7--QGG*AN5HNYC#kj4=>Log&=k23NZSjW(WM33gi@CJ@bJzr3$8DYie z3Yf-kG3^QNnEw1a@h-ua@8(4otc|C8vpFGY?uEiVW*( zQ+u|qO4?mEl5x{6jxqmH0mc8}@`cgP6Fs1v6Jca|DwvUox@c&;W+JuzsqFvo3%^4* z)A>Dq$sX0bK8{T;_+p8%iN7AQcbg84atQR(>>RJPl^qO0GbuZP=fI)`vCG<5O`s}|qOD)iG83$?6KzB88)Tt(eq=Zt1 zUb24|9zK@?57X+h(QoAVTYtz4sr-*V(6@{0H!jQnnpG*cV7mY4zpcwbmSvx$zJoO( z8brVRzm3rM`8#&;K!-lze{xTr44?R`c#!e)nAVzqYjc|_+fTOXf$6vN+jY}qy2{cC z&?;~n)^1-+GbX7m8?k>Q`;|nUMgHJn?yAuCNEy2PG~Q09CH&j}TlI z2)6@YZW^@seZY8TnS#Ecqym7lohRO0LPdbVFSy2jd+rniGq$5&NQ>FubsnapkL%j$ zqlPvZqd9fwMaf(_UHWsjX5l-AS(}44fth6 z|5Y#bN3jeM~4 zRBUks$-|g->rVeTC_-37*cc?}Sqltk0y?p?%WZd3`Afxa{$KZznJ2(STwUn@`rG_;)q{m70TVbHv58q$Ad6vQ%H5vpBtS1B)r2h>Fkdm;tQQ9DQqwG7C!N~`=_HA z+0n=$fa!kcY3+l}DCvuH0aglNW%%ApO=aHH+ClThl53PCZ+YW-1cUu+uP?S^OHf&C zh@$-y?2S|{#5-2a?UG6LAijY0!*8i#lEK`^=d3o(DDmuXjr|=j+*wk^TGL?Z{FuG2 zys2y|ZQvVOxL(^H+GLP*gonI=*?a#__oW~*bkt}HhJPW_Xkp>Oem|ql)TJ!6A~cwS zM-lQHrlS6B#a&3!mLB0B31p3;K=xom=vuill@hseFN%XN=SQPB$Kpc!$Rv z*XLh?cU^s^;|M!1Ndj>$YFrk6vo!EK?#i2S4~?cjvPRj>A?^7kjdFnMur(N$4K&R8 zh-x_6q2ZNVUBhmExf$nyS_gdwtOK{+cSf4lUz=mCU#ZrM572tLAMKpF5jjW?-c-Bg zXk`ud!k|t6yFqisYOegt2HSPUgNW{0=+?;f;`;(}ZMi9wTcH+l^!Z~5AjA);yRoy2 z>M>gu9mew)Wiq}XW5xgUOzH_kn@xI@k+ASsdYfNIxf){twtOOq!PT*PR--HE2w8E{ zJ^RRth8cWcpB8}u!GQV{V@Kz0{o#Rop{0wAmcl-F{5Ac4NxOa>0r|+Mm>L1y=apbz zsbj#3=LidvC(BzTBuHN-|L2(t0-?gm42l{iGfQ4cbe_6^&c%O1kF)o8Y_iie?X$k| zeZUj+q0DsI`+r%7d7}C+D>ePz=Q)w9q_Nh5Fr8Q18+xRK4*g%^)=QE|qtCOtTAu$a ze)O+lxUVZ@TB^@$DpDOEQ;@O6GpK5jp3d#rqA0Fq`T9K9`fwFjpcel$D)E1WM~Iq^ zIGQYzBlyIPZ_h_xwEAyS)NvCVA7cd$Q^(T1?>BPK(EoGEy_liL-Bl2nInVu>`rkax z3FczWDE-HdW9G;gKVW=b5J&@xJa4g@K-kj2vzidxbQa&aid4f;@Y0Q zYfCHXiTkl=0g6^H(p`v=XLaLGB={xc-@e)M+uUkyx=u9N@kU^Oh(;i>AL$3zQFkMp zY_B`|Oyddg`AIVoA3g8rvk)PJTcj5~OZDlsWnGSWrXbKkjA#XT+wnGY;mwNkJDh_U znLl*n`BI&Hvf<0}j5_&pal8CSvx(KQZ@XSiW&Q(;cAGs|+L)Ud{*4dBnT7tNY*;f* zKaRCLW%MN2p85CHH{|$P#nVwmArHPy6+{FAk_)LNG5nMF`MjP$9T~5O2mBXSWp?1W zAVVms9r<23iTGCPOALS7zGNXwU-t9A-sz*ht`E7H#PIpydrX^@c&nz^Kf~TV#H0tR zmv;*#Z;)n($C8&3TR&*hA@xu$(XHu0zkTvrU6#Ub=seD*$-ni1>vH@78dSQ^SYt%| z$j5}upjWbe{Aspy&9#!8!l?eEY!g60ng2)P&aeM*DB+2%>*(b%`8Ya|O~uY4#k9?0 zK<9cB2KD`jl^EHDB&qz-RMkOY!|5LuCTvY|`;Sw<)ImY^VH$Dt^K*I_ zwBhM3j0j?bO+RdAS!JJ~3k&u`1t@&DD-PYnVkpQo&#wJ|0*nHx=zg{ilv{ zd{~PM5A7kVDJVJZ>#n4nq1>=sowqhLKfCNT^B!XMSohU2{Qp?tHU@Q~u;uhGRbOs? z8f(K3jS_Yc_86C`e}r|)tQ&|HCkR9%j4WNVTSAhK6#4faL-!0j)(8K(u=)RRe)^qG z_-k*UX{!IgU=7`25?eg=jyROqhH)-F-{1T@vFah-^2$Pxl;fwG!+yE_TYE~ZZ|G9j zx79xk(c35*()?+Qn?EJ<0wmA=SQLpFXo3m{qryWW&^4opq9D=EU@tYTFcZW-%-$=R z7)cE0>t$7^7w3Ad=fZ%~IB)Nqp2R25-f87?3n|xTg1P@1h+amdGF;nP6_ixeYvvaeXzPj0+m?75Sd%EZ}#u3Y^x)&D! z6B6^B3v9;pa_b`u$ie3kKG9)=w`aKU()SDoKFU2DAG`$H_Y5z6UNM`|E1%6lp9wzf z%3j@Y&b)y=W3A0Gjwy&Gb{TwjH-M}uZ=W--U(Ye=yn_H}7q#e58AY{_@6qi(Jm80T zTu=yf7$!cv0yUjH>&=GY{m@J~L7I+y|K98MEs50Ml&pZmke$YW{g3%RUR!dh$N`VD z_G@-qhYxaPmIF_kwSG&`q4vLHCalU--Er;&1*g9!lLSd((Qv!`X|!vsRDMUzga$mK zOscGY+q50lZpJBfXCFoG6Apk9jVn`fIR(?Z$PH3VW?R-(kt z1Lh)P8Y|X<7hB~KZf%Y{Q**LX@FYgjDQ?QV3eF6l%!(L8Q*wogkp%}w8{bqaFl{DD z)lRhJ>s^&-jm0nar`I^qh|mnI_fr2{VH60KYXAhAUr;hJ)3Cb%A2ZE5h_&28gKOWJ zM^Vf74Iue_{|l$z@pRAs@I+)p;34(TK)|r>$dSz0KDuMo01N-4Tkw=0LyAXVm-XH&Ozb%h60r|J2I`QGkV$pvXJ^)IsDy zgqlZ8sB8e!J*)6%UL9MzHQTMyWTu;&* zB7B=)_-*TFCsii27x@Fi9-BTBR*PD+JRa)jf7}0hrePiXf5lt>pZh<1zy8-;`DOjT zC>cQffc>9(aR7Vf)8^@d>pH-G(WS2MP&j^>oP3-9Aj{quO#YMNbbpw7jFs{79 zxg^I56I7V06TEfWOZE`F%Tmj8~z-0^`qZ1&QJl^jpghR)c!d6cfCAn_i~X19?gs*`pcJJ7YC-#!)jd*Ye8>*$Kfq%3VK&&+ku3g zZ@AtafHqIrzhl|kL;k)SQV4h?DzMhzwpM^e6t%p&{yI@NbUCAw$h!Sv*RAn%>wD`B z>P%ilNG8W3|7V@Id>I`iI;`qVJN5<9v}jISm(j__PPd4Z6K*3x{_9iG5v7#)OG`s3 z-OgZ+#IA4p5)dn|)4nX`=7xOgIsJ$qhb<fRIZeao3y$`D$K?p{in-UUp23>q{s{`%cjkOuqnf0`&;T1qy2SDAh@zm`#{E(wwr+1{E zFKJ**im-utG^uWp%tOU(WHq}_(TVnC*b7!~g9k0Hz3F8l@p$$RGBi&3exS=%(C3By7 zg9b3(F1^Em!C^f%U!W_uP{ft*OZ18uL7M@mdYbJ%|AJW;$5-Qcvk&R+2e0@&hG}l& zOO{lz@y0M*CXL^VZqtnKJYU3$phB$XRKPt0YM<|6eGjJ zmH_{+aBEHv!2O$#%Ew)=!F$|%sEA=6^^>N5dMr)LO74y;2Zib4@ru293?Hx$jN}to zmQ5N$DK$mF3Y`(IbdR?R^U5M~f$0S{DVk3-x*d5kzsb1-^b%oSe*H3Ht;G9i zDWw(^rmdWh6g~}dUwYOU6vd*JB77|Vjfu~GZ3J+!#{qYCWkGCyrAX&eamvz37e|yr zq^*)z+tc)=J~b(5NKLJ5s2)}BudHf7N$4bn+v{U(OY~4ZwK6vUUY=-eaPwIBn}?zP z{A5FNV@G{bbxcA7omA0~Y7JS1dmI`CSoUjj*l*+{m1UG~9M&#Sw#NPMWMN2QGLtN~ z6-LYUi>6Nj*kBCNYsz#qmfs4(IjdT`BI4Xec9FPnnHscj)uaOeWJ2lDH8E_4&n~si z@^$semu!l3fBiA@(bRS3$sX^|6-J3wSRflKS%6p#G-m~=LhM_m^Pz>9WS*@lqt^x5 zfcJjQ$8eR^J^*&{l{l*P=b}^|d1xtV15x7XC_na@1HgV+f!uF&HmYm8$(?}i@R~k% zdywP^M0I1u3`VJIE9gL(lj#uuK^cpa0iJY|_HQ{UNR=eMIY?Lhgm)=r55tO8k~+{G z^xt&JP?s8#I&Tn*d0cSM1B>Sp>OtEq?tU%T>`}t+JZ#$dBN}5O_S^%{8GjXC4ox2k z>~3$dBh(t$iqGxb0B`;FdH$^PIol6~9rh-t@!!bNg$1cgit0If{D>eSWOs67_It(= zP@8;KhPb7~A2$XNk~wU{x6ENV|I^rlXL{&+8vO=4jbZ#vZHKfKk*o@5Yiv65gDq^+jZ^s*qyj_$Lk zmC+=XPG{JrSMXkG?~1m>k-u^9HOQaFj0#R?ds69#gyoV<;F!W;#LCvEB-Rz;1XVd` zy{%&ZmSI?_m^XRV@n*}%v#6~^(S%R}J?L((;s>G#m0^!n zjru7JR3SX>TtZPvsTw&l3aeG_zBNVy-&fdQlg)dr_asom`rpg#0h>u1Nm2J6vR1WH z7Zan~tk-n$z<_iU&(DSFoGz^+`?wdOoS9ILyGyN5kS=@S4AIU;I9DGh;mls*Lu~y6 zZMMIEQ-KP3Xm z{lfR=7wf~R2KgPPRl2)KbI-5k&%3I?L&`V{SRpYryFv&xKM~hu1Bk4QRPbu2|23z2)xH$&uRy0jA_{LPH)>pI4VATDYt_b354 zFC({o$ID3IJhv22#px{W*N}!Ujs@Sx@D@JNhY~j+YU4k%ug4aAA0Wf^6D*|_d18ER z3ntEvX5#Rcw%$}x)KZV!YD56fIh})CL49h0rZM7ctebg>XGbfST8ck1)Ps9~U4qmo z1JmPU^~qS4x^bxDE=}MqL#F8PP8aU_siC?eyyfrVXL=Xz7clpAxmWOK@%Zbbq(J|( zLwxqpO~Uwgy5FaSWrA1n+n7m06~9SfqL`xE@cUS~yq5xehwiuEJIXukcc+X8Re4Hi z*>}|3b&AE(pl(CF>)c0#c$Vg7brILz>PRgrw~1a-Mlr{&LO%M$sKGzWl41F(cgF7I zNGS5b4r+QYr#WgM%wT7T7Wqq_Ilj`FN$C;uyjF=V3F!jQEN1w`8zf1;LLnkU>dl>cHT(MW(u^goXJ zN+3FH*A~`G>)kUy5P0F|5KLbnYI!%9eS3BgzP@l%=BuEB!zY;w4JF%Ah?{8QD^J(8 zUoxpa^~3OHtOv`ds9{=~#&2zs6EJV+dIm!SGY;r)^H~`N%SxiMPC$n$f|S2lhn8?; zkdAWcBEK_#CY*l?ZaKA-eAea+Vf4-i1tKm2ZTIlNMT8^k8L&w-a%Bg)Yx4lEnw?yc zJ(jz6?1!hCMx~k`si`GmSO4GCXoTgqkJmOR?PL{PKYF!} z2cluH1Q!HB>(0F>x`CpNqf+O0)Yam4+5etB7G*9)&$cUW-HAWakn@TZYc7s0J&0hk zh@EcaaXAFSmLPSD51PiV#r@Hn!Ly^0a*figqD1+4QVAD{u*wkrakqFF%*GOO9Mx*< zFh+9d*!uLvY?QH~QQNxnU$KP~VM(5LwOrCM0bhxcZvIm?3vz_Dz`G6q6P3Wd$XE9b zpEU8_Ffh8?q@>66l^L;y=F6q!jus%+uc8hDV$TDbqQ0PJC zFV$HeU=fePHyD4u*N-jiI6F0p=+@|WwXHi!W|Y@H3Qv>kE+yrw-7U#2fsqRiNq>09`;_>AJR8TPC_+ z{Ey+}keT7&G5?`!xNZ8}YxJy5-&}TRZcOvO0?(|yCZuZ%v;7HAEksqt6HoWc{8G)e z?)?B=?gn2Tb=i(k zW;?9yUU@3>~7q#qwlTAm!i_n-#o`mCRHq#ZICMQ zU}UVAqNNPs@Ig%TIQQg)3ej`ych3AWLpKNy2GQqNTHaHDoBc8R?Us8C2Tf|bb*Jk` zo8nwVtQe)EpJU^i&HurNzHno~Q__KRx|B=fypo3q@Voi?{QhSKA+z!gIKKZYdiq}@ z)fDH|U9pxkgXPm(u5Z5jx+{(gs!Lj`=FTp;>V~GTw;X@v+}VS!zq;kf*4g_`Z5i#h zudq=)`45ncz`?(UF+FW1U(K%U?z1^W`?0V;XhqZuuVu1BjZiFvQumnZ0Bf*33GN7L z$RUyazwi}Bi}kr1p!&C{gtuE$Ly0Ml?yuM7_tw@oeL9@qd7gd$7wp#mRBIWGDO^;# zjp%A{e~Th>pQLtx9!R-JI2Du=$d6Yp=9PqMMD*jO;8q_%SwO9jLPl0hUS*PH;C00k z+A5R>%Zd?d0WnwUPUc%)U)<-SZv02_bz=*DPfa2HP7;op??Tfr&<29G#+|nue5H%0 zE3nl*wCB3IxP%=4H;-w_H(RN%&F-I?WGnRm{JER&*8GprWQ}7b%Anj)-YRIZh99f+ zUCXT6(Wg=EzN+>cRBPHPFVNp&=eX^enUhSyDjo8d9;*G#8XP*tK1sB zri(MzN9m9AfyxOM)9HRMco(P!H5b8jK^{yqCfZsjJmBHJpd z7k$qRLfU|RE+VkWyxGj#ik}Eg&THZsT5RQq%a0L2+gzaWP3VfjC(*kKTvhH}{VeGV z*f+niXTY)v_)F`vR;id4NB9l&0E1=j``eAZo+vNlQ|tI+SFd6+ZTlxJ5!|uT?rDFQ zm)e9~d{_{>(_2|?Ya*AdEZhJm6(0Q=``iEUA)crvNzoRh(R)vx2g`NAqgEffnNnA@ z=~7AWxLmuiz25lm90c{Fs;doe((OUoZ)ivM=e(ui5c6@w^ezKvDybsDv;5(QFJm_> zyvr&~`#lub?@%R#pujZ(K?^m36kF;+k(plzs7o!BS+;iW8#*3=4%?qw2~uZ5Ghb^; zyt6ArN%O(k`-`flfu?+O1yww)z-9lxZd^#{E-L$oI5p6*P$W} zd7``%!0lm8^sq5{a6I5DI!`|=ij-3;vkJW^xA41;UoE3lNcffNr4_5n+EsXZr_(Bo zEg-$fp1Rjd$Pl!|CoCh8s&i=|OUQ83bh{XN^a7$QR2Sj~zuF=7xN~OA#x(aCQIH}U zfN$lXbydg}r~1^vW32SFk{Ekc_xtA&dVWY*X-MfB4W+5ACHBj;y7v26`6K)qe~v>| zYOSZbvBp=}ZD2gJxKO$%^}l8_$FTm~&gb1WCXIRh9Wsqq?U_-ewN+#`?6&sNRHgmP zPR~4-Q+>!h%RpRvn{B>%cb~J61viypR|mr+pfy-#T9)7{XbbiCpSVM^MYK7oI%Nhd@AG+>(G4qy+(gw$n4 z6H?zOXW@BXMRp?hqD~n5*9l|)A|uoI`l+u(@n`(~LIl;Ji}g%L26@|nIH$3rs?JPZ zKD_A6)V0G0VQ?Bc9QB=>#yE8jqa4p@oHePg{k%zXYYk6!Os-2_t{7*E%FR*CX~Y#< z)JZh4y5w7R$xIy~1`sGlC+KgBL-{KDL4!U~I?bfq7;70>Q%5kf%4C<=@pv7l(GdgP z;Vsr8nwK8MBt$W`r6wIbCBV^hn*KBiIm!rfZXIGld;B{iyE%(PsAsUTYt0%;?epc% zs(n(fKZSm<&qZ3X?}7UUE;I(DX~lQ=iNVzD-1z&kgm-oz3cv6rXcuzY2uYyLu?DhB zDsiDOT0xz4vxv^>e*Fs*bQ9Ymt#tHK>F2xn%*x?J4D*M&JAIy}Ux%U+`MvA6h{IR- zo~@495?N3q?s|g;+|72gUdU2VranSS%4@8(_e+6FzHrWKYLw+NKEVG~QmSYEhDyd#2_H^`BhyV*&U3vKX=V`t z`#1dA#6BX1(7&E*BW7N!Z-O>2>(k0Ay+6v&c73UOy+jpV@pFUb^SKVa{Fnz=snVSr znUehcF3|2(_OM+6BjRK`q*C%@L-T%#6(&5nNU?feCxq6#A0u+A;YWVscl>~F95kua zF#85-(U!d8!FRy&3Ws~)VFT;6--2hU)|!9w0CT_eQ{gZ3(np5r_p4iX`t&RF(su#B zK<-fb^`yJCY9!YQk4(Yq8cA>|jpvVfGIolj%OYE_j8IN;U{LB!&V*y$NYjMsm zo5H~6t~={d5HOzs_w>D3Il)#dxkLi$k8F#_$+UNDhZ#)RpC9a-GzL#=(L zS8Tt&n3?i8Zy(lX^=F<(jD!gsSUU^|kLNJG)j^BY=bzm_hN)drC3_Zc-!tx$UEU7= z&TVFg_ZIhW^Mb5FSD|ufEm|@9{%yWAR6138Y2LE&H0~UI{&_o*rGwurpYTISd{I|W zbeb@vBR8Q|;ccFddhhQvRgHF-Z z(I{}6yd;E%T7?M4+-QisI_YKZ2M^g0Uafdx3RdWbFmR&9Mt9~fE$P}{L>l9^M;O!f zDnL5*)@k=&76gzH=sb;#FO_ogB;Aq%P9olNn+*J@w?*qzq{99E6p3nC8IaN5KLGuq znVS-d>M->%D>YVR2ijC>dVv`^nIURoi#Vl?4G7CJ(;GzV+L%ryUzimWYP3eIR3)G) zoTE3HZ-{1@9cQ1=Qs$Qa#5(lVcj+t3M$WI%AwPb*lqCMv=d%T1Xo)&rK$aP}eJoLS zz|8fN&O)PQ-Ud~JzHyNFP)IJ6D+gPaJTgNq`>R0tB$sKwZ?ou8n4E^Td=`KC_B9el7faFaUx1iFJxGknb#=tQD|t}I14#-LlEgQ$IzTj(YPL3R2eLDsq=>ysp?8!aqc#qu-FvTrQY0+N~gvF)B@zGw-dCWOC-?3aCi`(;;~ zU$^?tLT+>gHkWCHYe0AGMV$7pfHkAlp8Dtf`uls74Etx5Bd9w0B(sP$f&kM>QuM99 z?g{Q4bA-z43Oa&kpQaIpaFfEYBv<<$Sa)3fB@)yzb;E-n*2pwzEucQDWuw1ce1KvRmPTlay5HUu1QIu+Xu6iC=3D{sw--+aWAWBxy}%wp51`Ml$T#3K3K6^yk>1 zyRxG;v7<2dUw`8Z-ggJI98%l5ePHtl{_fwrpYYF9teF{;ektfcXhZMJ4w1=c(v|3U z9I%mrXOeBHoZNd$<;ZAD<&bbolN4C^`lg?%LwpYBW!=6N=XN~tAEcML>Yc%m4 z@M)2xE9o^*>aicF(V1^XvZ6O-`L~d=5H)q>Wggo7gC~2oohmiA0@gMiyyfbeT_v%3 zBN($F{pIa!1B90iC$=CaW_%Q+Pc6+3wl0){wC)$AzZ2g%MGqP5qAxO9$F;o6w>dZD z;_to?TlfU&b~IJzPc1&in1A4R|B>AAKiU+q?^Zv$D=6F%BtGsxr$IH9Qd30>cN(8x zTG+bts1}0Lod3n{)}3Qojtdg2|E&ut6wz$wml9k01%q3_>oHrs|@(V(7Z!MB-x zl%;#O?x>x9MC*=AW|e713K!DcHycwz2??=#yRv(+0Y$J*bDpAuI0bY5Tc_sPAi->~ zuBEVGSqXj7EySnuoqLD<{??7GX+umCTA}J!p8jJ?9}xKy%xCEC)Svu)N2*;yGx^-y zH)WOPeC>=wlCSs(J~pkU$3OY4^~mueEV}0pFUjtod}Rdj1Fs_wO(nKcEhcgye%}c`?2F0Qi9Yil_l=->nSOYus41atAeJ zN4g_IVE%`SOy60g#2fhP2KuCB-zCYW-EW39pxq*++&7eS0-0!ZXl%tBgJzVuS01#c zhp(f|0Cjc(nSA>rRUKK`NbkILocp=Yd2+7ykzws4+*l9)-CL+cRPM{~`XS9({f3*w zvW+AaG?%%{d`+pdBg64}<+S=OXR6hfuITqTuh%eMtxG5>1NPpvbl036^>?(C3g5ps zd-_+IVy~k5w33zqwkpnY)criUyhiW)raB~b5ksE92E?R5p+ANZqFF~c#Kksj(`{NVH zZ?`y1uXICvdcVeS5##yq<}kg=eegZ2|0fSn-c%^FA5JFSoh+yTVnk3(SO*@pojCXD z0?;B#D+|(h70BckfKMtRn;QP;m|hz7(jKNv!pl5}owkRV5KUKripTl{LYN~H0>p{pH$aY zavq?%wxStB1JN(5*R<@lY&3v!6YtZ@PSwM*FY52^8j$CYB_u|g5JnvK>02wo4eh(h zoWqn6LMJmST6gT%Jg{{~adUC&j(udPp;IUVtviOaluIA3V3D8uni|~yK4S2$c(X8e zPna`mjC9y?a`C3NQh>^D}Os@T`5M5?c%2bQaKk1+E z-+Mj%o1%J}uoSL61505?^Wp5i%#k|JUo>+5*4SS{Xo$Zv^C^njQ>)=BGn#kp_Zp#% z(*5UV-1{h;bVs=BB~G<`_F#eBOfLSKS*#H zUg`2|4xAB61iEYrQg}|k*1Zk`;e3=k#9#{nqv|-2@`n95na~CGY;4Y&PMgtfWG-9w zHCT%$h+2kkYOU03m0o!ggPim&&!F(zr7Zb>EHr-oKJ7o;OiK0;H&hvjcYOjlFQv~e zK^CJ=65O^$mO8vXvTs~rsgfV#!kPh!JwN8DIcgCoFuyB(I9Zn}qn z-D_tJ(d1sA+{XOyXea3AYJl|MHP1HdPR;b-S9u@+ZIBv2|8&kv>t-Sr0NcA?@#4VX za$C*_p~)`(BO|9sf1KwwSMx^=c}OX{!u4_f)1m>!zMp>jVWDedF_Di*>( z9qBq4?=VLk&;4dtocgROlq+=+F^x{cZ+=iY0hHvSNvx(XG!(Aqaj*L7=Ne+CuhEUu zC?BQqG3z^m@jhA$LDdcE zxZ+ryL;$NHL3$7|!{UY6hjMI-tA>uTnwlJja+=USYKVopde1^##nQ7FSjErs0i8Bw zA46m)2+ue0qT$zq?V#Uoz7jI$4APhR>;v$u<%>nq5&Z6E-dG2J(!Y>CDnuVu>_0UV zdgLO4Ag)q}w1%&Kg}c_X{zi2+aQ1CKzx+tImkl3J1XNDQQSOtfkLYiN>ZcJ;Pf(W> z(sVHaV*p-KL{o^K7=IHgMdhxmwlB%SRW+1=_f0@jnebR;(HTeV83>avXNA3F0`T#_ zOFL-1D@hC-H|}L03lBo@lLpsaT#WxqF~p}_i^=7dzDlNqZi93C;EIv`X|BIsejLU6 zCv2lky)YqC1?SYLrvcTRPmWywNY-pbPm%8Q^wpX^J?(I9H}(0XK0}DiA?b4qgVZP% zA>6mL>q|jb_6tGbKX}~BRKC+$zxxxB1eF%D3|l3%Mi#U3}D8pD~*ey8&#b7uBBNN)| z3(E5H1jbsqIB35SdsnZGE&QJGc|K#=iSKjLgG!9MxJR*vb%;9GsVHc8u;fQUgZ&iU z8=S=p;~ZrV!SYQS|K{2~JZjg=m;83~n~Wzv3i8ZZt?M3~p zNrp_lJkZJqb9Y(0ueFcjSh??MkUSe|)}`=-Xd;>Jasp zNEYbuIg){uhCA^~`MQH315gq&i}z$T$gy8Ie?JBScjs}j@9Xnn-;0RVC=Dvdlk7w!=@#bgKI%=t3<<4~Y=i8m22$nTZo*>O4f6DRSoSEWoQgSCGv zf+Ki)@&gM@coG)loqMw_ICq!k)fs1_-X~v3tZi+tA5oTl5%{8%BilHSKBA1&>@xHe zJD<$T36KViV9ozIfwc7v$*7Hf^iH3maSvZk=4H>52=b5k%X9Pb&**wd&(UlKkthjc zHsPbV%~jG%(PgDVUWNOToX6jb!eDQFyp3?*7*pk$jjmKT92%+2vS2%rn{bBih}_uiN~vg!aKtgx{Xmw`cV&BB^IiWBiT+Ojr45 zNXor84uU!&>am}nKu6TSvexmZFs0!uE**?kZW>5b-(mj;hk(CQJ|rLhdfxf(o4>Be zzC#7JmRm4Uc9>hhZn$;Yc&b-W--nmo!2aStRp`&@yh20WxxEVI1@(Pg`I-;M;i$}A zYnl2)^Bwl51%_It%whli6pD7Tv5dzzF1k{W5E~BZ$-&FX1o+SWEC;^US1YIZo>8_q zHi1~bM*$ma2$Q+VlEnDx9w7Gj(VNkMf5JdG}>6X(d!vpT=*@GwR+VP z&GIv^<(W<}%STHn$Q?y3!)sfgWRIM28XSN2jM6`0RkZeTKbn7m@pTWxTHp+Kr$IO% z0_D)XT1B__i%7CZc=P1@|58u?OIyd^2MSqr{+y2{YS+Q!m_FA(6uz(V?_Iouj|X^j zzfJ3UhT?nm{8Rt@GoF#JBf$?TKlEjey+MR|MoI*C1Y1FA71+q8w?;cP_-tN%AnCyq z{Ub}c;>&r|KkPE&kKvi>8u$t457nRWQ3{GL`%=Vb?zxQrWv<{$KH? zeVRj^3VXh&e6~8pH7+b_t$*6C!}DOM*fanH_TTRk`{xyMn@< z9CVM(-vm$UqGIF-zIIAW{=B@=5Z0{4Fvr#H1wSN9Y%6cF_eJIH`ek7fSVz-e+x3(> zp3x?{JS;Re><1n@55h{Fx{h^z3a17>j$QlYiDYy)&G)ZtdFE#uE={L@LlB;WC+hS6QD zfrm&-ub1mG4&+-v%7pgv1MAa82l|l2r>N{rdv(rU|)MpT?zMQ$Bg<3>ER^^mWsS*mLJ}ovTwC`SD4}4nRSY?HuQkkbK z>YH!%ow^%*J@v_0$@p275AwX{E>o3`z0|fB^{UE@6%2HJdhkoPZ77(S9Ey$C)27D0 z-Dn`BS=Jw1jO_{5R$#|xvIv~o#0Q0S?DP_mnA~4^x*;`Z=l1&KoPPyD_p>4-Q5^g8 zbGwbc(#Lbku0DMmu@e3~=cUYO-Wrly!llrGsHE|(_gRBL!Am&-5}*4om7lR8 z^KUEiURY#rv(EgLB0DHDo+9zN|F)c)Gl%omklb_5srfmd#@ogF6vS2wwLVP_EmgxzT zA?Hg;^eZa2b*xku)>fGx6R^ckvzlLLUKr{YWt7mIkskIP$%9nUD*P`xo5%9ue5=o{ zX)&vW)?YbG%qeWf^fvx^1xE_EyD4fldyj9j*I#S@${yXO&)sMv!khHUY@$DYHnZ{1 zR-rf03ziPrY+3vde~sn-N;__~(qsxx4|{D6U5G9R^LoY&z?n_&)_!ckPx9^&$CNWu zKRW@Z7mf&B%gywOw+rjjY8-)L4xwsnDX6yz$Zg*a+3d9zBeju<2e{pT4FLOTw=1+NUH}8e(;SuTMIS*TiSr+#B)$;U70(_q0%( z+z`)QrH5r75Zgl#IcHV3@TlxTWbyT7W4=lMhWof|KQ*?!&H20y&ELcf)D)ju%2BQM z9W+M7NHjt2BHhAu;foF^6+I@m${mSwd(2UfTOzra>6n(>GlLn}@(Z#>f0Gm-}&1rd{qAjX*KkJo*<> z1)kP>#D1T`V>`F@;Ju+fJ=NnKjKABEe7iRBm%_82ZF_f#28e$>RdQZ2{?XeJQS^d` zGi`MX56hO2MOtyE4x(KZr0!cn1@);j5GG6STg7uc`MT=YCG6br`neFRhEpQ;=-#I$ z6jEXJ&>pO^Q_?^0iijClVorUf2bT;BGNMsif&M;KH%RU;;fwLlu7+rS%31v6@Oq#- z?dW{QGK-&lTo25w&A0g3{4qO}-OvpCxiT0|lcDRioE>RVsk#$Se$bFyWx+;7EU)_Z z<ZHFPwOcpLaG56`sy=b` z=hwe8qx)Z2XvoM9ca-J!hsT}3pdj5Vw7#&pPgCaAYb61h1uwmkS+I~$$Bi}>R8mel zeuc%NSH!fN4<}z@PZ6WL#^gh8)`84*eL?l|i>>@<{%q79HWEuh3_zLS#9hgaEYP=} zp|Q7}>GR8{v~gm_l3qeo;r4l;-PL8(g7y^ea$kh0bjKjuaO^#CZe51Il6pmq?aW@q zark9KiSeTDrm;lUd67H?fTgvwiEXZ)y_%3wOK%=!Ye zQP%`qotrwiXFA$oRQ%D{{A+~U>a(h1^S`bq=1UNXR|d8iGnG$sC;nnbH>O97R3=R9 z*i5b|4Ar)AQe{E;l!a2Y+-DXtN9xQ9Ta-t<5}Chk(s9)lyN^Teep8SCd2}+TLwVte z*MdNV8}O}$8;UjW36o{G*ScbGrWaG9kbClRI2TRPEJ`Z_vbrrH;+XXm&%x>=x~)aF zm8)nnp!?>jK)hGeuT)`)adDs7(#@2Ujx^6bO_G_Bl{zgcfr~vkgUfyRxe$iz!+9E@$KSVl=(hsTX>|Q9+p*5Tznq!b zisd}E5DRxf&FxJkti@yVPc!tLU(TX9HK|mlv=cj^HeL6EeYfz#u+*$Wf-%u^EK#6B z>7xCEw8gE&@Fl>w!^*w-ICnA$>MApb!$4DcrTVbWbMxw)$;qTf5W!W1!3g%}s)g$^ zwF6a-=x|4`4Aoq|jeVT+ZS z5>?pc)klG{u(5~z!pdOR2E7!0t5e#l@Ky!$G zdr>?_EUwe{!60^|$n75T@nPwIQP_^N&Eo?NMkM7nPpIk@RHx2bSrXoRPTnsBl(-Zr;)3NDxX zsGWbxUCVMJr%fT7DIwXI6xEW$jXNx#?5TT1My5nh9TENK$^S;dHzi2f`az8|4VWUt zW2MDve5xOP07nK>-^FAP=D6_uqTJSTPfImKuN>5?BkoUe=a8m0tYe2ZqpSh1ATiqMJadQ zeB(-cHL7tK@t@uQJ}GR!N;L*OpB$`vv_r%~DJ zD6`d1iIHfqU(wghKK!Moa{P5ON0*k5Y^GUnQtw~rId&bh_ zR;E0Z@m@asm{!960hdva$@g6Unp;{|sI`LTuc=r0H2(mn*CY8rN|5@sLBg^CfpK?< z^$GF5e0128%1E+%``KbxM%}6L-6>c-&k)KO>IhG|_<9ANI*_t%{gb`NaPG+bZe>o$ zo3(mK)adh?ux|`TxNOYtz$PNF+@A1FVQf5rjb@^TuC_~#qGsb2GwYw6WWAO6Aqj06mE098gdhcmSkRl6$?GMM7C4$s>dYAkXu$87{nyhr^DfU)`9Hv%S zLiQzc!BfOmL4kT@3GH|V${r0JjX~<(C1HJy!v3V?kgU;XW5jCiB!!ru%1X4c#EL2j zspj*|XwMU7IvnxhU2o#>F;8jOb%tJ!GgRSo*r&D^%>ZO9B|ySRg?O!6u2q$vS^&ys z{B>fa#4}A_dD=FLJpJE{%Sng&Ck39b?XtS<-HuJl5cF}3Re*R16$7qTXxTpe=@|=c=Ia@&`RfyxZ+hi4~ z;T+ZAshYrtz9QsJ3PpC=n*Vmh`&(X3)OON@M8tF0#Cc+ z0f+3aEu4`U`r)3?aolB~1M`KjVH?J@%kuUV^zZyB1fA)#5HfT(gc$$i5F(23`q3%7 zA;s9-oi=PY#2ANXGWitg@$;9y_>r52Cy*Wl)r1)Nvl{?Mh*NCv@~4{X6|6798$8Zd zIW>DrCB4zKlHT*sRl*|4&=qaeh4tjgLm1Vl$P^Hp&qHXcmZQ#x zd@G`nMlk{wibyHq(;j)~4rKOFZ%RaprFo)I_Mgn=d~D@0Zusc&cOo4K>C3Rx*k`iA z4i$X#ZnV9S{8upMRY+)gIN8*tj+!w4uSDzX&R)&-k>B8B8{;Uyee~sq^tI)M9r47! zx@(^(qEGB*yx)*~U;9VwW@Lmt{p*?AxK!h#zeKH#d6{|b`(abzW=6l{t2!)yEg@-B zcP*hTn;3Vk;&;!R7`8PO_vd+QP4=;&;l7X7i+!iF`G`H5{zLoOC))o{>P5GC#ZjuxxQ+KJX+YA{ihLhfYe)%cM7yTs^zao;W=@a2xWA=l$ z4Zf;;wOf+cZ7I!%(F@+|cLUUqPj?T0Oi?$R_QW4O%Ghi1F&iM-yC7Qa$=0Xt65PSF zb0hHUQU^`IXk4uDZQp=p%=)jLzk@=SsZUQX^gFH*$GqO4{kgZqF`J?t*B*|s{lDE= zMy*5Ybqf#5_P3Cxep#%0_9`_+>Z%Fi!z~1lHSJM+G3^)Z6-*rhPbIac$lGpZW3cyj ztNEF@S6Rl2kv{G2_+N^AY;!PNnj@@`urwB1>RZu>ZO#TQ2bR`aN``S(}v__Oa0nlT7i zenbdT&!xa4JV?Dr*nm*`BX@5_p%3d8vRjBN08!h1@F(EtF+7<@lUt8eE@#bRfcK#J(Kik7 z-O=nGACwQhjdA95-vz^OWe7Vw71=KVU^DRR@o_v)%dS`q~3bk1`S)q-6aIw2Z)noVN9 z59Juw-QH~h*$^x37aIZ=C^M41s&w&(=Tg<+B~+ELjr{QZrmA`vIrL1Kwt6zE6r^o+ zr~g4*sYRzGP0o>w?Q=fDC#YK4l~>|F4sJi?e2)CL%Wzom{@X91(iyGHeSZ?-O^gH0 zNp{Yux-)YuulV9Hu2Q`oi?!E^H|Qt^1V!q|LE&4qeQoTSBbjfm0h`lj=EGz zYwud(8Vo`{#OB>*W!ud0w+`Ys29346h6-X!7cV0XCr`Hxr86CT+)6C3g$Dy;1AZI0 zgsPc%b!W>!q^lLl9vnSI`{VKI)=nyk%^!fgP?>4!7xseL_Ul1ae+IF8-!h;+mDou3 z#Q4t(_LgSi2X{6Ptxfn_3~sx;wsqNoQU_ZI-eYRYwxIe?&9$oFgdlNq6Q^o|)Qs6$ zzA<_Hrj@K?J2N*?gwNB(EySfd^H&O(P=EmOA>GRTeH)v{ zQ+*U(<&q%Hw&znGX&>8tksFDCxE0+LHVM~974E5)DXH}Z_#s`m(fLr)?&%rG`T~w(CAe8k_wesDq zQFrG)BMOpMvwnqr{m>jun$WBeHM1rI^XN<*gun<8I&+OC@tTsK5my z`xf3nxL4FYQxl|4rdOul!D_dv{I-@igLIRGYxbo+`FgUvqb%9YFw8N@4LSXJU@Rf| zl?x!$R$e9A&;c*5g+9xS?4??;nLmB1u9Pmcl~e<^|G=lZk8Ibg%^$~v^9O=Q zx{N-}IO?mJ=0R@1`=G_=jGI0W^yj zx8Evy0Jrz@9?LmenV;2A6h!U`qJ3AS+1m^1$aQQzP9zxe*14p` zQ(vx(Ctv2&i1>^93m0C)*LtdJC8sWof5U!#wF;*oktf+iG=n+iXKL7*)Ov?y>#R@y zzCO9WKKX8a@^4!1$01{x9#jkQEvUc0AWA*x!Nki_5#m{d*!+64(!j@*oZYzVEl&Cl zT^z=2VEYQke*wTyHEEf1rYK{!JFHXj17sf_RiFA=DQ7qAjA$&;4&$7*y6(`jemY#z zJMC*xT7P|Sz(27*c@@9c?1Ov0g>G1QJXsp5-;T{YKo9AM{i%2+kMmREZgXtZhI4B=VPkzJU?t z3KO+@Y5Bk$*b5)fyjA^rY~cbuq#rEzCq#D9@LLV(QR5oYlgs31Jf%MQ9&K_s91m8t zS@e0DjCbj*0Zkqdoiq3|=RH1ucDnp?YS6kV$70!oviqxfZi^%G^K((3L^^j~jbyG* z3AAg=2gXw~N*Yq9mo}s(jsVOMJ)4;)8>-*uK#m^LKM%n){4}KY&!I(x&OGM1ka!!5El>1L;MYX6;hVKvIL0S=r$vlCDbNG1DSnT zXI{vq0Fs#0bqvJN-jKcs>)#y0A9VeFfRY*;k~^bPN@$EHx;dB6FZRxx84&4bqUl(=p0y~E46MwC%p=rb*SuylKOU~rDj6RdbF|2B8^nH`tXpftG6BDEF8Jj=d%KSpd*-Ln+{7u|B7$JYg z;3d~&;s`rmjCXrA4?GSvX$CuU4{sA z(Zml%nIVW8gD&2Yftn3`d3@S1c!(i_WK${XR#jsB z{f$zkIT3${Rhk{@2H5Vof92q6JV^*WKv_cNL9&EU9~C^I2iH^ruWBmOOzx*cj)THA zOYHjx+;}ElVz#oQDn8sY7L_p0a{7t#PGwBrwk~fKQw@b^731L_H>|sxokl#)2N9Bl z>p)Zh98c3l3A~Hbf?P$-)D_eoNQ_cpRbaN2)cW+?~R^AC_9B& zwt(6CRwk|@{gs>6;QJG5oT7%XOQ)F!g`PE~hkvtC zswHfsbF(ehm;I{K{;=gbF%0L$p0;6|kla|G#CJ*9L;w6Jmi~(#aP|%)=_T#7*@F#}-V7 zA~i4-QE03nIcjx%Iw&MCR#=*&K*Z>|^_+Ne4WxZ(`JwS7K9V11#%QrbU#eW)MuDuI zFR!~wAcWgwq6~o|NsKsFXRMCwMfF%;3^nR!jU;+mkhVH>E7ba9Rk`1?6Cl1jxaQ~- zmg=Z4KLq_6$N%J?CZKbxX4_fkC_$|4PWXnv**Mn z#MITncwOK<<63`Mt!)B}gg1(mskor7{qk}`pa1KC7H${cHBh&U@7lk4F!<#m7MowM z83IffbHNgtXZ4y}2hZfJ^VbT`PL6sm-rdEQ*nb^Krp$r-p__`c^Cmtc%k9qaS9x+9 z_|qYj`Q?vIbhcC4Gts$yw`*v27Y3pmKfPtL`KM>X_2+dVZGE!T8-4JQJ<}?7v;pP3lJloPQ|vTTiwF6OYvqba#WcTAua$D&)!AtBrrOCAU+nO|PhW));jQ_e)(^ zM0Ai@^&FtPB%Zo!or-e#!AU%K^6bwymUX1=)|4Ct9PZyTz;=ML!4AQx_0X|Ey?HRG>1JmEDEiCr0Ym=Su)r91FH%34tKgZv_{+Q4JPgT~XJ5NBLcu+q5u$1`pVPjw>3rxvvdo*>UKxPJ;A63^xw&6KrOF8 zRqg|yvtk$K_oGPk^UJvV@_N%lH_=nX`N>sBSP=W|{bwDT*k0J;?>pdp$s`Qq&4=j5 z)vtM+pPAUc*Q^rUj+%#NzuuA9PNZr>clNl%_Ptxaz-p}J(AZMW25&!R#$jwq+;qz- zOwEG|+13p+7B54y&=8bj-&%f*I`w~Y_DC0RyPQE7rw?tM=@Ea@SPN#w;O6>&D(o8~{Is&33r$ZeiKnXKsiqQlfI5({SUM@7%C3!uSNI|R)~P-E zPmQ3mKGMB8bZYL$rl1u+>GeG`{xMtV1kKrOnlf2;xRa6h!boF~`ljM1gUCr*GGK0Z zul>RYDBTB}-1fA*3e<)8MJr zJ%seMVZsnVoTat3#5J4HK8VPiEUYsM@lYqM>?Gh{7#U^8rdp-j?eJlA&-B>?dtz>E z5gMzx@M66l()acR-1`uV+7|)>?n#$mRoTg;hy|%jZPv9Dzf-Y9eT;}(hDEFMKNFIV z$et$>KVhczl9oP}k!;pgLHbUsoC#IIXLb;c<^yt8ld}w6F^JWp^FgiH|NhZ@s0IoN ze?D|5{bjxTv3U&Z-4x?OB60#(W00I(!f~>S`MFK5C~U+9`)m2U)ivnR)YlgTg6_^ZtPddqPB#=Gk*8`kI$McEz4g+xp)3XjvUaL zS)ajwUk>>X-pj?O@PR@(@P%-??O>tP`+M=kyE9G+mj}Vx)vlhq*1l zk9_@Zj#c;g;MXsw!T=!*u&#+BT}9sgB#wDlLfnNvlk~Z$RLd~B@*iIE-_&3zRb(Yz?AHtLLu z3ED=DG&vaQji@EPN808_xKOcDZeoR;i#qvNqH}7q#*pCcCw%er>$bihj(Q*e;F%Ni z#<$E1Y%b!`1EB;N-^V}C(4BCr##a(vW9tt86>&$D_<$0BJ2yA318F7uP&AlE-($o2 zN2tT>?`&=!F7e9qauKV0Tw5av9aTlP+HViTxi3UeTf5m`Mm76iPakusC2Rw*Z7p5O z%C2P}^Aq6uwr=iuCT>J>lNm3#W@odTr$I+uOs;dY9-{sKaBHT@UHyzfYrX-Yhs?=1 zq2vh(w}27LIGfsg zH}=Qc#2;wvnExM*b@T++HvW$KJ2`6mOg;2!yCF5I{QtS#9AaNX)>$W4>!D9WmzERU z_x}-{`5i3CH5)|D$`>}C?uh1oFAT%EUj~Wf3wYFN@_$|eNE@gz3CO)!>)p3PA7IN^ z?;uZds(|##5j{Hs=r5D^yl)>#VUzDudgMELN@`MtJEAyRf9*PbhpEn`v8C~$+q(Lp z%_VjfPCqp0X5cpEEQ^JN9t=glO#rr#9lI9&DhI!-j6lsMqvpf)kDT&C7-%P;ox;ZCF()Ym}R*ZG-XHG7mT$* z75d4(mV%8vsI)7;a84K>)-3$C?ikv9Nb8ORTL?=~!~I|Ct=WFUXdb2LT}t@pX;DJz zKsNx{?6%~-*ktF7@h3;D6Nn1@aplYC>>p!Y#g04w zw;%$0aTw7Ro-rHZ_+`|>#-B8|F4v#MqQYwJg@LcXIgOx; z-qV4f|U?LlfbH>hCC z)gCl=5f4TFY+F^@e36h4@L_mj%b^{uJBPI3do{bJkh=&W&Fq@iod?F|zhJ{@D}Vez zQcX2x*YC)lu0S)3Ge1=_H=b*p8`HeC4z0OjQa06)d^(=okxhgkq>E4J!fGT>S9jukF-Eh9&bA2F zxgS`qB3<~X>u>!vRp8L@ti>!lD?Ny#71pF0N`4$vH`UB~GW#PG-Vc6HrKMDA@^y0? ztB8=w(2GsJx&?0vJG~Z#nG#%7mS%dB& zTQdW6mo`wbA6BoM{!Wm3)V4>fx6XJinELx5T{JMV4|6|9Y~Fcf1t+Ql)K+wu-oEPN z^=3btF17yPXLzG;fBoJS1>kautNY=O?shgVf>epRRO8FsNiMgx1>-mB=|WkMYPSt!Km!+c8J4FzkjT6_6xRL60S0=Mf#-&&Qs(YG{j zI!Rh~c=@zBOs{n3lJ4#}jz2$9CA3I0tsdo_E$v`ua0%wQ<5cV0^MDD0MPX>B)dPI1 zKYy934FU71l?n_2J5Df=`u~>1eN}i`1d{ZF%|7*_N>Wjy3*1=|Kpwu8q`PgP!wvC` zoHrj!;OHFulYzw3A4F5?2L0J1s|2=S0bY<<{Mq)0*n&CGRVZIXfBO>Z&TbU?)0R&l zz)?N)HCF>M>#d-Au4r)PYj!u7=odP@ShNEc@2V2vri=Ie&J_jnJbB6e<$F>KfSk>^ zW5w6XrJ8^ntZ}_+(FqW|Cu>6Jo<&kP{(T8~$1aF+5rL~A&tMJZ z6Y*N*FPfqJA}Rp*s=MGQ8>4@1hz9T(&>jt7)mTg1d=`mD!9UTMky=6hBYoog&ypyi z;BMD|UE%Bd?wjCmP7mFV_(ZyWd5pC&>MK-ZbbET(MwMG$X-UuBK$7UzRfI{EqMya2 zx>t_o&j+dksA$Bf*62swn-4}>izCuKsx?QtNJ2N+H{37R^XKSL*mKoC&bL0{*R*cb z`!jWz3{~O$?$hr(mUN@v+rxCAs{`0w1jcnI3%+xGOTU@di+&elgDGzppHmW67BAT@I35|RkAM)rSq>|&R}~rqeq5@_k&b>`h6#&-#><0UTpsV zfNOYak_1axDF1dqI%BRgQoEaH>R$PPk=i7;-*-gOMrg#el4WFyaxZT3gobZrXUkRY z{UdEKf2f;IO;St-e_(TxMCFSJAIeP+NED&v@K1&^_oz>u_d8Pk^dtO^)c9}nwI2Ux z#O3W23_F`#!~RJ(@jpWq%V;AfI4ko6XNCK+uVV2f)NTa0ih%pU|z`3x*Jsk1$Lvq1@!5-{t^BC?3P{wKKZr00nZ%Ucarqu%NdbqdikG_acB zz-__kkH~sx?Y7R=md>-%r|x@J`b3oenf;7@x2@`Dt!&7CfwMG2sf9rwRLSt3&+WDH ze|@fbKx$AWa&9Q1Yp6S#oe;OzDW>hqe>q4`c(m|A!RlI+;)pcb4)$LOJ@%$3<-=+|M zne}~fCnnMPi&j|3o0uMBS!R4P_x{{{F1`^-2gS?0&eRVg%4@a-%3xx*TB zFI_AMhCTB#T*YqbU}ypW4fgZqu9% z(kxagkCnIb%wEL^*6ivr8W6VIfS48(e=0f48HU&`ja}iK|kC}L;NH? zRd1Sct~${{SqzYoN7diIbp`XsVtpHYIQbIepBRHL0@tCOv`yYs=%~YXZCTHg-J-IU zM_Dkj>-mZfeupoK@e5U`h3ND+AZ16p1EaFduWdJ1IDHRNPYUvQ@@7=ly4SV`$pv~R zR)e~%K~tB>WxWC$_~K?1<3+96@`L$xws!tIEuY7}Et}{gD{IZ-qu{h+FtiVfOQ2Lm0oAIl)I}4((Ws1NU74LpS3s zuP@=#efWR?v8A-U9CcnV*;twwzx+szChm>Cj_hz(LG{sVJjq>6xZ}&iu{85vhA28C z)srPFW&AMOh%<;m_4Zi0+H#R4HFO?2Y@GtQ^}knG6rhg)jJA20zw*KR{JkDeQCHY@ zmF~;ohwN>_vaG#CUFJy@h`9Ad{eadUFxo=@yT>NWI#*0*+aT4~Kc~*Y?B2GP`4XlN z7yQHbPZjj^FLO9)>RDshvxlsHKnSY0-m*ZmbYnos_NZwSQyp~59+pH8k3$s()^6xXB_6H6d<{!KPfnA}k=clU*g zP#bHzOy5H=WF*iMHL?^oR>@M> z*eFY3V^bDOAzxq^{<7W8cMf)8DM6YDtk}|9ht_O+R*iILFXU}_;@v~BE&bi-$E-?N zCI|n@yX#mG%P4t_?a)(DNAhQ>R}m++f9FhZ!U&nGMM z$;u37Yl7T?{_K_2^)IFk(!_YjTuTeHP}<=w|9% zuXU)Y`ob!Lb992fJ{3y-uatd1${u^X@q{a@FFYYOKS{@UtBgHsw-yJNtubV;R(4K#ktUM&;C!7?^T zeOZG=IQNL5Q`5oW6P}r?XVtU}l31V3Y(I@*&TBdEu`eFoOg0IK{wyS$H=rM!)2ecV zle&cGa1`S@aS~!2{kYGVxTErtcTXMEJN0ZRGN@^}PPMp>qdyHT)0G-Z2YE>LNQT+x z8A>3lP{yS$fh#0oLL#PHx8`*}@3A*Q=Oyga|$gjm*${9>CB1+Ivi|#6I*lB;*17=}}!^ zuN=ok<6ONpmi|fp_{yY#yBlnCP7PbWoi^zA*f^l*NMJmo9w9*9FjSsn!@W_@=|SuU z++k-4YEz>+WkUa!LMY|tOLJsfWJkhMqi}uqXB=Epm}#9==qFbOz?FFX%P) z9r8$tW{14T-oxxpW;?`_X3)WB=`ULFjZtZ*5Y{mf<|<`&eL(_>3#o4(OJ;Q!<8UErfE zuKw}OWnn?$1|b>+bkS%N#Tr!FL`dCW&}VTY!7B)Dqaa4S1(HA%lnt9emdDk_yVAZd zw$)m%cqwveH31C)TMeKHVk_cp;%X7}g#b$a-|v~{*-H{o`}=(U_%ZuDGtZnkbLPyM zGiT16kvR5I=jsAf=YFL&Kjnb?l}(tV(u~6Q+zYXP>@e~U=q-4o`Ey(f$E$S@_;In^ zD|en<_qhcb^A>!Wabk1~rnU>MDR6}Wn24xI&?W9yF3c}US?7MG(@1IYVTG~qk4X0C zt@DKr82di-VHeS8?u1*_IwR$foLb=dgxkr1IHT{XiG{`zjY?fJxEy z>$PbA5|-T7L(Mvg_PbeUTIHd?4msa9)3H(rS@+NHXze`ktTgB{Af%p~Y7Ynlm#Nt!xQ0LU?I^_RgL{ioL#u{CcEyL*P_1J zzlPa1J5}o!-auzyrXPP_n|&csNE;QHSv2ak*@eN+dN+S|j8xsP&z9il=Qn@etIr{6 zIO>Hbr!J4$JKc`iSeH#q*EQoQWySZM!ou{+zT>5ac`pz)~lm(UwpGEH%_ktZDPiTL0XRqMfP53VO(fM$sZZuL> zU?syez%#s|u$);#Vr=VrT%v|3m6QTof2VDVgiez53Q17V%2#zhBZ9`(%* z%NSJ#2NIZH&9ZX*LUxx`;1?%Y``5~!a?ZlolsHNV9Knu+kz%}xUh3>TA1#BqImmd0 zbV6zVDBW-NbIWacAA?qy^xQ7LIneD-GZ0?kK(Be%AZjGelQPUu3`DsFqFgS}=KO=tv4FnS-7pYkgGK$UA`P)36;_do z_C2(F1#3OnZdgKr6s*n06~OiP@EOM3J`{iTbvmcQQFCgr=+$G`(thwpDOUpkkv7$J z-g1yCCZD9xpO9eoHLp$&O_*R_jjlJaYceQ2D?PN=cnx^rAL_`%g-Eq!P)KluHU8$NwfiIPqEO zrS(fP5+OLGp|fUdyCxm%L~6N3k3b0 zXe*nr1x+|7STx;&_wm0h{L6qdw-b!q76fY-(WC!{+Nl2w+G!1Is7G!*i&)&PNshzRcLa=$V@ zb=tl)DUO;NbG)nYvP>-Rp*7{3Me zN2R!e;3@&FHc&em8$Y;E^Y;C3Lo#H|!B6{H7#&EuUME%HCkj_C9<1~Qn>{#Oi$k_| z-U^Z$^uCCq{S7!C3QZOpAGd+%YpCXK9=>Vc?ogYaUvQ?`z2J3xK)u``3gy`B8Ra)8 zc}vZqatEf*^r3+;{uP@u2EsN}P-+%ubEm9qj5#uh<+cDX9s+TZ6)N}l^9(tQa4&;I&?z`_q14$K9gIW?>LTY>+qlVBS zRmeNZ%XXC%PMR=#MFLf-b4K+*k=rsst~f=ap6)2N-zv<)UMlXyRi8KJmzZ-Vpv@(D z9f-g7hI_$$(%-xh^t-9SF($MNUh65LuY;{A(;_8>s^*Fk)NwA!HH>sjBv(Y!YmpG$ zt{Rjd1s0#iGzG?3>3va&+ z7h4(MT(GpC25F^rB0av(2jQ&oU1|F#(loJD=spv(<(=8}y^BN5Byb+ufPenx7`t3EI;-)Xtahe<^RHS~FTI05g^qN*29O(4Anvh3I1HSr7vhDRtK-O-K4=HBf~5;# zntwCMATEx5wPwU7h3f(+^~@IJN=X&a_+^G z#Xj<>+V%?e)~dVUWuvJ1`<9sK{<2nFdwvffdVN30N8h5NIY>Yh$Wt*8j44?=)83(+ zo`*z;?vCTuAj(v~zPRwc)3@*a(xDrC?&op8+K}I-!*@G85I5po3Y*wgt^|i}rogJ- zM>z1~#wD_QL~4D81ah>nD#qAWxI^sQO}?!#GfqN1X3-G*9o{6WCblEgAJ*IEIdENt z;eLJtwX7LruQDLKW*ZQm7O4U0X*z+gtn(U1;yL4X)V$95B(r7o%8qo_pYR?mIi|` zHVfMk8N;Q#zZp}MT(+2%iv%fs7E51>(gbf<02p(n4f~5*Ntlf9wr<2V?}=SSTO)}g1YF$D6g$amsh&+qQ~ z$JvYQ;|MzW)AvBhiVI1}jE#5(6RzP8Etbw@l0e4;^In3m_K&Kte*|Rh7WZX~KdqG( z-;EN%qT_n&7Dup2EiKNNhIC)(VhA+nBnzn52o1T4&!Nk=c1W*I#2frGW&DV5a?tir zcBwHh13u{DY9Dl%foTm;5v90u&mON`fA#pqn$o6EZbZ&U-~hw=&W#QP{e7XYjyZlN z+0LVGJV{%jVXSGb?l1nSgKc?@BY(ob@n7s;fwb8w%Mtf|TWS#;;?WEL$4;>#<@JJ9 z@C4+j=`QP2EkCyRhUsuiicZT^cRBIeI~9LUCdjb!+0Ws1cN`1OfENLfx915p^d*Z% zGA*(7U#)GrrdCDEDjOs$4$6Yu{9*`xKvSknvtOE7zx^xYa=0|BB8}DG?9TJj_H2sBdCI< z3#5@;M4;$>rTaj7`k9Rnqqp75<#KkM))+SP=v4#AQsEKiiWv?# zv`XaIA@h&r@I4pqKbH@{K%-!U#*ojkn#lz%l^HXzlqHerQ8T|6M*MXu_z7);eG{z4 z{_v>d(uCDcycAh|nAKus<-&ddUIf#;vw5ClHL!&J+sc#0Ql?tM*Rb=P-YA>S{6$Dm z*ReA8HMDMcC#a*{3Htv6!gSyo(@Okt^^){2k&YBbpMbd91!5xcy z^@7g*WW0r?HUBbyuLTd)1u!3oCV-9TK)l9kyGGTQ6~2Mj=qZFhNkdJs>r@-kk^eYS zHT;oyQnL=>&tiUQbu|W|dJN&lwT$}Z;q@;Wez}W$JxtcGM=fih``&S9~A4;jIx4GY4KMV54zV@{J z2D}J}bb|P^fI!uz44d%P0P%=`IB>WD)yT_0t)QGUTlOrfdMkN`5&V8; z%hz@3InWdxYTCzL54~x@c?%&V0Z2IijfUt>w$6Wt^+ut(Z6o*&&f|Ts5!r}ue!aG? zHgn384@GL=p_H|{qnt*LnxFek=wq02p_oIR8?tT;_Axy89A^YO4pchisx1{p>`Rqf zrrD*IOSJ$$0YlZQ;n1Y*5=(~7aJ&k8HD>W9Xek6*0H8AgRQU+wlW|&pswK}rd;SGz zmDH@*OSk^p{2=&06Oh$o1feFO{E_;P`$s3*^d)~okhHP*=tVLdIUgNI81KgFOnktF z#OoI}&IKd)%mRX6tpy(^qrd@qcY%dVisVXa=dkc*46SCKQ`KY195PgrU`iUk9{h3e zCf=S*(-S`7umPF&-L;vTMKcuptZ%GmJ)!>71nfqPL$DOI2$Y}nH0Z~%l!$fwS@845 z_!EO1>l&Ww4`+Q;hWLx@`lGQNP?uc?JcLhS(|`}vl-sVQ{;0P9j156K%n@8YvK3rE zdDKTw>7GwmR?>gh6E)-2Tjy)<2Ei>HFu~x|Ohl!1V{tPb0WP`A6?Xn-5p)PHqG1g0 zR1>D_+chwo{Bvj5fng4YeO>m(*3N?;DB6e77nJKa^RUXys5-n;tTVs+UXtARSsr9Ix0udj_HI55 z?~qK=Kcg+$P`=-IJR*k6M0w5I`(Y73a1dHCmIGC-wsJi2@tAUa2_DfN?DnY3U=fbK zkU)9;DDcmS!58|P&SO!I?qOc6uRr86Ps|K`J2ysmN>?iQ z0d!2H8t1m_TKhwuyof~tS1;@2m6WiD6CkOV|7@YzK0RryO8<V-H|DRWXD1b z_JajP6mv7Q-e8j#(qSW$bB@O%kJ4r}-)4;xiGTwv>P?{A<^I1}gDm(E?oN~6FW_1@ z2wgm~R-FLMqFcL=E%qw-+5HEaQ~Po?Kym`5Y@p;cjzQb^KB0wJc3@=%-f_!>?yYdv zmwO<}+|8*ib&?^K>i$!Y0aMLmkH)I&_8|2iMf}zH`h%Tl;B+=n*&iC~(#UsMeV+FX zMxdGT^dB}lq8RCmy-3Fiz;gazL639yh--a;E15n2f%2Sjq3h*x#d=lK9>aZl(;jzb z#@G$>9DCfqY2M@R->sBg`#%!O%ZfLleBYl~zMxC}8`l4{`n_GsFZzk)jV|TK{>1VX zUCQ_UiRH_>l;6<$)7n3wOZi1Vv3z-#@?(Eu`Pwe!`~Jl8m0ikjSob5_ulc_*8|95N z8a@1h>BQpm*!T$OjIOL4&zJJu21qosvi3C`@e5r?+?b!l9@LJ+3zyq@RR z=S(_)S@!;KA?7oW#i19G`s8A8Lf0)dtog(r%n9@zY%LDgvO`#FC}W6 z4!M2MK0Rr%8t0E?SiN@_u<`t+9`kkoQorunznh+l_wQTstowI^JpXY2p1ec)cgaNd z@5`8m68iVF*Z#}?y@_zpzn?Z#oAsdrDK+FXH7F9jQF#|0j=(pSPeZXrX`w z-*i@CAvM2?H(i`$W=5UuOj|_@D1@?xFd1KFnk; z;|wDk|9kL%F8+szx!4uyqV8C|7XOLSC$RJf+Mn62Z3*~6r}i85MMqjkmvXt1iFeaOHKzVatPNX`oqJqeJ-6Mj&2)n*cs+`GD)l z{2S;va(VP0ytYuk)RU&0lcuSX)+mK7+|n9#Rf3|8-xTLlpL3ymSp1v^)Mkg7@lNU{ zhne-Ov`vn@w!BtMo#qoX183cZANXivh8VTmd~GSLxVY2@{sjo8HaFVPB!)isCC%MN zSU3K@5unwAjGp*=*`wY0yIc8-T_}HHkL4?WO!+|>DBr8c^7%iee6&BxxAf}?|F7lH zu00Xz@!1Xk)ihu(=&}5=9?GNtxc-P>0psgUqesS~LHx=3_yP1wN-LK#izv#mr>2)O zt#BZy`66+pvh?qV*A$7Ld%@WNV9l?FVMefI=8By^{D&Ps8oeFWCm>Otm}pia80>;d z%*^~pF*QN<@d8CxeYP=Se@1P?-Z!TqOt4{NJm zs0lR=--JbTXguzOyd)pbMrbipWg)!?yG|;c$89a*08OzjMj*r$KrZpa={7iBFJcZt zyM;CYM8;C)g*M}H$nWvk>HJ^(6_~%kgW5LiKxd%n?6}Ph{(-=p~ zD5&O@-49KX-Z&0GWef2!NWW{DkB{JJ0&CdV`I_7X=8Hn4hP|_n!p$h5MSKH^1O&}p zi-bgr#0WnFh88i$)7|wL+X!FnvJLPW1NOE0!Y>AE!#1cNfGak$UG2+aUOVymL-SWQ zN?QDdX;QXrG?QU730xH8v_R3IPi!)*k7m*Swq&MmPQJxGR9>lBLp|2}6A1Q7_UQ-Q zWD8m41vC#Ck(R&;q@JjG3F6hE{>d{GHZPTtWVseE{TN32A#>DW8Oh=!k||#s@BYMV z2@*DYUVgx);)W!JO613B7VTW{X+?aq{^~-U;f4%2?ymPL3`iK75`rQkf z!CMv$avAIaf?%c*ydD0>)m1!i?%mtssfJA*ZsRM5K5^yr$8M={7{g)mZ-W!CB9j`c zUYl~y>Kk`mio2hm$DM1m-b2Lp_uuW=x!Xw@Ax{gjoPxAaodi5Fj>xx0^vn=+h zl;zsECSF{_`%^pt;sy>;2v>-eyO&oML2_3@n#uZ#p$jkL#=4gxt$;Hq#8Rql=*4WT zBckW4d;imcQ)kt%K|t6?5fDZW#L^fL9*m6!5vsiThwJa?BDzs)Qpx$}d~nqsoONLA zepHdGN=Onx1aL59WoE`<+%oU%f5ysE{?0+@^R9g4dK-L{djBErUk*Y@2+c{0Yr#qW zvywQ8jmlQy=6K=`_?(Ux@&XEMG1!3Y@`0imQv9@dakd?^)|)Cj4uUBHhk?PjViu-% zP*XBU8?^jd@UsI&{RKWQxw1v9wLX`QWE$Y2I$C6Y_PKB<%>8!zP=4b_Y+kqWyy=nc zODwFG> z<_qlK4gwpfk0_MX66_5gVgJ^m5Ad7*1*EXM{soFWI4#saB(jf+5s~$o7lJtK#?FA3 z0>TV%UNqL>E7bMwxlBTKOMtpcN@u{3kEA&E9g&3r3Jz9pLbXeZbBnA@rqfKRGunDvlmIsTz`2@Y|uBRcClEJXg*NJoIP^98;?bzeSgf z;U7Gn;BNR9^>TtOE8e@tQ-eb%eUi$*&1{Mdi=|uDsW0;Mb%{Qozf4NQ6e@LC74)B7 zLHP{$DK!@pB{=WYcf(ysfk!JYhC#RUt7nkjXl?lsnX_ zJX<2Gadur@?oSwC!FQ>z-V{1RQVO?IzQ@YE(`D$&tLT66^3QfFzkQL_zG#o-v4Cl+ zK3R@!RcDzQk3+~|{}$@N^W2?;q;%_bIy7qEVSF+)nMc3EmIje>G%D4Db27wn#6l`taTLG}Ks`AB z_5p?XF{tn*ByxV{{x;8vt#ke!Df}m8>LuF?{7%$pfU9GZ4-^q_jCF#;16BtL;Nvp1 zepm?ZBE92V(7OFI;`$vm1jd9QUZ&1L5%P+jpQVkp{Cdd{ z-9Aq{;@WB1hX~%#vvB?qaRGu&9{78NGtNC1;l+2sZ;VmFTHXg05r_s90d#0wh+keM z8}LYwLwDHG!I?E?;Q^zv5(n^j@Qz1?LM|M-bFK4clGu7Rx1|%vp|A7Rm*4N#`|jJ{ z*)08YaInTNA9TxxN=jl+z+GKOTNGNW1qhgAF@c~4NLjgv$60>$jo9CZGf%K+pkVw< zVhphlTcDsGfOHHf=Oq|RyxW`<1jtw=2hq5Y+hAn z^hu1d0>q7f`*FC3KlMpRG8)?^0*z`xBfO1-JLkuvamO3b2@8nAH;=P-4vWGw7&d42 zhwI%*AgcN-CbLM3Oz=>)x_1Eq*n*N|#2I!+`;Umlj@rr|z@{a7J9;eS^PE3v zx}qmBZ)?5iT?zIje4AZ{o59j z6Kg6|74@iF1W)Xu_7yytiU$m`tAY3=3@t1ra4}Vo7fca(ti7D8uEg-T0`7bS0w3~V z(e(n9qmuVC)mkHR<{AuzGfxJ0Kluj{*-@MTw);nr6O}+c73@X?F?$^8{@tI{ew?pj zhw1i1geJCMF#Cz^zk=HEo7w)MZ2x0NZ2$b9(tdQn@w4j=Z{O1V!DCY~ z{@~)EHxhIQg4yMYtbmrW)u*Yyz@rL>TfmF>C-W0%B%&vuQpd|l3D<(3`4*BR)dSVU z^DGG;&ozoVaF%!WXlaAS7 z^jCjA13w6{PyJ%a2+IGaf1Q zQ9TX#v6-SD7N~nHUooy>$-(+>*tzc?*cys4HO8kUb18oY)g^X^h~4%-i)tFz|Kk45 zuziKrie$hvukABj9L7hxdNW|bOV}SdQu&cx%9}s2{6W|m66?RXhw?Km-T++=rc`5= z)iNIk=5|(&HdcYq_?JRA=-KC>3+DbDt9of9&gGm)~_>FDNPAtfQZWuRhtAL+5cPQd%S!`Pvr}KsJv}|&cs=I z_o|OlX7=LY$S7tZM8&(hQB>|Ew@dZuor!IVt~{&+7yRP)w}qWgAG#U)b7WNTEzgIZ zNl3D~!R0abJgn+bL3E9!|L4WW_IBwl!|i|Hc+KuN^`1*mw1l?iZ;`m@zmZ9p>WSc~ zIJ$!0;23|1*#>(#D*ZSC*~29E#T|)F*8qQ@{kDGML9`F(iLe`2=Wu5y))uUO;;rcu zZ%x?Qw#q)P@S-P~t*%YNBl=*xO^Hv^zS#Iv&;Azc`sJG;Rjj(lw9!Z%AHNB+bxKkN zx}nPwVe?tw+xM$tZif6+#^r~pquZf4l}A zglR4pc7X!w#NZ(>*B)abgL`a{uIr4$)%8Hvrpdds?^iMYWBaUmr5dXu$j^faUTWz_ zF+9qM2Le!Z6S{FVfF@xWAR+(f^xSsJeC+?V&-r2fD1N_DL}E#AB?DhD@Nf*A*S*H* ziXIzp_pcov%kJN+1@z&1bN%f-wv?Zhgi=SZmXUUD7pzVse{+&Km*3ijQbO1 z#R!E#SYP&HKz_N*XsDcGV!p5@wF;SeV)+CIl6A3N+bCHE*E-T0Qt_C!{6AK4Rf2c+Ad=h}sv`dV2 z5AODJ=WUCch`kmo6Wow6`-s4iflm7mLQ8P_=IPnp=p?dE#yi6?NJx`{_9=SY3x4tW z{aNawUAcEc638R!2RHXrKKlseWBi}M=-Aq5gRKXbDs0F6%EL%RThwOdUurY8rgDt3 zGT%4?$W6iZ(qEjwTO^_X;=)}-I&;iq1noR{@4h|(d(|)x4&1`=mBlOGnpIz14^FBL z#PaNG*a~rz17aN1WB!kL7tNf4fOIJ}ZUj5c_7^tI>}3>=uAF@#5>u?>dNq8W($JLiA|p zhxf7P@j`c7&4iG>=8%!P!nsKms+$qzm0x2d!#we73t?gP5A#JdOXXXj^2KvkOnw-x zW%^WmRa-NTM8SU0w~q|x0+AQtAw%x6;yH4Z8XTo%>hoFHVn6w~Bz=rz%U1uaBDRzQ z5Kgcw(89s%EbQ*?_ABFC^xI&Oo9N=GSL3~0KVy}iG40maQLjmOv@9y>db<|z#}Ay( z68N`SeGAdW`7!Kl*;fT>r{_RFUOl7BeiyPAK3w5Y*TQWH9W$~OKQK6jGaivb2Ks2) z8$gtF#f%!wP%9R*(Rikb3Put2`Ay>dV$ZSam6;Y*+BttE(I82_xzs=ZET<3?_9y1p zWqaOV(ELl60IQAJY-29BnBfNVI!XZ?Jiuu1a5Ut;2F2W=Zu}m|TJy3! zTdD^u6NgQ7QJh6||2Ctfg#%z^twZZk^Q%aOJB`1E)4|;j;l*dp!t}YIvKJm#o;CIF zwNr=8T3VXY>RYuv_vNJ`;jP9a#y&*7dXUwTKX7#SGIUR?s399)gJBo@+jBqb^!>fj2I&Opf4hDU>lY@FS;7mUFgKg^lgUvbvQV7*Q5dyo z`_{o@rT(P$%V+AbTM~&NHAiFn;x-5TQ2iea{(<@@4LV%?Lw{`j?gb2xVD$lrCk&l6 zdOE#6w;-}8j$mlt+|G4mgWZV0J=cjd$I+ABzsGW;1LTJ&^kb*NTwcyqVJEKaYVwEH zqkrHZRDB6;0kcXGn$qP#MflC+uRmPeSsH3aj3Hlh$N9y<9ohcygS9B{OKE~$^BN=o z?0-+HiP$VJ4I$K@r!+Lh6@ADkJP=(#Q57X3XH+Libk>bDD_vfO2#ZLm- zwpu$x=n8e3i3xnwMe9|oZt7N77lk+a%a|*U|9XcZy z85Gt0XM_TocvPh*kG)So$W@Oys9BNVke=D<(g^^K)$l2r0mIJWl!B6VRq1yOjD=^9 zC0dC>>>Pa9*&lHiR-cA?)J;dDvaqwP3<*DD!XzX_qzhH%jcg@4v;B$KB%tLlce8E& z57Z*|xi zgB?MKdMiV)OQ}S{=}18Tt=37~PeIZt{N^bnXoN-ooHX4=dVE*if-)o$F^z24G#ypF z#iAQ63?7_W(+4T3Gmi%T!Gp7Fj=@_R@;N_6k4HYPdd5c?G=(CWa@^9dYd~M*NTj2M z2$y>__yYiXGxE_wBNsLdi2rWuOZS4W0m7zV#4H0sJ7WkH5n?Z-q|Q8wzy{(mt*Vb; z1O4vAM0|F}@aa7q(u366oj`6i-_`Dw=FO{X9ORUe2wz^@KXHvO~x*6!#e8ZC+Wqcn-I-{qlTf}kH?c* zyoC%IFAV@j@Ww^^CdMj$SYTy6aBWh>k{XK(`m%KqMwg2Jg6%82V$_n7P)nfpJh-;} zkHChd2jkyg_%I1t(?>|M7de)U1~Hi7xbv#|O*NMp;m9()NDRpe5aj!767WKJL>hQ1 zxj3vaOabUO8#NPy6zH2f+N&HYQxMbl6C$9nlMvOxKN4G=*iw8R*uFIi-*R2~w8)+1 zsD5%{^|h$}&gANA*%<*qBL=lSV{lLbgS#QvdG`s&RmVRR( zgsFL68fiyK8ur(ah&g8zlKR2cka6P+5-=hqp{A{vS;}C{JCIU+HmBvEX)mMUd+A?W zm5Xb;)_LnYtKk=XAXTnnJG#@KGb-vDzDeZMCh%kXZ!ui)tLG?8SJ(xF)XI~_w+`P< zNLPCRsfF>|0SQsvwf*H-ft865X&s1SgvtY8iTrK<2Er^Z>a=FNZVJ1CS`p=)XtwPG z4t81jY7JM4=RT2m?}=#)4|2LH`b+e-o(&^+HHS;tR<>U{krj z${yGr?I(b6+R2u;s2kcz;PygC^+`r}w4u@-BP#+^3IdWyumcc$be;o7uJC*rAKRDm zI|ytJ4$WQpYQa8D5iHH)>^1&E%1q9L%)@xJR{8Kg?Q})ZvHn0uij+o(leW9;?Fi5{gs}wc`q)K~b zqklR7ZPoMNnV7c(T-}#TfezO$fSs#Tz^qWdXFL4exlOKxJ=w=yc#mxckBvn~>yg@TDSL;i|9k zjF(TqaYk?zeXH(}jYwaR!t01W49>4F#Saz|k3GW=oL~LB(z>xa^RI}~ z7iFq&5vnJ7)c)1`5g!=I>iOsJXM--by2AG7KA!ppt_qIuW53RQI0kg}%P8|;H=ut4 zP|?o@5%84+JcCdDbotzBKp#keb6EaLDQ{1>yw$L=1DUZNGz07#8J23p(`K8g|z71DB4yZbRPB+jYfL7^97W#}N=qq*k{c`|1 zi`YI6sNgMo;i<0p4VsT$(-OD+3H$m0y?B9ad zuBXJewgDOP-^S}m_Tvvg5erkqz`PQs|h6gM_f#Csc8 zbx7iiU*pHrM|UT}RxKvo!yVlXJJ0_Ry4}o)0H?V+?98l;$q(o!37t(>TU!2(m)%v2 z??Iq>eB@}i+vUuMD(Qj$!S;m3T6gm6@pYC(yKG}h#-CrrB0ucR`Aaz(_a@+<2>4Sn zB21Pk5LR*Z#MM|*OMDBh|C|P5+ni!%l&sl^LjpC&L!}I7{1Pwv)VKSE{t{`qhGA>K z3<);=Sg_K}22hCIjADK@F%mIZW3 zO0my}%ke6+u?=aaZ(ykLJMgDY3oxzIJJ1MQ_p_4_%1LbS7 z(y?1q3Ekccvl^ByWfev!5&$@(&^5cCwLe^FxT@fnj5C|zA#NX`a%WPMO*~EDGQOMw z1!cJegDfdCLXagNU)e>LNTsWRw?j-9>JM8WRk$;VJ>E*A@a);xIG*XM8VNr5^FOl#7fAC3eQ0XEjl$H~F6cjnqg_?M0L;rSOn~VjvRz>g?*=pM zd|+#pLn<8DJu^=4T=l>|NmaY|HL3OdI`UV{5qf*`JH>hcrl_@ zBkjw$iQ`apZ;>3)e&)So*upCZ;)2!|tU0JK&o|g1vS}esALv@xQ>2gch2)Q2-USnl zE?xM{dxh&q50q7g4%>a{JDQ(h8{SlXDN#cBVjZF3N5rs53Oz8;4$uJmeo}}A*pj`K zq%a0gerJetRA2>-(+=3Lv2E~g_3xbeIVWK-_U zGc!(Eg}X|!hVt)_SCAO)*FWq_DSY$J3@wlZ$7mW%@#f-2j1TjXyYSaAUx@U<%Syf! zepvHy;pQ3~koD5)ThmL9iT3P)XwlyV)`KF0^&NJfl6zH@%~*T8K3L_mrOzNHU0~&K zqZgJ2%AQQv_w|GeyA19((Mp5MVh{|pOfyp63))FxWGa4UZ4Qr32{kf>*WR1;Z2~BG zggIXHV}1US7m`8uI(>Zi{j)!yX%?nl!z}8Ygsn}4OvC|A9Km0{eB7BSAd21VcPe9SNGJu_n6wPed7U(?Q7q1xc1#Mu3P(T{-e@S z*6`DKk5rQWzsiD=sYPqpIV~G^u++JD^5oISAO+&SJYU|-w%Wctbd8eZh9fS9QoHO` zUTd!Uyo`x6zI;~OE@2U{cJ$tOzt~Swe_7Z1Px}?>Pm%ghNUr~;p6h>OEb7lk{RtIo z{bo|E_WSKR6Mw-UH%vrtm_w$^PsWY-Nf1<;Kfa0czeOWlYdWt$_BXdzSHY~ArdN2= z>I$y8sU|Z}n|f1C-xU~#j&{sC4kXXMuI2_L&#ayjy$0W>*Yv9^xaHPcuB*8W0iSL{ zinAuGu3*Z{YpQCB1GVWDH6vFXg_6)i_; z24rqa$oD30>06R3GP@cj5l=;5q8a?mWuzdO%*(Q;7A*RR(--t3RfuhCthH$`ZITM% z3*($xe2w-mT;gPHmZj6gk(R|30{f9l`O)#A4GUIt z#)V66c3cvg-1PO>P<2xW?mxwBg+0Gpz|iWf8`!duxX-sqF)S~}cl#B{07>Dw5Awok z#~)hj!$aNchxZMc3llQ8QURy`J|3fAT2VH4FOvr0Y3S=`34}FZA(a=Py{W zPQF|vUk*^`*xzLhmG5x;Kjb_XkL#S@U5B83G!B_VoJi0bM`#12$ccTf!+_nWt{kwx zlRnHfH<%fl@HJ%GV8mPwWxatH6l>v6*tx6Mb-14^0~bER6j;oPBYI}dj}BBXP9qti z%p@P=His&`Re`;kf8(2!1P5LfqSvnp(b5q^-lW> zw#-hP|Aas7^Iy0cLp(k#CvLH?uih%NIgd6Fs5;7q7q`#NviTF|Keo%);@OI?;Xi@- z5-VNx&V?2l^nA!QARgv^i&*;z|JY>s+uuuS zUmX6)|0R6xmWTyO<3Hzc@Yjs#PLUtNKi)sts73l`P%?aVqYXBpf9(B(al%PcWyty7)cW6%oFB!F}=Z?IoL)K`>5` zJ#LIb40n~aMH^jld2%|$xq-7b%sQj9OJUzTDOglaOsX^0wrfQKl_HLfHuQU4@Y*UWW_ASmD|J3f zW@_9<%b4*5i%zs4JQVu^cdQfp(b=@gRIY>Z57fwC$(_L0s1d#jqmDye^f`qUj;_GI z2xAkX!^v5y;#?!IO)Q*h%qD&TBB(i!%jOA|PY|g{$ydIu6sS7zJI1igQCSyQ-OD+u z{i3)e(fyZjzCPD-&3I(vt`(W2HB zThzq<$?7;Q?J<$~tLZxzmB!Xc!48jXaahMEJgOrsC~WR!J1Sfc6o?-BUoE*$GFx_H z%eD`3AB)Tt9z0p{3HfU8J^0gK^K+7H%$8dRtGU zB`CK#ZuDYl@^)h5@GRxeu*-wUX>Wk3Ls-p@KEEp{4Q3I+wAx@aeVV}b7K}34sZb@A z*8V^2%Ms*~KM*$f6SOOMptrjrojo61$!+meM0TuO>B5sE6I7Z15*`98|Bk;7*jFdx zju_@~8uI|Zf6N7yha*pYbP*|=u^I`?ETD< zkfu)lH;14$VS>wY)$qHdr_OE!{f`G2-9JmnU+BwR)t^1(M<=Q4^_S-VpiiAdW%*8a zQrLM`47m~_XJ%wvjUY-G6*xlc!%}64lkYGkJ^nA6cOkQb2yA%=nkfDO^n0qHvrqMK zLR-z75Gh*JUU8ktcz$9sv_JD5(5?bB7C7!_C;%Ed)Em0MbCt;jp5QwQoQ49bZXA4> zqYnlT9OZ6c$S5qm1PdJ2XlUSjVyDo9+v*f|1BN!f)}#~bwj+RqcUFWD7sW$Llx3Kfg1s0iAAx8)YvwD6pi2DVItDL5Ml=pj^!k2#pjPKD!Ure(G z8rBEu;JtR~87%z_ORvLs(Iy;3Io6YSFb_LLJlfc|Zl^x3*snjv|6~lM;p^M45dAX7 zXq>IPG6ZQ!BRX?&%)`cp3qk8N04Z z?w-&2j_z5A0@nO0{_XWMAf)I$=dQmVPwiFs6Fg8nvp;G*z@23A5E%{uhlomW4$bPd zx(yvvvH>hNc|)e!w;VZw&&@dq0+S2yD4B5q+IKp+W#5NDP`xk;tEXW}t0yfV+zTGS zSJwE>=3y(G`s8A4ow4tu%F5&b9Ye6=GdJ5P+%^}-0lyLTL+!)fF6Io;N;`~wAI}&_ zZvE&KiOKQkbO`4M-p3c3mB53rnautd;lQ&n>|Ck8o6qlV=6Cw2D!z*@BX?nbi>bL^ zjU;C>jT5CzO6`R)VQCAkgkLScM)i)huN-SkBkw>w{tOfx7qSiWSDdL%@rTp<_zTz0 z%d+-AaTpXs!yR7T3t}zBSpgR}TgL;Zu!+_gIy>L6cuMdwLqQenp|XK82+PTJIc?f@J5U{7ZA@GphA z#qNiiK#tPTyX}v1G6;4eKJj1>15NcIOk9j6&!YrMa-2>77->qwWv*x%Dgnkqkqb)0 zSA!x^6h5davJ2XXKYZ#9yM!Wxas4aW7d!~6@NN_2oTc#}Jh?P)O=;fd=xvif^LhV;<2=HGWR2q(u2Bo;=95h%P?dz-CNg9;m{BiTn zG#YlAKLO(JOYh0F=I{WW!d(_s;*^5*2qeO%?bToh^mu2)-|(Khf$kTE`)_ZPTAOzm zn|J!aqnkh0{bzC0UoFaI+7#S|1fYu+k|A}OT$w@vMMh?h?wrGW9w~Y2Mn>ybq$kDGmQo6YxtA@HF zFkg@$_DGA)e5NZ1(C=YQzpbR->!jbuntmVnR-;k)2OioS^=zGipdKtoAoFFXr zD)o0|uT!K2r}q6S#$F|0ec`Wzs2cqBwh#~8VdSmx<-x_2HMie^YWzJg+RM7oqmCp- zTdY&-djb_5VQ6N6VLDzyCb01*5R9c`}X+V&$r34 z%olnCQ;i(AKNzRu82AG;90bC#@mF}jz3>YX3X--`Pj#fPAAX})p$RQ-vArwBLTAbR zw3i{Np@QSz_fr` z`G@tY(bqD=dNue7x3M6uA-*phB2&{zQ!(Wn*xZRjq+3^_vk^aS0?@>ZaJtxcMp`M7 zeYEvb$8U$q%MM-e+pAb`hZI!36La3Ta-_^x@}eu#`sZpZg*B?T60+4}){7K;Szg+7 zWecqrDf4Jz&dt^f%V_v>B&FFOu5)1A;v{3LFQpX|-0UwTA8Tp%JtOy1q;G9M2fv_B z?qH!#%9MGqxo*cwHbSx{OvAJydnB+1=zp#zbHa>F!?A~^aEYJOk+@x$Ff;2%JwGo1 zx|aT7u;2H~85GzEP+CT4Rk*Wa-Y>Fu~Ui%Lo@&IN~i;GtW6fL)*_ij1r>T zH#H^JK2Kb|p?t?kcQ4FGHd~x;#kIQwzv!&lg^*gkq0y#6Xi1L-+2h!Fn5LR>cxNEu zQ$lNm@O@V&pY;WjUm191^m51%%59YGjk3bc!9VJc`hI7XmHub>s(AqUO}kYVs|hTNS1HfxoH$l8@Gtsc0PJuU?J;;dNjf-`<7erdw} z>|bM)NhezOvtw89VYCa_SW)esi4rPr0l6}*gN-RZl(zk>|A2UPb$I|8Q~A#-u?)|$C9n;tZZz3H6oiPGP~U2 zK8SsZTFY5K=D+%!0D*@Eqk}m7a{ClIU{O5cq@d(MJeT9tVM)#fSmK5LU4oS(+EUK? zB)_54UH=ycClId#oq8;zB301n+Ix(9xi>eOHwIhkIsPdv;9qK^=pc8n9tHdWQ(Ii0 z0+l}kur=>_0EK*a%;pf)!;|9*oK* z6uE}IKl$sq<*+~Q>FmU8Qo?x!$0CWiKRhl4@tn4Hv^!WHs<=%H=tY`kt}U}!CN9p^ zvuBd<92ppY*7|W90!en`dpp4&{!>mRs?b~TPFIYD#Aan?nr8#&!NEhj-3`;QGz;9G z4qx=i^5g^o@iIAjDjiX1fc4fexGRTC zU~_Wc^oa6bN^a6AelW~Z7Qt!-69C=>d3XpYNd?apo0DDX>Nu;AZrftrHXXkY_uILH zy@`^!GJsNO)IRPxKZ$4ZpC6}&7krRT<;ofjKpiqzpKCQs_CfyG=W^LD(xtrGJ)1xvV@O|; zisvWWuRx`uVz0sSggRF~Js8*|^8}ec#_0~}LR;wW0el1fVvl>lTq!CZU5lAYNgxm= z@9CgD>MFv34D;GG!&JDG-&tpksmm3xry6bpTCv5Y)?eh7Hh05sh31PpdqYPa`&$n7Y{sV^LZ;lU=6`v^4t#m z`U-1ZH7KPULPVt^r#*1K2=)s-eCV#rOSCkvjJu)Fy=1L?(bVt=~`5U*7#BzJwXep*G;O9_w$!3-B8` zS88s00QnFxh~FUjU2fFS5!9boqmGr2K+d`RP`9uP(nG`RZ8WJX~Wk zj#h1M0_*%aZ&E&g&0YMqvEb<@EZJ2Ho+yJnY|Aoyi>9$YGaVmVLvnt#RD8)SAO>!7 zsNKXA4SSd`Q&Fw%-&s0ULjg#&9^a{YBuoAhg2D6$PbMr#6GoR&xMp4z{8C9LjFKvB zM9iqPq>wrHy>$4m&w|>>RonBpQr*(La+maQO-4Vxw9nA4>7Zbs6L@!4u{*b)TekC=lO$!IDj|G(Es&IhFSVdGC^uN` zqL_nW`3Z~HD1RoAKag9i7HbK+_wiUR=65yH%CA&2bpE3&EKald&&sb*<8}Uhn~>iZ zXzKifB9u#V%GGe4-%tX)vSRt$EuqbBRF`N3Z?{nZ{Z?D~0p|Z)=daz3Dl(8j`dax( z!*u}?RWUdR{WDYA{NfVSI)pHuYPEH7&3~topwKAVH^Rr>RvTi!T7NDFxvlj>r9FJr zHAuw%F*eZ7klqmW&0;5~_wNU;&4B~cdn!Qh5na?y1q689~szsUNZ}}plK0(3rIPE zS459hXI?;Rfjz|u2Wk2?b$!o|?` zI+%T-t?H?NoWcs&9rI=37hm6HZ2Z|82Nttt$V-xFBQ!>S-BJ*8w!*`cc$oE}9Z}_U zOoCddyig`Rh3$~MHY0c_<<8^%W}SgF#NTXhMImebhYe$>K`DETGpyNj3)bKL>OSkl z>d0vRkIM)Tycb=SYNRcu43qu^yv(X9^E?E}I6FP%Kr|J0O)Zncx2IryQ3{PkbpaG8 z4fpFPE=-yA0ff!0Gm6cUHf%eNuY@3*1yy!@1q>Vdh@b3SZ`AxVX^g``Q`>Geo=+l? zF2WOJ^2$sARafJsG+dl*bgmWklG`Z=dsS+dWukt6;d?XBE;X}D5l5&rZ|k^lPAdEm zJI967Q%l3%6u2Iix=VJ@dvdiu?>%2QePnwF2p^|NY$WvjpvMR4Z1oga5F^4wf-oD; zN>-5f3dqFyX4$~dA$S=)9Lv3#;)HI9~UvpB%(T; zn<^a&yvcs72%UlqH%@bU+6RKFJyAfnKb+A1KL0pB{7**fVJXDWqZ9^Q5NY^ceKKmRsNXc20;zmGSV<=^D?m%b z>A1y_jQw2eJ*jc3#?!4`?Zs>o@tLp9h zT2W%`Yd4w?3^wxKH*VPD*zo8`GAm4Sp*GluzWt5F1js-=(Wes#CGbaDyy5bhck4RV zdIikhlqKRwQ3bMZ;l*a+r8j=Aa2zG+eVZ7ZjN|%@C150c+s>9 z-8Agwhn-LU?iQSHg%=NOP#I~D(Vqf=x5621Ctl0P++figGa&qGAZs8}qZ#VBUy*uv zmKdt=hYGG@GaS|FE#9M2f<+JVa|9lB<2(3L`ptV;T`8|f3eA_AX-p?J1X5}~%F?Ac zdDpAdoKzM)Lv}T;!0=uy^%+6q-QOOPF}-pC(0&aj4~IBhWBweu272|0pvwF|R6!ti z`2gpSk&mvRX*F(ORi~b4@zW34=k)k!Mujo?fNlYE$!v*yV`Oc@_ui#9kHF$gCSV=ZvQJ1kQjKMBYMCE|M6 z>8~h<20CQK#q(_aYL$(eia;e545ELDjX;4v#)4na1^)4bpTH&0|5|D)kk;?KUTWGt z7RK2JW0l0)uZG&y#bssp_>)%69yoiva3Y+1Azg3{)7hN}5k$MP5yC(RFSsCrGu1d) z36ll@x`ZZGd>Cs`mj~K+=w+zwJD2yd_^j?rN`S`t9BOVfHGer-4$?ozLJbf73RFaK@Q;Qkl}rUkYMy?p-+^)M13J$SZiy zm3M7TQ6mw2!M*%0L8N|t&57)wS|eXXjQudhbWPp!@Hn5@fjXj zObV*N^)j^`vQ@1ge%NRQ3~Ra;+@DwD@r5f>e5gUZ9#O+SL^e~`!@+yu*~pKMLOt#O zV|kKwWOpIEd$}fDeG@GJtVqB}ZN&(S*}z@eK+!#b$8*I^ux>fkF?&fGZBa5aCQsw_ zZeG|&_8}QimZC`f#`V6PZ-wOgbzHbEk_gd|nqQO)*X5e^@STX-u*wBOLSL&n-9FD- zJ~^Di zQ$GHmZkDWCFM)1E8w+3l+r!B{-X7nT$}v<;AxBC0%Fakh=w6#318jmMoNp%U?5(zf za5s>>ney#CIKS`v3tdCA+6IExElW!jp`XIeE%x_U;Ct9sIA}O17v*EsVn=1gkUiBf z7jYy7i=LiN`TH-G^GnKK4CP1pDIHRyt?-yC#qDR&V{x6k0Ki!20Hx?YM|hCrKeJ6r z!J=yjDN?;zZTp3Ya>INi2I^J8y@0rHe+IbYe!|<>4VIAyV@=@VofL@;#7w>*)4|_R zzZ|Y_2f>t)BvaUbdR?I7xKVmx7;hcEcX%fa;~7Sn?THdg0c1lx&XmCJvZ^Cf>}e|z=GT)(|6W-}Vs zwju}IbAQfPENlKQX9s@SMuV|QF5;9_hA~V-456z*C&7M!Y@BqOno}Ek%ZDWfD5TL? z7is?w<}4UOLcFa(y|oFwfQ^Jxf*)hi`f<8@Il@T|#*X8XOm;9m;DUeWQ)tv?5p-C; z|BFKgVoLS@gik{3ZNZN)Gc)MK4eO;Z@LUPMxS#(T92!pVt3GwJRXTD1Z*`)SRVIuy z%z>uR&u27$1kaGHtA3OCMc!%nBAoFD1es?YnD0eSL)S3EdfMW05kc%?V=M8-Dad^EJm`={0$Uxv~Kv`Xtm!=-(6e}UlIuS&KAn| zViEAA5b&kpiIB(pJMsK}X=qz92zc?j`mH_;yU@Ik!=NNQnnEHdLIPpg|0}6keF5ddn#$zaa?9i2 zcdFg*ALC$_w@W8E>>+EYlQb({`0%Qvj~pX>woRh?7) z=DE031DoKnd8m3Qqo+qY7if_*VkXrcvuF-}N^!;?l4TmOoC+-Ez@rs^R&D?D_lZD; z;2U);{+$_YP?`UC+kivU$&o%{=_z*OAQBjZr-`t7w(NM zhP8gb6g0FnJ&Z5zqlQ8MSeyw7Z^yeH=jLR~-(2}yAb;VSJL1Zf?2BryxN!iJPuZ4} z)E@rk5*)Z*TtTSMV^~8zLXxpEuMwsTa|k~1KhNyaJsg|x?RhII(@`n&%vQN9I|{* z9W~CnR2Qvc{0n0p)+Si^Z}++xpFyUvrYH^J9x^K&pXQ2+U;^$3RUF8H7c-v601hq>z;03XjD z_kue8 zKh}W%3qDw%@W*i9*}4`V`&~Qq*Z1DVuL~UgTBC0ZDnRwlCVt|Iz6uB#k3r=Y07%Nj z|C3!`Be@O#Z)5T%{@LF1)2__~)`o`Px)J~5`&}8A3b2q3zX$&xE98p`nRY}el4=c$I%9{@mnh;}1!IAJU-2y{n0T*7MIM{@KnypYYFD{Ii#TI;V{RA)4gxdilFa z{%)7QpUB^@8$R9}?10wlBF72(h2uBH5$>{`a3|JM#NI@kYy z?7a(kRMpitKDohwz!~lVQ3j0~R5U1PA|MkDdPXJ~0X1GptwyX?B4h{xl1V2)#&K-g zda0MUFIC@GYisd_AYKwc?n;0bxmX3XaHgXYr3C`Y{C~f-&zU)s3tHaq`=00jJk9fD z&OZCP*4k^Yz4qE`?}KkhC0+3Af$qQ6Ll^@N{DW15Q^+XjX;#5svI9pVe|I8BnFl{p zOYl=shM!p#l0q)waN#fc1OrCTqErENS{+Wf|G(gae+z3e#SiBjyC65^KQ3&zowmSx z;HVV7H?KJSrzYTA9R8mQC>_OV9~Y1MpIHc1ol+c9QA0m24t>TYOPMc>LYN`A#}pck zNu<>@4_|A}DVSmI;Wy->Xf#qd=Y?I z-{FMi{#{?>k2&@1Od|DHLCSW>F#$gfd9y%6X=0c(QS${C@>VOjJFgYNYF08G4Lt$J ziP#%#h!y~8XtOkAqrcRTwQOqrn4gbZKhn8Bk*uEuh)DbO!(}(Me%SYpTR+lK|3`4_ zFyUu`j_b#YBei}|__*~W9rafw>t}&>>-UB}_rkFfTbptADm<2&jKgfe!Ok_7-Yxof20%tWcw`eL)#aT8>z&i65`#FV2eaRd~gov z!7p<4;OEU0?pV3q43QievwJkHKF{Rf`cy0)r(n@A1!;rz(4EdDsLP=}8$9f&Jh$fP zm3Q3h_xGP*U%e|F%+~e=OD(lj#aVOpq3SaHnP}W;`!-hcb0X*~Bz>79V zetG~kuU^i|^wo`g#G7DQn#zXpA-SxDV(KbH%Z1soVF2m6Yp`;UdK`}1_0^fOtT-Lj zqt-D<(8urvD-i=sj%tRW8Z4i>Nj@wGeo=xv_)=h~Fz;KV7H&eAYqCSwAHfq-7^XGj zJj5D9uf)&oI_t>ldselh#P|p=rN(`L&v+PhV-c8{13|?M-}VTgQcj7yU~w|Dcp$ZtpgB$^u4S>AJ_#%9uF;KOC+r4R2aBMG zu@v_*VLj*#-Rj|Ca2EpkdiWMB;clI(Y-|_$3J&_Sq7TDW#K*4!9K78ZQYIL0xI7>C zN}N_0|4V&o^d)4lZ5OeA?IgpG{YqP`)%u1F(mp0|*X?>(^%&gO^Yl@dmsH-NhkN4? zMddB}s9*zV<-f&v1PG+AcyG(+*_QCw_(!P~grx}bT9uXopQ$j3ctCK{-!qj@>MSgN zOMD*)zaO-WH+_(i1W({20eq2>uZ-gTJP3v^wBdd$%o{PV$H#JD3&o8PHX^l?%sK#- zTHos7DX>&>x9v)hSahT-0sFM6dg%HRJ$xZNi2YrS55|EVblJ(AQKF)DFlwYkNvX?S zroDw1ZOp++|72h}NHKBv$H4OLsm5M(f{}(YE95M2bY}a?5n%L!!MzyJ=z8n`(sY8` zEh=-csSDSTV#MVYLs82wMix(bp|-UsN9O~s`+UGdnU9-u%J{fFXDT1};QC!W@Ff>M z-p&bt&QMUdnl6Wh(xy6WsE=%~4#dDxgn+N#$0Q`Iaem(#{AAp|^z|RNZ=R?7NV4OBj!OxI_ zpCJW5LkfO|6#NV+_!;UDen1Gx+TyC}LjHqDi0`6VLtX=rA@b^x*Pf7ecvS`tiTQ6U zhI*L96k`^UJaizIn3J=t7$iwdG!f%8W8Q@Bph`h?kUVwJxKxbWjG2VYD#l~R48dlv zia`%csr`u<03m_!U}YKEUTAd>-b=(?d4+ zDq;ek8`{jc1bk{S_HV-HNrA5n?Ly3&^qXa@LFH^6?m(QhNWWRefg=LnRKRx+;VWZ~ zk`(xw{vq&r0N?*0x1yg~%zZz6iS?T{|7Q@0s-ss1EI{XQ4{;$9u=n=@9wxZYi`+B% z3B*d+SU{UeqX@Topy8REKe8xX{aF*Ydh4Ys8;!dO4zfJljnk@fy@!2;sMXEDTtRM# z($JAyKg;^fTpw!l7oc82A$5&7k65@Ni~vzC9tkYC>131uR073w14%3-$q!h}GT~=( zc%2@xU`;H*Rb@&~ToFZ0iRCBmoQp>%0XF*zRGnB5M7YCZ8*(YZ1b+*D=K3@hKS)xm zmlS@8Agp*K@xzNz0XPIdyx8z#(qmXTnq`O|ixNM10zW?OBca?-_#qz5mXE?o{1C?> zdqVh`>*G}XFfXLyhX}%oM-o5081;Zd@WYD@KPJ5a-)*xD@nccqCr{wVryalfyZ{XS zhj`#uio!|!5O>1(nd|dZ{4jB);)e*riboPZycmlBhv0`78-7gsD|Xz>GQ^KXiJv@y zAD?#oez#ZQhj`#O3x$*TA?`%*OWFstpZyY}k2Zo-Jh|*Q#j@g4L=a{?l6d09SOa(j zPrTUhWYU-aQg|XvJn;}biNmexKlSG4d(mf#0Hk+VMl&3E(#t zYl9B@&(j(|L=ZnblKA1pa9a4`#fBe~h5lf4Dn-8;wMkw$EO{? zOZTY$Lp<up0(o^t5QUnWl!4E}=ABqZo zd=fuaWz$w}#jR!>e~1Tuc_^IhKZ5i9^I&WF63^%uzs%P7Wh(qK?f7Lnj0J#0;g^|$ zACmsmY~qKa#1BOUKR$^ctFqxYZ0gM{@e;bw;ew>=0Cup@N=i&hotTneke-(P*m{allZYJ8-AbQ9z+>`ZsND-%M|Z%4^B<5<{TE2V4@t!UQSd`i;)kMwAD_gJRoU=6 z)xs}8{F<@8w&4eGP5{4n$M`vLy}mLFDE$)`lL@R2_?pV%`}rIgU(*bob_jr*jTig; zhoqkZM6-q`r`dmwG~nk-#Sh?|2!3fD_MaoYHGb&|)^t05>BdyR zVd9sbf?v83!SdTIqwq^N@xxQ_Lsd5XZrx$wmk#{$P}tUg0Ov&T%jg)t%+~m2Dp)h^ z_+=UkXhTr_mzjcJrtv2%%*`?izf2Q9JOw{gWy5dYb_>5u;8%jecKk9=2*1u9{O}a~P?Zh8cR#Z5 z!;x8|9)<1rxlRbb!5!o0Zry)w1*_YRpW85KT~PSBQ}A;e-4pn^6@G3LKRg9LRAs~O zldTqhZs4~Ft9m<)!a2}r%jB?^n0Q#c5q?5aX9o4Jkc+gf+KQtE1L}| zThKJ z6mciyE`8`~J@hSLLj~~Wr581}8?*YIg&hoRy{k-U+N5k~pPsfFJDZ1fZXAc^<+p|k zXxchKwm$(M+D302b@&HiYyPs958=rRPXT-uHy>YpLUUIRmF9xS`7WGAV%FtM5VI|} zeUK45X60?~34qNV;({_~RhF@V-8#yR5YFAkS8NE3(Z|3`!SB-2T5$J(TkZ$|AFR+` zZq{BlwBfO6d(|f50%OLV#}ivw(bKkIbp3QF1U!$LLE=bEMOIH|z9El(%u#*;ZgU1LBh$U4^emD-iH)`C)8-m@2Pps31)$ z*i&Fu5VZo$45$j;w<c0a8t2qf0;90<{u7q+(K7s{nO(UF*lB!BClLb>lf+PC9$XrYei zzaZ#a7nS$IWp1Ybwd3?$roYi~dLGjs>o^@Mu_Nm5INihaYdcCeH(`E_O!T94^SnLo zeT5SvJv!lPiG6R=)e?K&biXX6n|~QyGO;Iyy>1GcSv-3aKpmVV>iNV;xCQbwF9(Al z$kxNwePuZ6arx=Y4KARw4nAH6k%Kp=2Z(~FAO+=y=rqVSM&l6iVRuzuFw;Figqfv$ z^lGLD4|^o(6)PzhRYylKX-ojsNa8=O#FLoVUlL*AQi&H+4Pm8UorXl*?_yqCEG1`K ziJO@CH>q=KO}~S)8O47vx%8kdEARtc7;i?&!k(nW6R3Ut>4AgJen1-g~_CHMqSn z`dCLt6l$j z`wu1l!v+5@$3yG!*m@r0!E)TU#ygS^iL!GvU7NpGg)(vTtO_}`pM8dqR%^avXa5tG zf&-3!Qz0C1+{IAMQBLF9{4doDl^|_?AI!9YF;C=isnQ);un~hhg%2TPV9XrGYPC<` z1xK{1$MUDzCBJU@&68h`{FcaXnfzAp_dT{I0csNxSZDO7zNjvmJ9rn9+exW*Goe~KZ|>j*m8(fTen^>WkCboI;d2KE zR3-K5u~0o0sYio)v~H(0+b7=1|M-FhZYtvtIGJ1!O`mf&Y*8GhzffTN}r zol2$y24p&bOQr+7WIBNZ4+4S*A;F_VQ0_$a)zeUYbrq_wu4eTR6RaL&Vf8?q)dO=@ zFRvi`C;j8A}nI>)}b){qg8nm>zK-sy_5}}xhHBG*uI~llvgrD}K=J$_H zJJUypgyq!tEV6qSBtKw+Nh_k(9@2t zY@Anp8s-2H@NPg;J)<5!bJ%?K<LqF>F=A^YW0tsao=3GQvv2ZU_>HdgP34h zurh21l(+SmI0FCTq04>vtP#HQ9_cpNoV2v;`3)c!9s$UQ_E4%>MN*kl4$<02wDtk5 zn$#76wi5X zVsZtJwOqdoJ;Ij>9{yfe;thT_n4w$C_*-7#8&3am0A9Y!H}n&97P$pIUp2?X5J^{H z`kOYP0YBF*#Luk(z2+;0RP~j+*jWwitcC0>B<;6j)oAOkTp&~7!p|&%SMAB;uTHqC zOG@}#N|>t4DmW}z38?CU5G8Tp6MtMl_7RYM1Y{op+1Cb;*G%%7tn^P{WJc@x$D9Vzr>DA@iZ|%(!aJ7b>e?v;)HPiQU|$Hp zA@GbiTqE$jTt9`tALWW51YXZ6QF-2$Ti=X3TrA;IZwOfFE~|vgs>5Z~>ayB#SuML1 zEUbpWu@=fF4V5&=(?kYUER=T>SyT{^cTj?Msi{6#vdU(xO{ZPXxfmC263AmZgtL zgCE$;tR=|6i-NP;tzX*DkUCozaIt{7w^o_MZ&_!n!=72F&284k@@!ru6GF|Ntj-5w z^G?pO(Z;ycbD8Ei^fkxQ5(5q6VmDOh#11L1e{n21U8+df9G9@5RGHXvNExO}u={}Y z!q7@9=c=O6KEUc+@()RA7wcpdX8F)+l5okTZHk!b0%LnsCFw(!%x=?Yf<7ww%+?LG zO8-RCThSMwVS5SP%Q2C?AyWzjC5HNxs?7>0Gw=PH9OF<|I&S1?qUnqqf_+o zuNLqT>IQ)aT0(o~z`F`OuhK)3?i(c=lzv?Fi(OG1$0-t2{ z_s4~SkD(1*Mb$%uS=PQCAL78BeA*}&KiPk92`X~Pr*`oL*Xw$2aWofdubkxn1O;!F zf?0isY+?EHl2g9s#fQXh2y9r&`Ri_#8TC-du0+J4a{LA;@HdU5EkJRA~NcMBAUJ~STv6c_)+ z|MK26)M3uSv2Orh5`W+xR1K(!_uryF1RYEZFk`J=oetFub^WHJy1)={YB9TS!;);t zmw310t)~q>GWe1Wk{#H$k^jxOIFDE4!Pv7JvjNy(jkZND==6m}G=m&aa718J&vo*? zIP6zTL~+=A7(tmkL?A-KvtJRGPu=^+?%XNG*ux_ot$5Ps;a7o6Km*Q(5-@Ie4yS3uhgV;!8qPS3^t z{5&8mUVQ#qIY~JO^3~!D^|Zq`fbey}{SDCQut}`R{kS{NN~z~#IcU5!QHj0$7?!_4 zTkH(9oIAaT+=LHUA73S~639s32v!JfVXaDSV~Mo!s;Qqmji8fCuAB?9m$Kbdt?k~)n=?^0DpDE1-=gAYI{7jge9(xCmb z3km#wX#2&9_OD89|LHRm?dP3n`voTc_zH=_zkv9k!Y|dMv$Vy!OItjvC+;0J{?r>c zkci)vaaywBH{Y=kUqr-n=@;mKn@HEk-bkR@Zb0yt>!hr#+iaWbHdpM=NtS$5sQya3%_btH{WDGc6aKMhLKg+Aqp3B< zjUxnQjz#I^tE>iNav7L7dHOd>TWb^5CIS{^$rn)VtnY)Q+)-;B+H%;WYNDJKFw27v zvBF9%wL24lQPPqYTmgbMR?W{62-0c6+ox@3HUwi37rzHgz9E#DokHK zAa!DJm{p`CM<+bl+S4F4{i`=yrxSjoswEyz$(X2qLrQe?<+N|xkw4IJ+oNBh8(*Gk zpK5LJKjHGJ@J&FI$+{UzO~3bh(jOUe{PO3WdHnQyuR4DEgqx0^{^2vN(~rYnjj#Q1 z`ntegSpI;IQwUOy?`sVfaodrHP)hb_kDTw0Pv74hKYhZ3t>>@Q`X@BCE^p$GTV#~v z%-2IS;=$>ZmOK}XJK3=E3@YL{rB;(`oc&fSW(E)Dsf+)_q1ykB$dWe|pP2Q-9%NQ) zbcLU23REB+yk$G^g-w)4E(~JG9}M68l=8;mr^SH7r9gIaWU2NkAGP`Q5W~ruTzWxo z|15l`*vap!PICJ1fpcoMUNAn}e;cln%GC=>a{Z+gO}V5*9^92Nk$7Cj`J?%*$jUM1 z68A>*IM=G-%MiFK*Kn!iQz>g8&l*sWrGqQ-mU2O4G>5AXISuSi%ZVQpL9-T zCT=V5y7X)kW#=W<++icgnJI0@-m*2=Dkv5=dxNdgsZ9bxpl?#H57mME@h<;K2=vS! z-?J^u_9|M_UwG#l;T_TcgntU{RIdPG$Gf0x!2Zeczrv!wVhU&miYc;}ju-q3I$(;^ z-uNN(7x=O*`YwGP+Oe?!Rkq==Ew9_Fi>)@1l=5Dyd=ihP_-F>c0D5-=p>($a3M?kQA<0e(I88pxt+ zz>$NLR`+iBVe+A41{3&`<7)^ho(quM5M@Rx1S#VyS)P7NhB308@)!P~@*~;)3+8fCR*_a_b&`5s%gU?lTxcl>7VgQ_(Z-?o;dLt?IJ85sh^yl zkS_y3cZ}olZodYN1if%mw(;bJ?L%$aCtgmW&d-yeONj7m^XmY%1w+^c2?twtiP^ts z|3_$5=|_+`2>MMz2K(-Krgk4}OBF3I=zATjf(f98Yp2a3$&VLc2Je2TS^Q*j<8J@!;u zG9Q4-&UmqO4FZ$&!Fh6@6FPj8F?%>Wz`rW?w#dTRo5`Ug_J=>(`6KFUCCnB4H^Po# z@dvFc1--R8aZ59C(dzP$!{QRH?lgIuluP}(Bv-5JCGRDrz`Ind6W_RSNtrqR%Cx#~ zKp$XUf!q~Z9Sw$hxITaf%KwT_tqvw?*-=PU$)R8633}8|##*W^Xk1C^+=>A7@>$6& z2^B_YXVc9mOP)%s1eA6>)v5x4t166<$tuQMS!P*T5O|0{8d@?JpltFNxXR=&a8(IbHJJ4O9j?lF0JQFit8#z= z`wyJ8Jhnt})@w=5GH(Ba9g*m@t=K9tNM&ID%Ne>ec>QB9vy)4qTN_ZwwW-83Bo{RDB~Wy8h5fj zl{u32)IX=dTb|cm z)~mbfew<|v!kRA(VVGL;D}v9c4+g>{eK|j1xlIzS59d9q-tiH{Q?$j?`-ct%_YU@A zlcMIs0P=Ybu6FyhqE#^$J{>rGGd_gbnSq_dH~T`3g~45e>k9*i`)hU2VcnI-(=$~ zh{kU>8|Q1A#)B>C+Jn7Gqk7EFp!I`njj?t8WF|}nPPc%YY6925?2)Wp&jGkOw+dw@ zO9u;ObPKqt3bh6$@N-bhx$`>APBH)p%i`Y|}ZWcpbQoJy?bD^&AWOY>OlsLzPTdQ<;< zx>4~8t7_AJB5eXA?jORGFCJousO zs^9#`VZ7?W1-9tcfMm*Afr8S$Syt`#b|2-IvV@Tt7qC-U#Ryh04OP@9=Q8Ra#?jvr zerqa=-UAPp#N>s5n&1BmRhjw`1i*Ck_&n&~hi6nmzdSnQUOhY;{Z1#<@MSLS+_@>H zATloUYJYC5B>lX^iyL~kTU*&I{<75jp|5qQdpW;0qUz zxG`BlE-N@)RnWRTmZ}q-;SoP$aV^~KsZh6{g+@G;Ec*qnoiO&{$Gj4ub$MwYJK)Qu zeLdW5haTz%6=TGXWF0TCj^|Vzs()*e{hOe~PY8+LxQl!Lh@9&}kFTF`6+bJB9vSHL zg);}DPtzeyF8T)JvT~5I9~;ocp$xQ&F9nRpCj(}nV7Gw?!_74lS69s)h^fp*OLP1h z{Rm8wF^#>yN$JDuJMKfmKl6^(RG1*Jg9_l!^)oIe8G>W#zgAFs0i{T^(aXJ|IVO~& zcOVQVZbhqlV-Ci*F%v&__^wEWuj=^lY4hh=^o0%sL(K5av98oYFwaKDr|FRqUi{yu zEuNc}rq>;uJH9Y(zkL4C*}J?%*0!G?f;O}!q;%+MpAbbPRV zZeJbW3qFK{Mw_N*VNk(2WAD~uabq`r0RPKJP0$UO1$DGM0kGQdJ+#HH zgUd4o)}67QgcanE>AZpatVCgcvS%;V7ENr2Y)VEAFQkF9PX9};n4>IqK|R+Wc0`Hj)^eH=Jz!f z1vOtJ(>o!OS*R_p?34}%z`1#ap|68`Nkyo7`j)+7ApR{U zA322b*b3AZd;1)0Os^b_18!;42kUY4?sj%tW6M~6ZaK}g&MHF7ig5T^e4qI}i}j2W z3ly7u_PEMFAgqU4*{A;C^0dlpOa)U9F5izYK|8B1!Bq23q}mbB!AGJ?^wNQ1Z#H+&vt@Q zb=koIjxh0neei5UJVXfn@=f~D)uexL_uxQFA8c{0jb)Ir;nxYRwa^2)z*WIG2doRF zTD^(LF!Hf~DP0t6>+GTU`?uEkg99qP%UTZds4~v5`EzYV-vChl@ zWx#*&oOOCc*JBss*Av4>hxGi|IruG!oq^wqdS17ID12fYzqr~13El9U7sD_Y`wYPE z6&_$zUIVt(4ucnD9x+E0W|U+|A#?Xr7QYp8kSh4YZQ-x%rTA+OKlXrghah}+TV420 zB0Rg!z)a@!1dg5O&tgaQL+~a9@RrvI8ys%pBbVE&a_Pb~DHr&>=Z$;BI2f_%hkfl6MY%@-4GbX5O<4(oqN)&JQFRsX1D{Y_7pq>8nwe|A#-S+*b8eehLXibLoK zFtRE?0N7?jYvP+n_wkFSmxm21ESun26yGG46k`}BB4CP{2ADb&B=-XnhE(NH;HNk_|7E2 zdT>^@Lwl@4BRTCS4a$BJPTEhna7@?}Qe>%CyH6mz-vjO`Lay4iGG=OXWGw{Khb+lJ zf(mW%r2e6;Vv^{i)jlItPU^#{WFl-VdgQwOGlFE3||8ddo*XEl*Z@N*BGU&z*@b>zQ!B@HY{aKy%bOdjZI8}CV^dm?J_<7 zgks0M#>v={ZQAkI#wIcsz%U!Rc^wq?TEW^FW;V4zD&`Uwxdah27inU2HZhW11#7T< zTnqcwA8o*hewgO}3G|bH0r)B)SLs{dFGg=cht7!%WO1$rtTT1u^-043lKX ztU;INO~xB6rL>r6Mmg!AUSJ;tJ1uoO}^0PBJItIxRAC< zi|j^k`@jb>zKRPrDgNR4O&r}6-%0ognEZ2Dc+gs-)JtF~CD8_UCsE=BJIBbb)a0D9 z@Sv`6!Olb-gX$AKdNK=J%=7a8j+p0BrYPoFFU(VJXP(FVC71_GC&eoeXM?alJF2Vt zEsoLK<(R)R7sf!6W3<8SK?fP%37a(A{U9zl2z7{kV_DxM|L7g@kCw_mdXx;4 z;2%A@|M>i~hWs<}HQHy^_z=7j!Fr;B)h=cx#bc3BV#I6>j8;Y_c-EfH*2-?na=q!a0KM}Dc)$8uf1IY1GU0A_EYLm5q|Pvl^R&#; zy{H_|$j4-Q5dQl8gZl=T*LwnSMEk;?{8$DiPG7+)t?tjLhVfNrNP17)sT!^TkiBA8 zN%q9+D8>y(TwlqO&)2i?+K>APQldWAAMgE>H8_#yUDWTWI@zS3==Yf7&qoUNdjxX= zM?}A$B>Mdk(eDx6J#a+yds82vEZ$<=grR5pH-Iu0cauor5)b#sCwasj5@uPGT0=Q@ zgDa5*@&zqv4|bA1=>tv-&hj|mr4^im$4R!z5|p@98GwOf zy{b-C`!`rd34#;zVizFX%YQaZPkFI35$?$bq^1 zT*l)KdAFmtl_V}TM!G}_<0vM`sE2PvF*!;A^x=3=Vv*l^w$n51BylLfm!pBBz(WNO zHKRgN=C)~(U!&Jy)&(SMwBXb7GQp!qMyrTAM!;qb5hqIiRS1YabR7b?BK2vd2{>IO-zGX0ba{~Mz;Vy@N71xCOgrA3D<+UjHo_1wG_ zb`Le4jh|v_VD1fIIc>4Jk+XI)KXq%W2PJIRC_fHRhS!3K{9}{OeGq&8Tb=#c+fU&@kQF=lRXDlIX&8As}8PkYLBh( znt&MHlVO3efi(Ekc_OWLqEX>!ww9 zeox11EbF~|JnDJL3$g@XMHgU#!RfWpA3?qyT!oD9s*LY4BNVmE^UBB7HTY#K_+Ts( zML+REbDMvU^q%an4#Jw?F#C7sVI_N~V17wpwK;~ZGwNy`0DD2`P|e;ryiOsX0QKJl z>Iy*J8km}W%mt7awt_-~~KGrv6wVrm& zSFlbCzQiiuoO6My0DZHyzPv6@lr|5K$Gk<_;>%$^^*CU5O{;VkE)fEBDwH#-Xl^{3 z+lc18Y1`1bRoD84;snzXX==CG)J9+0>hgMT!RDFgazMEC@F1+jnvHdb6hV&Ky4%*B zkRDWlir~Le1mg^}=_g-;AYtrU<2;FNU~JHeZ8Wm!>q2Yc*G6{)>p9Yt<|MQI4LFoR zmcV#{GNopF9u1diUd`|S1!|b{y9lHbikDK{OM*l7oaPTMcl$5b-rC)H#%=g@QpTCe zO`b8k6I-VYps?aVMqByDbKO;|7!acPKplqwrgv#IF?ixF8Z{`@(13dHzPMG=`Pp z;Vt;fyxzEg9G~d8y)RDHPVVcB!9f#8;Xj`_w>W$UqOJu2flUPt)(*S=n`sVT=v;L{ zFpL>gJtC(JpM^t?J@Mv)Tfxq0jzT#sS{&Nr#YB8TSPtTpa^_8*i#%49EOPw~6)3{n z5sYymD>Et%H5wydu!vwhRA-_t@-cdHdsrtmIO0EZwAr`LC0O(G`&x(NMn;*rerTvX z$$0!FX%6;bSY19Tt#B+O6zC3Gj0d2>n0cHgS+N;X^j(77W*a&!ZWHtu%MgW0HMmko z6*B?kQXbY<#zm0l)u-ZWKhItNW+mDfjiqOCSuk&ICE8=a(| zhz@iOt`O2g>!5c-#qU#D2%So++d-;Q%4EPBnifQuBs_V+-DT!dL+`RluUQ-5EF)*W zXs?GMTf&qJE|DjO^HZo4n4e%$k-6vs?qj*(2Mj6x=GT}VAR=9f zzhAc75sLoL0w|Mz-Rwei0tS=lH$Vd^>pjY?? z(2RQ;ZVECv)Nyk^90VLO9Ge8&vI|99`bZ!e2Af(mNIEl|;IP0~#MhS{r z*xAvI)7urVtKlxu6pUNDdb`fAB;P%Q{EDrzf=~xpv9hG<6%NgZaLIv6vu;)^# z1zNIk3MYIysYKg+G8Dt%v`_a#h_ z+f`IA74;IMRw1fh#;T2JuBmQANsQlR?Xpc`0F%BmuQzE6?&DMq+UAlwdXPR(@5ErU z_Ezp)1YErNDIMNvN2?Bx&ITSi?LqkGd2Jw!&Pn!l0w`NR_5Vj8n+fAo!Z?dQhyl_v z^tS1X__|oa2s`e1<0OKgQe}_EDn=)l^n@U_8bUvNC5DwWC_N6!l?2!4yWigZI3hrFF-lt{=I6=c8eq?{89ZbE2q)_Th5X2!m&QF zAT50eTORB)$NKosWL;wG4~}whYfM2peCJX+L|{9E_;A>nxscA5DgTU}>~F;jH*?jb ziW)1o9TNKm=Mgz?TguV_l+r`J;s5s`)eLO0VmTh`YaD!voq(`6gp0Oj&?g3cHVN_p zo81X~xhVl&K_hQVP163T!@$j|+RVCC{1KC23%cuS_Q=d<=Ft{c(3YYfYAgd#!kh28 z5z@7B8#zyQ5lg!eC0UW_T>IcB3TF%xaGM37Q6bUhIccb6fU1Etn*MrV@iTu67Iz_z zj5UiF$dvgaeaCKva1(l>=KwDwdijC!7Mq|<=@ zOR5|qpWF%g6v;XXO+pnf`W?4l(Z9>G(YkRhs*Y{3$qg$g<*of`7km388p^53sqNxr z?@N9E{2z$bX{;+bAf^7J_uGMv{n@J6d`kTzO!yM_gFxIQH+msRc~JV*J*Y^g2cz?z z!}fO6od3&|hR8_SvEL@I3;C0rdjEZ^<~Oiq>ukN;9|JodW}*9KQ}mVE)+^wm5|5y`z(_xv3FT_w%lm4PC#6l0^$#+ z&t}ySrcYzvE~}xWU^J#%O(u1sA3z_AHeKqq#h(6fXqQV#@O`a}Bnhu}A$ zef&l*7yKT37Wg&y0e-PhQt_LEwIwG{XY2&=+mXPpK2f!CMxxdqg5UAR$FgModCB_U z_gheZPyH50WYuG|*?6;Adhj0`taMC8(9P3qIlf|!`q(}jv$Yfa-u}O7TY^3nf3rw$ zWc^V1?ed4>wK5BMURr|<#Ct!H7f}KyOEK}QX#y-%zN#oA-qi~l_(Dx|(W3W4qz|^=xrI@%bvk4@fRDnpNpw)r$Dkuh z9q_C96n;U=-hlvw`Ebif=E27v;E?_yv&>S}0h`k30ciM8TV@WhJek*5b%ENes091) zF`C|CM*QkmrXL4(il2Q{4DyKGhFEjn9(Esz25B12K$T!o^A0l%JTPZdTOJ|*YV&^! z`k7-0izqIPz{n*e0oF8d@!-Ip$|3Y)GnH{FRTfa{gjO!|<|#7`>S~qgoEbGd>{@*mSn2pg2EK zVPc$A8)W?yg&__EQ26<*rBUz;pe8FdD9)Y*vRfwX2NgZ0!FO79%T(!C5<$q3>#03h zIa0y3Id(eD_bcZCEFgiLw8W@_s0phapp%O|^g8Zg!9Td661#pSI4+R2=(iu@3+K)v zTpbWCld-m(>2OG`+Z@9pg@=c>iPw8ee6!_0f^F|dNE)<-MLS%}*R^UUIRa^H~67#$N~f!_oLY-Q!|y^%?2Fu?mii-IlH?h$hG z_@E!d*lZ;RXDF`cgAFdilSdESx}Edj2PG;tlW=03mnOn&r6>+M3m#(M0c>zZT-FXq z#i1?5L)Lk*DR6c8_H-w<2r4fswm<@L+zWXP>lS0lSBbt93u8)$MsGv|SBHzzF@Ba~ zEgZcH@9nW7xhdE9<4@aXN5Y#Mz1Oz#QS*mQKG#}IYRYFz62la-kQ`tgd4x%15#H7Q zJNu{h88Q=(U=BkS92^xK91t+vY{p2$wHwo65pBkL(+dwSbu`qph<=D$QDa^4L%S%v zsOw=Eh079Z#2(sZ{dq>TFmM>g-Rlum99mNdYYHW4NxkT&h459c8aOU;%~vo1r_H>C z@0I93CvHf|C%~(gF_E=-=?4uJ&?T+Ciu=XvV37JmI1phz+m2S zbfDt#YCZINPC%aK$6AnN!$<%zYP&%?!_?V`?CGxI5Z$LX0?NdI)H_P+U z97CR%GMFeG0&Wo72nNF%Dg3b5I$|Sf?Py?3*vx^hVh*3#mFy^VnOP_Lm2F@Y;cG^a z(mZkjI~67eQUN?O*=CDG@6O_I>f(!>(Jh3DEo;mPzuTM$QRO^O)@@bPmB6v0Tg5~P0OcR9&~p#>LBhAK$nsoY<2kHZ~N z{l|s26k-ir9Qup5W?cXc6dqjRF4l_n#Cm~#6g!(^PAlXKZG=B^acGyZCz|wGU5HZF ztW&d6y~&_bK^=vLe2vpgUW~>mGn_^)#X|;n5M_A5}4UI*yD8mZjAioe3(XSfts(`4o0gnxTwG`vbd_QJ;K~_0bqp zx8&~G-LJ!>xOZ?%JUAx4M6I`GVT0PsW0T#_eB?u{w`fw&IvGJ(0N1e4A$WWvP+jd8q4#MqE$50gT30RT-#f zjnNS`yW{Y<)FYYj?hmAcI{H%N!k-qk z<--bh$QHd|+uSp_wF+_+teHDd@3Ow~jB>AbZv%fo@hOc0LiP$>28qLQxSDLtch#aJ zz{Wap-p|G+1-P{B>IUl{3qEmZ|33)dEk77OLZ+a!Gp-rt7<1}N6qP_GDCI+zCxEWj z;gRiRkTN+rQDyULP29(w{f;i zQW-XVqusom@AWC~H)Ji4cUSlN8>`KVO1sasg{RuWlWk#-Eqtym?6ie5RT#u_b$3X( z6oB3!@69)`z2y6@R_{$I@1!9u6zepD&Jb-Yf=4&Z-CeWd7-~$ZM_;`Hq;tfcCAFqMIM18?$_ z+>lj*7vfb4xK{3Id9nMIR^TElaE2A=V+As-z@AdG)NTX_{rg8tyZ_A=-ee2EZwoI) z7y!MP^#TIX7^dxZ_{xfE&0j+>HQo;7Ah<{i5J>xZ5#OzG0+!pRJ#r4Bgyk&O)a13P zT$|hkl(YV;mRxvUlinB`QS%wQq9#T%Qu2TWnPqbwsk3}}7G6%Nll+snfdwVek9TxE z-f!4~IH~g$DNwq+T+7|@jdtrcJU>JF=XidB=a;Bwr?aPF zf2K!U9ETUyyE_{k#gT5ayphqf@L6%3Vm+WeOocYFz~W(RZTJ4gk}dE$V`viAAsle*sA*woiR^G6&aBVL>(L3 zwq$Tm=f*v~uxK1x*tn}(VV9=h?y-%#I~8_WgQ%h|4a+hUjRf~-jeEM8SvwVVS&pn- z)`gmufsIT!TEhh`vT;u*7D0C8gbv+7&c?li8;=bRH6Lmk(p0mT=yhqfAt)8gnSSiT zC?yPbw0gLznAb{J!{@mD;~x5b{d4M$|MZV+#J29q6Y8Jld2Rbg+4s0UG)Iz~T0$O1 zQe~dDcydO(=12gEb9w0UTRk%47!-T)^wKroN3kJbB9raiUz#Ea45{aJM^JA*SHbh#B^GgYby@Z z&g7yZ2(39=PlM^Lk`7!Dz*{R*#~<5P4p?+Q+ituCti=;;yRrX)w##$llAGG7>(RZ5 zNkP%)(G5FO?9HF3u_hhutnUulA(9_l~VCg%3Eb9==*C9xp+@h=9e* zOuooK!OLBENr*|sU)Lbbq@;)ZRRTNQRGD8)l3t4It8t~!_8HmlNu80A&ppo#82EP# zipR0KoEkb}QF?C1F%uIEU(nfe%L+P&9YjZBm zqyCO~JcYmUNu%Hjh@u^d9Xec80$Kz@QRLHhEz$+u zs|C;J@8Ujbfg^z#{pHS#$jDPpYlO3W-;1_1VBOvnTMwqxpE%q?ewOSn7hQ;T8u-Va>*dLgimL6QKG?#OcAw#RBXE@*n&up2A zswSsp1cC37vD$nWQe-0oWBU7^Y8=S$7c0wlqm-U2yw7X9QH&rC!7_N6#7gjD1QR1B zDSH_DzuZ3$xTSv{-<0g1pCIZ)`e!2Q`2T1BETJ=q>YqO$X!g&u5-a`l1cDv(j~ay3 z%O3_4%D1UugjrRw|dInl1RGt=SxyzqzMshs9>qK7Y7YA@-=iETcz5W550G5iJ(|qe;G3^bL z5B=w1>`_mi#VT0$z-hd^Ei&&tsO$r(GJ>nzaQjPtei}d@-QSacsB#-k-0L_X{O{}1 zB26pG3MIl{6e3LT>icBSZyv}&*^HvdmG43GVV$^AG?KOAvuPZYnc0Q;hbuR+QrwC) z<6Eo|GT&8TUiJy)2f)T{F+fSHn<(Qivo|f+;_wKwQQR_yVNI?TuM;>F1Ztcl#|Jzs z%2x;SST{Gj=AEl8?#=VX=lDA-%JvN$8RqY?O0uM>C>$|`uYWvtk~OG>NSm}rD1WH1 z^ae^(Dx>&4&wr|?Hm=pxAqAh&bfX<#D3FVXxD3SJN1nXt)A3tSbq~Y1!#=o#*&H~i z5MRKY?@A9pt%nyeUid?=ImYk<1I>UI!XxvML7V>te;1GF9sJOZ_1PW%8G2+o7KLBW zyAkqmU>bPh9N3_P%W)OmR-q8?7eeGP++ZJ>o^JALEK8DD?BsfFKDPqE02d-(-t?~c zEvU)_NiVeEYyAW`=85*i+DZw__$pR8f@Hr?h&dGeA@l@s;;yqmrJcS=xA(?JM#IaZ zx+(U7N}p1>QrG_ck)BpB*oMA|Jp;wh*fX7@y2;of&*r5hv+)65Qbw}UPqttlH#sSv zBU(==Xk2nXvI{5zEEl#g&+&IRhhc0W^?yVS^LLXd#ZtWQXtOVJO}ejO%e*p_8ssbt z9L@7zir~%8w8G$eH{NIY`!98&R&lm{uL7Y$nKxpWdqeBw%YE;5MdW*T;0MRjW9POX z-M8K7q6I}c{TEEm>4&|Oal?1Y*2$OShR5+Lc2GQvaB{GZ`Rt2l>~wY3CbTj1p*OUx zP|mdEW7i%+16wxPm<@CK0VC~^@nFx(Fh95gN2d7Y%uTi+j`nZ@0$F4014qvD<8*rf zusg=p?o``Jg)(Y=p*^veiXxX`^R<@A?B6chgB(KtxfO z&EELR;?QzcA0Y0lsuH-Poa7;%T>k5W>)e4OKbn3u_$zRvyy{A6#M}7y%;54DwZ)rN zGg4)}IT%o{9aL5=mDWe!g61XEi{Z;aAfn2a;4j&~rlr;wYVkJiONYqBRf5M{UYtcL zuG`7|lk8$`+-Jq1&%BMFr!xs#V;?8VOP{O)`52fVM@3g?i*sCs!3}PaFGczLw7P{z zFOJ-n<}3JY-dv>5b)^+@sQ2(VWcA?M*1ocBOc3=6c#&MoBxEWybt*I zNZ#}TO8-K*psKsjx6kl+^i09T7``*K3C)1Mp;g$c1A{?j1v~jd9VQVooVUksWoJ4= z^od>6CU;ZE6(y6rL)RDAeOdT6aCVS#^v$^g)R|t*J*+%_ULI#F;3BJ{;*kQ0LQ9Q+nk^|u7wCpd@y9yHx*5p+#RoZ@#DDhab3((aHq?LZOt zLH9(vp`(1ET~sOe!?^^WXbgUiV106hV2qF}i@0C_8m?&8QPV1{qfcpy!3`a+wOJn(M$47{_Dv$h_L;}*{b?~umg$X)T`A@4K4x|6baz~}}bj4{7psG3dS1WjSO94&*I|ei7t{;;?J$R1*}k$<3f~eaI0#V-mJ+ z*9~8*CeR;otW&VT?xG*sX*_m55s;ls9_7Z@Wzn-9(n`0eP`7#B74)5P>jiz!djMa9 z?fe#xM8uY0=e{4_^>Cl9v6omWtQcF2%gq|ylmjk(Xxkdq{Ez!dJNxqk`6FjssA`9E zWO(EUbItu**ng~sp4aAIh<-ro?~y9a{Q}Dsn2d0ZY-Aqh@sH-=I~{Xjy&3wU9=SCg zh`~SPJQhhJBOXjB5c-H#D9}m>l6wDV{KJHNk@NX4qQ_OmIJOyIVccoe$?=n?COxU{0EmA~FKG57eFpj-wk7Ue4{i2FD$;!LAmu&t(p_HFUBv?$iib3z zue}A$)$~iq@kEER{Y{29a$g$Gl*2NXi)IpijLxlF?uW|(v1-J&HtzUfF`;j?O7^## zczC`EJ}ULeF(K)4KN7QpYdJ8!_%?OBB%xo1`xd^{;DBpp2%~tlzQs_yg=^WGw7Rp| zFLm*`UCo`I{GebYbmE=SDRb=W0XOL5c)^7&E znM807?S%Pb=4E&tt;+O4nOoPP5nC}^ldTfCBEevV{s&(xqu?%b*EVA~p2oTOu`6gc z`u}!GhxG4nqyGWyY`3L9W7i$9=zjpT**n!nfAJAg^mkRw1?{`eI~&-|zh7v7P-wqN z(f%ihL;1;1Z9721Q%z%aze07|dF!gW^W_nFX+!plSsgB1o`;z9WKbZcp>5$K6Pv{&#rMRUJ zhv4wR@}wLu4&R3F1E1|n`^p>{z9Bm%L}b zExb<_QXiLZDv<*WNr>Ndymci8?vAtT;Z{w0APfoMqgwC6svfK z|6(ufN+RgcLRz6L?7X;NdK180m0^PF8`9!~O)b|~(1LTKar^_Vs4sNPYhe@j)y1Kt zZ6JM%F}@;afjz~6rf5NJP5=y(khzeJA&9f9B7Ja|@I;xCxXXu|f?;opP2l`mrU)L| z#}5SLgU;tr0vf<-F334c9}{N51ewu)TL^a_1(4H7v{R}eR)b|mY9r{UTRsPaK!)(j>My|n#Y4XE#y1oX*?>|= zG&xWo@{uocb=*7TYwwW16nEK;^0+SCJ0xD*1d9Zemza?Z$eQu40U&J0LR| z!@s8XSDUjCFNyhE))%zfaNe23^AgO<+k75e#Y#e-6oy*h0ggGX5W1RGXQcauuQdpN z9EGO%jdo)LluDjGK?c?je^mm=^Y3GpJktQ}uy#2a2ox$Ig-St;3q1?w=3D@)gny7R z65AB?Qe41HAWsQtfX~n&r}5<3qJfuF1HS+_x9A7xTZGebtV`Wqg-czK-I%6wj)sW! z<&03@Ups&HFw8C%TykH830nf#lt}vF5d+>Ap+YIiawkri4tX&Zs&_N`{GOa<9S7^0 zji=!0q=$bB_!SXFe-KJeCq*KrYbN^yN{w+F`il4aX?2+#erSx8hbyHF?t`%jY!~{| zI~>rpISouiSE??3STb{b9=)5bKC05q@%^@$T7)7T-(N!GA~$;I1ieUr$;xO^~KWR#b&V5QSoitOeH zhpiE3bEiIz(@7Z9CVeel!NDbxD00fSMGd%r&Bf>dw+!Yci;?nPxLhxV= z6HXIJW%PWzV@jF+$L*0xD6~o>;OjXrunABq9|C9hp*!I}J?Bsgecmt<^no}feeSPM z(1)c#pEWlt`tUVLpPx+@`ULq9`gm9n^m!85P5MBEeG#(8227bA;t^)62w3+ zkQn#;oW#HvW*(Kouur>;r8lX@SX+`D!AU}nT0Vpv!&wyMcnH~3*rfoD?(MM)rB2G& zG|tC1mT@+J&cF`_8P^|EDD@hR3-Po`XyfwHgvt`c(MKVGTB$bjO8NUjLjGQql)p_v zn`d$id8)x{^e|H8uZ(C6T4pj{i7EL@wn&w~w98ZeP9WWwSENQm`|?-njC9}fCnbO9 z90VQ-*~_}Y8Uzm4l#ChkgoxhNcF|h~(R(pPueu*m#P3BIY?MSHyZF7B;N(Uq!8 zAC_(s{Ybo>AI*{Ug#1mkFXJg{m%lQoB3Z!$O8%bAlT}Im>e|l}L&~Fu)PRQ*@`Xh) zpr)3#H=r&kkpXofA2OhJh1Gy6K=zaYWz;7I)C}fHPy+KGIFZ&EoN3DN*J z?vFg6)fG#gLRjXqx)p!uu&!G!7D?u&Sq;1d>n-lF!hiQ>--iz4^l@^>CpC1erC2|t zVJ@ouLqxoGVe#dcN=817S21cpe%5YbznPjzLu|CAnN+<-RxoXB=A!KK+eif*fv_#g zr0<`WzHjCzzzRz(#;)6szW+AcUkGcAixEegpGB$r<4(qQx@KG z8^mh&0e9c#Fdlu?x*H(50FwUMiNnpw-j)SV^eoux%*mGhJ9F6o$J(2~M_FC}{|OKY z2u@JIAfQ2`LR}hEDp9EkBrv0s8q`))s<ab|L>2NW}f9f_nv$1x#ygF?m6dXtvK|z zgvA-hOMAVLNi4Q}Ly%XumwJ4gP^V>V;MTE z{nd%}-nCai2~I2{c*?wgPayK0-pvwvYBfFgYMhgEO2WyB5ZxDwNhE+&lN;{ttad9YOy-fvw>55+Y+L-PA$L42I#6g?w$jrqQybZmwD&5V-o40L4%@e6*2YtB;D->X{a#_UmHsFyp1ju>DwH zd-lBd-05H;dzv5UDD+mG=F>-dY6n#Wqo??D&Ku`Ms1Hj};P^vbFtqVEr)jL_3Cpt` zzA^pi$guXzm03)<5>J#i8d!TxU*7y{H%A#8AXXHh-jW~Z3c;td6J$B@ztN&Th6}?n}C@FL%cI68($Kev2}< z%*kw5WRCG>`L)baEp%0Eq zGI)5emHDG8Y{GeL=Oi$5q?O+?Xa0wl{y!MMBYxHM_-(hv*#H0W+dh@?8`OFHHjN_v zW-rll?)bHx&G<#royKqa9i7JSSD))~{N|<^zr+16{qZ|iU-mqH5Barx;_;hHv_hBh z>oe;k$M5)0|5xMpQ&Qk|$Y<=oSq^5q7eAByO-((B-TK(M*zV*)z#3QbA#HmZgp4ow z0)-mKmnos*f!^~kAi+z%?XzEv$4RQTS2Q*0pzR!Grdxqi8~5Lm^G2*IGtu4*ZrndF z=S`8`jOKHWR&0&z*&1oxcdksu*i@aHROV3grEoA|ey%_CsS15Vdcz6?V0%UAPK7eC z_1wSy@CbDzHiaL*|J(L&7Nf&iZaK80@+`d;C-{0Wg`WMnQ7-A-;>T_ z&wKO=V=~H&oGvP0aBN*>cRihj64T^?Na}XzY<_83;H;5W_@C`$9c1o5v_X9Q-~zAD*UCdjknv-QNjcgi6ox063&zw;~Q@!dKYE46N$o8+i+3YR6+W6sIlpFr);QN zIKV_}rI6LvJZAI2)ssw*Sfd})BVvo7R`iHx*+%yD2{;)biQgzmhV zE6P1wIet$l{$q%T{0yPEHp+1Kc%91MuE~F`xu*QhxdqYkx9jdeXE8>@yhm+CB^K$M$2;g(to{k9_o;%7uYs5wU+aXJG3&Eh*bH&Z_=Fo4YRZ$Lhw89@ z4D=p5PjkuGY+w;@m?->>o2wsFzR%D{;4ekl>{?{xx$L}|_-p?G{Fzrf!T<2uuJEVlcY(jWJN$<@`1@wze?%Vv|G-Z0Kef2? z-0&&rp`UdJK4y!oPRMVB6rKIm^5UlonqLL}lRCqnUegu+FH~URIOAP-_*Ree~|u%Si&*?HY||j(lTEHyXS8TFe(Bo|nR{2hWYaPMOub$Q)wQYIP+?i>V9qw7GO5 zYNvAb+@O^bt&LX?Nw=^)b|w1$zZOCZ_<${0AYhWWmiY3id|Y~hmc+K@nE9+A4A#M0 zcp*>8;?HE4!dQZbJgl1Fo#S2VrO_D@H4V9!hhyKvh{-8ClJ>Awa$T%@vO+|`7HGKL zdDi%jB);DVt1Y6e=9iwRT_D1w2va=32XdrsdXWpAPqRC;RGE-8KC_JXjrp;o$O-{5 zLoLnn{&S(Dp9-HM2_9+UBR&)VTjKM-9pZl^F%)G=VL-55{KxG4V|2v7AD)-x9~H*G z_f`3IcNk9|J;!MCkNR=^Palc@Q8u7WSbmwnNsXMlz~&+50JwOq1oBE=RD>SgV^Lt$ zEB%?LSJ`e({89IA9@e#+;D`P_D2%5H%3h{_8%Q#k)4$lGUHi9gZkPTI>)yW?&bI!& zs2}U!z50m$y)~&z|H#&s8u_jHUHT_F`;QR3rqU1{pKy^?z;a`d_psG*1Vr=V9|RmL zlwfE-_rvaeK5A+(w7zv!TW{+1SJeQc9}XvOW8B_p5Qs(ImwXVDQ;Td}leo1A+C2&E3u6}+LsN*O0QCDspi6k76-6)kftTF@@UhD!lN+tdTtnmGNZKT>9eK!9Mw4d}hhjuuo=HI#V zvh)c|ntx;Jv-DYF^Y1p>GRN(%WByGpH~O5SA1D7}jy`KB8_d7d$oAVhMrX9I2d|bI z-IBTJF*!7hZTHSLHF(HhRJ43EsiYxU!4{wJpw($4`(A|`^wf~A&UGXk*P*!=qy{(2 z5hdK-dO@ns)NuLpp}W`dEj#!F4y%l}Zk*XneyV;AocrQ*&zryB9dl>dYEE8-PWP-Z zlzrRKQ}D&@plt89PAD5-AlM?^N7;LILYcW>lpsvQKr4ka2Vq0T8^VU_#}KwkpTznh zAFXTVe*x7#JFgSQqKTHso-GKRNT{mCXHxXrTYV|C+{&LEs`cI}$)(iv)i~B+zcH#t z29;Rs%PFw}VqfZy=yXhSaC-NFUh~6R0g?_coF89TBK@^--_^1Hjr(rVck}9x;1442 zamYRI$uj;lXG#gtSob8>w!F-+j?2S3E_++d#6{PoA)E9(cu50=#*LB>ZK`EC5*m9hR$j?(o{NcF;hJo(TQ zW`kL2`&LEvw;1WpN!PcRu?aT-r&A<2LVq)Yx`C5|NZ#?RuU?pC_*Kl1z47+FCya;G zm;~eAo&LdNZKiFpcnbK}?V7y_ckA73Hya--rlfb3-K=#t7jx5-o0*S4c@A&N;8}e} zFL^#|NKOLo_P)~$c6cMI{H-fvxgBE1A|l*1p1 z*|B7bIoNb&=A?^`8S?_3Vt%Mh;FlF0wHj|V)HKd7kEX6Ko4l;F5N2=>a7Ef%2|&3> ze%ZP0pXs+Bipxb)XGLv(8#Xbb7iUsMM!g$Zyw9NfU0QZnf4J@YCG8ET=|r~8Z|n4` zY{>h;L5~lR%}4Wk5phkTGtTOeoSYs@JcRMAVY3= z%)amhjku~;uor=>;x9+HXMRH!v7fJwyV`%~Pj@owh7)e$JGka+7OMvRAI-N3jsHzg z?BM@MKQ~O^bR@N+{&|;kM@)hvna^?axL$cpT!8}ew{r0zv>`U>^q&Rv*r$|iR9$R< zWREfxEV^+1aquN&0MNp3#W|GreuVlY{iTSI=5wTAVc9Z)Ol1RwEsZxzVC(kTdZ(W(eJ|NQzdm5a<(n7W(0P7_ z;;#ZU?2mA}gX8K?M||Wv`(pY2`caL`HMn{8$I;n^WTCydxIMmdV|*v)#}c}@DbrUU zg}%NL?~Oyksq@=2*C4lz$zz`aGd8=sGW`+a63qeE7k?;nT>md0!ygi7gMfBicGt}( zO}FB`%j@25U%8CwC0S>aHM3!L-dLaDm<)MHEJ={eBUw=~iCP%I$S ztnYcYkZ`p#h;0O~r!Z}Zlh|Kh;-j>={#ZU(NV=P7eme>ss!C=69HP)+w6z%}0@eay zZRsg{81Q4+Jd#5Faf&IJayBlkz1d*34P!d+_37dSi}(K#g(h_8*K~8k_Ag!7n{-kK zigX$s8_bujS_LbcKeVtp8v0X9WKAmsCHG;%V8Z#>vnvzpl?QF}4l@bwRp7>+S2$C9 z@lHj1MN%V*!>P;jX+*d6pJ#KEoYrj(RRoBz+DEc&q2tv$sh8oN`((M0NZy?v9z*sG zd2(C02RZ|>n~jWnUSv;;)z7ZLJMq`?p+1;jU*sz13G~}rwWhwVtX;@?Qx#3%x1}ZU zTmShPxoU?OugXJdx7GBN&0)IWL|ldB+d+08=N#hK*}C(L@Csp2X)(g1w(6)9{M18_ zr_Uuqa2ped160}+M!eDulKZaHoXx$-jxRo^1-~Evk>h)BkK_B5*8e}_`JiY z!vWwL>(ip7ALRSi2Dt<<*d2vb3&UR2^@&da(NyIL5CA?P$`;&-0Hm7H90V{jy5#wK zJn~yfiPJk0C!gkFt{EO>dh-YK*rFase3*@RJk!`^xHZ%uBxk6PgorsGv}25q$sOZQ zG{o}%n*nm1|MiSupKI}(#Trb!oksHu_$Bq^b-b))W@sT9>jw^9+LD(c#I-`NDnd&J z^IbDUWiN;EQakUqiOz<388y@-ui|i(F&CuHQ6#ToJ<%XG?@}@Cu@gWL*_??cUdaYE z`5W%M2p&b)slwCUDJ5^!jLJku?TV(pgcK#T%(WI7_18%JeP$u?vp;rOZAa~7l@J-V zSr61w&5}1FvfgaqTJRGp89U774M+|7;F??VGRIJaM{fN-BtDBr1A@ETxPxpCttnqw z7Z&has78sW@3T(8CYhMyyeqDxN2CX@LJl8zfh95UsU${C1&y%xuJZD>6K>?QzSh3S zr%BJbH;YC-n~0me{hyV*^&jzxie{7eE`D0$^u<+#%GMtW;BJoz^J%|lxl{0O?@P5P zygJl$2|eO!UQElwY4xRwK}>9{No=c0Y^X`3QNa^?5-)hkVyX|SZJeHa# zl)0RM-CiBj-ziG=`(EaFQC#L6_x`&2fzi~=d_7_UW+45Q%nwjW{2OWUhW|R6 zcs(=Fzjm<_QHEy+fGA(`L-zZN(g*ofH(L0$H7kMYoCP~8wB#2&frk3|(Vi*G+3S)a z%OONP0zu{+ve&LM5R` z9b%&t+QGfDFB?HH+6HmbLG1dIZly?eeFv@k8B*Fsek-+%c3 zTlhoYdpdInW2lJyrhmi=Q9aV12P-|3qMJXWm@GZoD9tmHTIP3ko~EIv8-I98{A&%5 zt{I-ln9ZHWW-C!p-p=F9kad^QG-j+RbI0(vI;Ou102^kV9y$aR>~ z7(b)zc9xXyS<+fkk`Ppy{Sx^;jj}WA$7IW%^hjx;RomkS8MS`B@(N_@2)@j4idM%% zB$Q8Dok*%G@q9o%m7(u&#>bC+iYzS+6*=;?#I?E+=(=IctPM?uIGC!$%W#0SG!35v zG@}Cb$R>Ua7J@=5lXx+j_-74)b(zC+USPDp{L(8S$&pQGl0H53i%u3b+o5tkit^XS zvdeafGQp1bmJG~YWY~@s3MS5T+D&2qMg>`ejBieJ&ge(2KP2ClXZ_p12^+H&$>KL# zxD1mWU9PPa%N{A+&9B1K-r-j)W3T<*TPnRvtV2dqarzxRmmAm?`^80!U&lhSK{MIO zDgC>{zwNTI>J#xZILyt6CN?LSI$Rwd+06&NwfC9%eo|Do_iF3;jg+Df8Cy`;!pag4593|qGU9DHRaX3 zD`*^6Shi=Y2`3I@ZlmnX*cAR=Uw;l2SW*hX8LC3Zl!IXaZC|U!`H(ZmJ8EG)IxRC+ z5S*+&FB9nbB*jwGo9N<)H2qOMPx%~Lh!G1AUP}Dyhk|P+PNSZ|Djd4*b!~IMoagD| zG$Rdq5V=<+fzC8;aG{a$2J`3tJs5b`8CZB6@|(qz25Rm}Mju>O$4<}#q#)hUD3jzo zbA_0JZp5Fi;{A2(FQ&c%20I?tK!3cM$%&DKx-Z#OX)G!dilQE6Yhpc>(fJeC*At!I z>8bG>zX`3n5(g?m-&vyu4A+Ul#!`guEK3n`jirQ>Ze|FNJM{3;M{H(kTNe~>;gPr4 zv5*$7Wx43SJ7gz@D7J8nJc!^7_y|O`x#P|3Ct3+?5XK%X1v`s)Kgw{7A}iq$`UI-0 zNdN0Vk9@+}S2i*JzNKQCRGDT#V-{B#r=K!+5csK%>F<=-)#)=R%;k0Ule7sjOWp;u zl_+DL@Yl$fQFc{rD4=E9r;S;P)345N4C%q?w(IsFg`juW5sd$d$3CX)2$3qI8D+F50c}%aK3ZKBb;Y{)`xICX-ZCsXp<>zpfXIiGgDx z$U*2t5L+Wb$(srB>L@wLtRQW{rhzknkg@(b6%kbGfB8ENF1C{U%usO;s~ZVkWbl>0 z%VDILr89?O@50lf0YevY^`s`DPx7e6X`G$tMJ(;Jk*Gx-J^76537Ua-tDV3>zMw3G zCk@j+9DKdRdt{e`Tth&rr%jn7bGMhW=v27vBc+W(1onh6d&0@zjs`{1RG%}W$%F=^ z2KTOT)?qUGL#Bb^026n~4>A<8HEX!I!g zluA~Qe>DaNcjVw_${C%#4?X^B-khN|sljK}q%I^6(!B;L?lmhjy{pG=YT8tPY-MVC zDY>s-Zs=>?PEL$H7#MY1f3*>!4BwQ1Z5)aT88_O*m>!|F3RRBPfd1j{~jmPcyRF0qm$_{$SA;-!B@D2T!&@aKVm< z-V6UH`uMLKhxuf1q3pS@q$cK1T-GN)lB%GQ#cDb8^y+*}x^~R~VA5SI(#ZUhO=M@? zpM88TBo5wi(mue9wh)7JEs)waUER^jhDLlesnKE>oLlNwQ?=^TzszG;Ev-)Y6P3E^ z2XU2ctB>9I+m3rmu_gB;L1z*l+DnArT~wwgnm}~&?~s6R#owGA$Um)*e*-X47?*gm zl;Rfq^;f5`o{iiq?cQ-xAjvd4^eMv(=i1dMdoA+QJMia&%H7(2N;vKggvpB?qf1qZ z|5Iq`B08<0NVNs+i=dZ_psCXM$JV+L(g7w1RsRoFdq1I8rT~w5*PF8|T*wHc8M^yz z_p#s^7JT%1eKebof|3I1RH>V5DJ@HLwEX!<=z@LtL+39Fna#=IPk&GAPqFaI`C1t??Aj(h%mz}m$@O7?+-d|7;DnP5vRdp`z; zYZug+ntHW_wxfI#lv@SeAQ5TLvD)i_rF!AT}0{m@X zsZr8f!6}7<4^~H7_maoIg`^r)r+?55a@3pIUtA>;E<<%tF!f#gwS(s-;Tu9qI3R_~ zX~}D#5hI>}k}@b9`^5jevquHTWd0Wa7ULqtBH$7c;%MniWm=b`coW|zdJanuuazD? zjrr+q|3Fn^MG#$Q4_ymTxfA>z%l1X#dH{=~PLjqPdNU&GYDyG5vibJ+a<@Tre& zfYI^t$B1)VWM&M$U}P**W)59lb-G5L&Bkrv^1G~83r`EDE@Q{z<+`03IE>S~sUskQ zFR1xj)x0*uo;R;T2^j+aD7IOgLA`+okoL(@QI>TcrEkX>=&qEpP7+fb=E%?(uv|#W z-(C1tfaFO2Zj-F+uaMeD$@9KrXUL=>2mfCEqNTduslVzuiiAf^_Ju_28%C+7R z2OJ#}{$VO4Uv#lGY1ANQeL<1hbfp#qj(-0`4}JOt^TY>Usb%jql3zN?L(;OIc`f`JP@@Nrm_SoN3R72RH;VC6l(@B^TTMPof`Jc&3?8j?# zTDA+vFb)>sVi&B~i5T=A8~Ej>!7> z5WgZu6aTY?w;9!hE=*#qBIVobNCmnzAejHDVu*h7grr6g!s_Y~7H5b)iJRM?DL&g# z55g^5hcA96tB$KaX&oQnX%p*x5ClY8)8_~Y)u~E}CUgqz;RE*!NM!-O_?u!CKFFu$ zfc)YlntN9XTg1)+xVwRRYWjKLqo#%79{PQcD*0vCN<`#BVh@!SQCZ?$rFtI!Zhha! zW>YFt@K`NBe(lF&0hpWvW|>+zpB943wD6xSD+Cs|1^pv?wms&QqsL4+viT>>o?;`{ zrLtEiN&=z(k^r|`ec1(Ka|E3yl)7C&$vo1@$!gCorTis!Le5Omea4Vjc>r3*D>Y+C z54pW=tWZBoQw;@Yt$N}sS~F?fTTIJB_$GM;Uv8`)K|qsYJk(`zA+CLw`9pItGUodW4-KwQV`bZp+^%Fh+4hm0+(#!d()*np zKqp@bFaO@#KU;nNnTg5>2YT+=RW)Wc&T%zk)~nCeHejX@s^hiNsZk4U=vabDGyHi4 zL$`XlKXg*61I>`~uIGSM=mzrr)E9c{zpD`rJ@1RFO!IGlUPon;I-1E9y88`9QNma> zg1gS)oGDhlg9P4YQ(~5(jGE$_Gc|??sxqK5RW+EwzA}T#8c?{golH`VW?S48YO3$4 zMdQC}7B57qaLs1f+>g$6^GEq>A7)h#s`H)-r0p+9Y6=`#!i zPioE^#3oqM;CD8^dR}TkuW%}YK5vom^Wm~Lv{hn$4liC={Q3x-sMw%orNKNZ3v2Ni z-#;ANAcp?XcUxq0X%V>@4vs^|DOFH1nq`~Umw4|$f5kot43Hi(t1OzD*pJQg{&h!J z!81y$6D?X%H@yaFYWj`F9V`7VH^S6$vgPmDjy6eFLfZ?f-26&qV&!HJv0E~1d*!ID zmF??Bt*Rc?rrb}HBP_C!q?P7&REawmrK*Q*svfnmx_s@Nqv}hfBOSqY{ZL&Esw542 zd`Euf)9#DRi3)2t)~|&W6qTFPu8Qr|v_zUqtXVD9iMDFoL3@pDkMGIX7$e!Mu;ig? z%nZHVu>3RGi6#|(rA#Rsa}`Zt!a|jPcF`duXI_JM)vGr z0ui}A_@0{bjj=ZA()$fH=^f}YY<^yGj%|Ma@hCPw5C1Aumnt~lJ-U}i#@`OyZI91z zkH4&v9*-PJGipUrUeREoPw$r9KH;K&qNnP)=+<)lcGH~P14o~eI_R?kjR%hbSsK+o z_UR6?tiYfg`qO4V`*}E2^@5#`5I=b40-WsTtk2SBI7^(EYB7-uyjdN@`Dj69E^&_c ziSx`4AZtC5_R^Ap^i>j$aN6vb~9#l zgju}Ug;JTayM0nUG5uFZs=qHcQa!mC0=)h%qsa%|qkejHF^`&iVzb`1w|t`1!YP+3 z7i)dwb49$64-O8+FM;Zai@W~e7J51OUCrpDnScy3XW6f;lCL7Rvh{Eg&ZDVHyeRw8 z<~jI>ujvrZQquQW)QE3#iQ?T6KTy!n*Emb&*L8iU_F;Td{RiJ;8wy`x9YDS*^EL4n z^Jt~wVV(3XzgFOplZq{_6So#;4vQu^JbC!UWz!EkD7;ExyW>%f6AS0oT_y0_`r&Z% zwp~wsR;D8z#nHO!_^KP%Ut2Y1L*_VTCm?}tR-JN=^9A7>_g_oAi~Ac0k0=Ya+yH?JYw7UGfW?w`OBnsd|M~^NmYRGp zN)5P9UZzj(JQFfW%cu^x4Y&d0QlGq(1}5ZDIbN@qu*HJ;U{z>oT!oUuI6#Wk9RBqv zgS+W;|2ZdzQ`7kBR(-YpNqsf=62|AHhKLnEd>L-pa;LwPgDYB;AUT|@gl+Im`L>3m zh>S#x7qxSCLTr09AJJ4Prt1PPB$Q4&Olx;|z&qX)yWHyRQ(S9le>%U92|eBz|H-KA zlOwqT%Et!l^)6gTIvnbiA8EJSoNGhFGICt}<}wPp{axFiGasWR>lRhWRd&y|Xy}Oz z>>JESy=Fa_ajQridtYV?9ARfO5Yn~z=jp^wb{ABm_9>6FV4XH65VINlVIk`|fL?uK9oN6@g{-1jqqDrhUS6ftK^XDOg5>mb_x=pte_HP= zy1ajY_fjnqn~=e0B;HG`k=g#!X1h6+_3?~sdtR+}ZfR>)4{dp;`!8qr(2zG&FKGoU znetn8YQrQ*D~v}HA`BNkb75bity&mCX_4b=QkM;j#19nLO-8#h%Z}mn6=V)3h4fD) zdlGnzy%>x;==c6CMiz{^)9Qjd$-)_o9lBAa)UA$`&5^`k@p+B7IIbXB_PWTZXGq-~ z9<`p0)0$Clgh%0?-X_Rq)QsBMtegfoc5VuNYZaH70y{+}cBIa^C$E7UYIfgt=7qk# zDpMFdiKebZY2HrPqoL}TF(gbRhKlYXV3|wN#LJ!Xu+$7&S2JouP5FVk{tUZyGgDb# z$Tb1^nKSvt+E>=OhIT*Ow|)COzPVDr;F<4`RlF)eM(~$qzZle9v*b-Op9sJ?eVST0 zy`X(1&*@RS%F8}Nl$pFm9PMtdOzh@!?>dwCE_+urd0vSdsWENH>uBPHhf(R9ipX1XH4ww$m>m6luU9-f8;Fx`jC_Pg^q@#8E;b^}hT- z41(C1Setng?Q!5~CZ(4aA(C60K1?J};e6Ac7C7mDcFRTR^uw<~&c38B(F`mzz67bV ze7^4|k9?-`%GrtVo}FNFMD&JDdF$`zV3Q4zwoJ#{EZ`K_<_dfeX?rWT0Aul*t6`T4 zG&eURxuavYM#sF3-DqA_`OdjRBWo&)!C&5TCba3N>B-=;I(2br{*vw0q3WGlN)#?x zm)*Huyf5#%XGgN@Y!f5Xmlv!!@JL)+m3S3Db9Qn#C#D)j?J*b;`NuSI#gD@Ai6#A@ zzr!f%zuRp@$2-p9NnD0*J+YYh&z6NadY*^SlOWp~TKWLhgp;SCVwPb)!L(QAj(0=C z@eKh=SB2wWDa>oQi9(H^EvvuKVu5+p4&9Q(UGe5~a2+Cv-B*gj?d0=^N$@zqojVa% z=VqivoEe{R@G}Zx{;@Z=x5BfB^GzgCSD5)aaUAxuLLn%*$-r z&uz`rN08vszc$Xjx+XcOCV44>YgHKAO=4-@CzaA~0*{?DiSVnP)Aj@^VSL}pkd6+tSJ4bFwswXY-sNjc)% z!QX7e=HU3Mew8bH9B$`?_v0!P&(wr|%>h+!9ycX*@{cRqUaL$H!u0C{k=D15s~VH8 zEPr{L`VCog2dsk=fg554dSmD4Rb#38k z7zqm&4buU9@5K(+P5lwNJS?$6@mhyE(hnszj9r&_F0nQ7uT1Z%#H#Xrb&Mb4qgQ*Y zG=?#lS=MJl(PZ9~Wz+LHWTF*y;vJGg7DqUC?lvNv+Wr}6unIgvgI$dV+gg?C)2|xk z6k`B>5^FUt<3HqYG+A31O^s}MZV7N z6@{oV?I^7yh@T+;{v1@&=FDdZmQT(u1co}MM_Ig;klz7^g|VnBT>{a3Ib#9o0J2xu zM}&epul&~sm>UG^suAyPt|_B!^MBZ7i+lbeHytWrCt`5??>l^*U8%4*BfaX^q*Ouw zE_iM3Og~!f7k4R|>EfaAgE@GrtP6*tFC%!a+SPCM7pI&9`;OAy|F)J4afl3#SS`b+WPe-}je+fc@2laCulV3?eWF zc-LcIK-EIQ4pv-ga)kCs=B|Hj9sOgyvM$u*(l1yav*CFrfn7}A>Lk6)$K$$}yg7^b zWC4;}SFp|^byFMSugm&CW;l4yUfVH$y?dAUhV%D^hrOp2T$CmCLT-Vf2YdO>&5=S_XN8$-apeE{y# zX~a9|?ufK@##~QW(&mC-6BhLz`4+j^XfMt_;}q zUd`75HH<&MIjqpT@ul2e;{X031Mhd!_3sBASTNqopkik)(;2rIQ8f~{^WLY>EClZnbzX9^RQ*_)W3$}VD4I0Qm>HW zZi1P?!W$pdmTAj=7hE{}$p6-_W16i%vKus5%dQQ@{|x@HVDt|ySz%Z0{TGyA)FS@a zl9`y*CN*T~_l3FrPJza#wV%uYY<;k#tLPOe-y6E)em-WYmHPFq#H|jlwRDdZIGrFw zc@4#+cUfLn+m(i9_OKyv|7c9_e|S&`;jtDtW#&a~1#J(TI0yk ztvJMZE!Hsm$>$j3v_{7*PYwUurS!OWiM_B??@R48rGX-Vt%CS0v$oD=5|Mxij5Bycn_!oK|{=qSs#vJ~SIuZPj z`~H80|H-~naX0)k>mBaBYmAU=OdQ_dl_QPe-Ft(}568JTYuiVlJpI3&5T0ZIIJdL? zL;L8)@>5^1#HFD-`%}Q2Zdske}hUQWH^ncjvw`%*>=R|iO&83f3BSK)AW}ppp+FTBzdmDh-1ut zfwoi`ihq{ZRm-LiK2?j-qazf|+L!J9Al^@0T{ZaBQ>2Y;vO|M@YVc$Estn!v53ZSX zkue)1@s`SP>MKui{FV}};#vSYG=D#%b^knVxXcdYne-rEh=fw(wv|FZ|M`xipV<*|`w^KY+5M^>HH=YBo~?U+83*>>^k&&OH;A=_whX zluB>kxw0py7BSyZ@iRKERgZ_eO7$Bo0;)4DRHd0Y0`Z?ex;bA`(F{ZXcJh4WCkE{c5=Pm;G59w9mb zY&{zaJsBTNAeh+?#)4zTSc5Npd9F8LAeB3QbNJUE(I8AnJNs?GzZA6B0(KQu(rUl= zmagPi{)5Zy_X+bKlx=s+)^PcAp}Q^Ju|G+JYEaft(NW;cZkj4Mj=pRDU4Eas^Bu=3 z%eTZv29s4$1`krdcPScL#|-tSHBkiCIPNKOUZlr9lnTr&-DIa|DN=MiT$>SLsnQLF7NL5bUNC#jg=_vwVid&M43w zQ@Qv+BY-aGYg%{a0%;U*GV@VJ8TglXc!RpBdu^r~AN#0YVfTdnp@YD%tT8zy#`lqG zPZ7V_2}ZLYw6mmKaxPD!smnPwd|O@A4A5U4R&b+aYYhnd4c>c@Zk@msWV9Wg?f{{mAhfd*$8*@ z{{VRXqk{q-Q5SS+dCJ;D^1_DGa`u&ffY+t{xFjZN0q?_m-`uo9>%T4B?6Mve$U4fRf&Ic^KR%4O@Ri(!ZwiCRYHg-dh zTmS@NsX=$VL3ctLlZVz!uK({BWcy#MMrKG?sR%v#LNkd*n^ps2ynTA8=}&?c{>Qwx zDN8{qOw$&(H}YnFAFN{|5_`Q_?6Zkf+{~6jgTQ5`&uGHcN72WAe}@E^d~rDaefR4a zE!6C?`4-k!`^8o2(n2ack_vS^*PXPYaa~BL&`Byg6a2Odm0xum;{*TDTX`Ob{8T@Q zwPUw8r+?pv{UwT~e=gvi?{c=`E7b69e#7#HoZhv>IVy2UchFR&=r`WJXzp2#gHgA2 zx_m3Xv+8aJlP^C(FW)(ess`j%l^JXW+~@k%d#fHM8n+y|`m_U!@pjyVeoYtR?R{en z@%F+P>HVM|Jzw%ibuD#~j0<&a8Ey_3<07?q|2V2sO#0F5W&c)N}5tHakx+HuV{I@4^wUpS#iRTm_X@6 z2C1!eCu-783TWf6#Z9C$9MhW z=FCYw75@8?6y7V(r(B#jgi*ZREJ$q2ybBxXg}Qm^`|{Mn2uLvH6&4ap(k--zy_-3w zI0U-9-`%1Ju>s|5o!8-bWb!pyI!U!9-U(3sB{jK(Cgs9bW!#Vw+q5*2M8+1CxtlLC zO`o*cTR%~={~AiOhxyHFhz+oA&8GXq(3JhDeCt9|A+424+O`h|fML<{wGHP@4*hZP zc{3}^_p=q78bNyW%kwjBHEjMpBj1eF8iZZlQIxqXSijCBByGuWc$_|uKjyZw#e3sT zAsnm!TI@4iH-7@ba>RPR0b@BvWq4o@g5`fZxk5VmqVwE*`O3UyDIh-(24yY#XWL_o zBuP%10TpIDINTGLOaeb^}ov;$N5t1 zg`G?ipaqA<_x6i@KT~Y{XYY(yD86@5{Z})EtZdDG-1XN?weA%TCSIa5M!aF`a(kX8 zwm8Sw==ygaLdNf(^`j%gm;QyC?iMqAv}k-={RxfxPE;!2V{z?Bj$8Edvuu+TH1b2t zF~<#z_3e_4`x`^?Bl)ViasTwt5>L#BE{E>cIe|JECYn0`pd84u$GP;1vX#{I{}&gT0QW8?6t3EgocpRzLSHNSs+<;Jls>0?@Bfm1ln0Ibuc{yLIBDp3n*NDB zxH`0C8~2YFx`)m7a878cOmL0+>*tPa+#ib#ApUiKeXKMs!S}efeED8m|Bd?_Vpp2{ z;H;a_5-pwqp}y~ORhJpgNA-ov858m&AEwiA`kI+N(+ii5@{No7f#~*|997a zemeL6@k3pEirs14Ka&nf5CFhG?7_`EuoT)YX`Oo4xPJ~02D%a}`Jw6uUDZG6RyFUM z+`A>+-*McHj7Qm#<)EGcg?7a6dsqh{Q*()$u5>t6_+5|8EUW7GQnP-GKcw zKb?UE()T+ct&H#N1*qu#;D1qnpa4t`HV^=dT@`n9tD=J&qyH9r-?j+afb&Xl6sMQK z%*_ZQ{?jnY=RL*xaD1`#ad6i6Gf!@*TLGt8{MhF z%y&AhE#0qVe_8AN=RU>cGe8!t`jqNI1&X}cHG8n*UDAGSGQtwf&2`YuMFKW1=iIp zdrpf=BnAKz$XZ=hS~Sqx9_msaXTdl{A6fe&4@e0}JSw^_7l+t5izcKQ_**uv+eap;G5H~yGz zR4M;6>&$O>kS&>5pT5!xjQiIXBj|tgBZAKM7LW|S#ZPNcp_wd#8o6iv0DcBjMbG$| z?yWe#XZ*+s_e?$tj06lc+QqCaX8U`Kd;StHejPP>3B#wkFj2zvJgsgR`?@TKI>zta z&>c5He5i^Yn95>5)u+Grn5i5%2Ue1KvmPp`pVh58f>%R#jQq%I4!;J1Or76LHn3T! z(e)!uKQXnW&~56FR0JuGD|2gRpw75Km!d3JMt(~`XD&g;%Ch6GEEjhwIoU^zHzqwP zu))}3t4Bi!QW%8CJWs~$gOS96ti^9zBsE|VskM#2%Q_tlaTW;Z56Cz^lI>dZZvZSf zKI1}?u#l34GeTScc`jyAB8wx0PvT0Yt%_7ZzX3+&6XSlu9yjMX?jGk*s=l~%qSB7o zJg3H5QW}%2YFyn5Mt?DWK8F6rg*WY##*BTMQJwEE`>0+GfQ)vS}XlQa%2N zP}5ahh|1ViaRyr3)9c9oxCPC$3J;NE-xGtm*FrBF&*~p)`atB4g>=cky9`vQNdccS zmrhfi+Dw?x$e;O#$iJrkdQsDC3=48noEItIHfMn9eUK8^_a^}gsBN-)c1D6_%Bud( zzPSAkF$=2BjtbisWC;bEeCAqPR&_*s#^%6mk-$87x?dsr>912aa=%xKQ5j_1w;aV_ z;Q0_4j5Ia9bfWQ(%EkjHhL&(zS$n3MQF`_-HcHR&^U`m4qd3oTj7ZIl3|PI5Cpn%_1P|JHT&_zedVgN#E5%tW(o&Z2;K;7jT>n}7l| zmdmJ8gYgi*+R?8&_hM4^MdtKWct?ES6%8XN{D4a4A2#8a{BWX)(|7}&J6I)} z`n`|5RSUJ386NYFt%JlAB_GfE4t4#js< zxjYBruODRmbUyb|yg2icXZ)^w^;}Nyd>&7t1EHnA*R#Qom#>_2DxK<;hm%oq;G_Sv zPW_CZ6l}(vV%FjfI4lRa0A9C0EI7-$z}eF9IqV1nnBWz8*b=tpK+2R|llgPFeD#9E z>V{Ef&P-fd?`>t}v@ZTmzWFFw|MBE@`BA(F{$_(pf(5VHF84Coyd`$ITbEzyxV(i+ z3hL>#_H-Zi_3rS2$KJxDUJ9sHGBa=$_mKYpWWndx8i_vqsjJmpU-k+7reM z7dLOuBH$V>&7EVbH_a}sKuyQx#E!COa`}<|iBcW1Yk*`J1LOIH^*4rfvUmAK#r0Q7 z-mzX(6kQTG;XLoPbM~}jxo6ViVT;#skuFB#(agnp#olW7dQ9-NM245LaQWntnDjOj zjms$fxzRK6uUx&ST?^}OtB9Qh=61~J^hNN2ZnM|zKQx@?!(Iq?7~5jWm3D`IJBaLK z&30r%{OLk1R@Qo_(oY()J9vfo@9jY|nMZo4-rwK2u~!y96~aYrQU~g6AN!t8Mlp)S zokd$IM=zUR$__5EFRVIB$bTK*S-{oF@%{O+0;z1cU99!)yjESK5J)>&vT~&MSB{pL zEt6G|4^7>vHTe}`57*5@&hndeQq z#aWz3GD7Gx1j`x^$_(|=cmmji@R+sX2^AAVd7~jYihum|UUL=@iO70=UBU$` z8rsqgz(KF;%jorv{5fN)5-TfP_x7${(h?h~aad3G4I(63c2_#epxJ^aftmCepx%pJ z;}40_-U#Sq5#8=GHt9h$g4z8TT}<~zEdLKbyF;zLAkJW)&U@t%H%f&c7k}Gud?3YE zP>t#-Zr^}i)aZLS;5k8LOCv8C)S7u(^zQ7B-=$D6|5F#`TR6>eHtB87bEffG0qvYm ze}tgXNc1w&^7X1KX`+FaKDOv|W80Upb@MriX0kT1t@S`};5lQ@O4;!0PfpF*8-I>v zb}LjB`t4ZeDWmb1aH_J;*zK-{Ki?eG;Oa5hW##oY{NBe3?H92>dp14pY2y0NT>pO7 z(ZA8*RJcq=;qq`Eq@yio9Fhs7XGj3i>#>7Q6yn z%WJc6)dX;5mO2FYd}>R_fPCD0vp=2uQT$thVr#vajv4IW+}_i_^%0c$Q%7SxTv`1e zH9rn0b%bveMI?APW-HFlkA`6Zev^eu*3}nyCw87wqKqQ%wBSSOx<#4Q4j4y&yE^DE zY@UweG5&;5;}BQIgqQ}m_L0lFSeOYA$PATPbHbYklMo3ZTkTOnU-4QK$-LGD=^0Ew z3Si0=OEi_JFjvGA#0PHN(&u-ttmgbwEopdqO>&g_a27V_*cWHgYgM! zJ6^SQW`+gcAZ(s)q`gCaeXu?Aw3;cg1~ys)>w9Rxjo)1z;|Jnkd?wp&RGT14t_02d>oC|=#2NO1ZNVa zRa+Qd!&^4cC%l~poD#;f3%#mm53-GLx(;~NOGJ4+Uy1_)qxU*H7dYa>IN)_q0nfcT zDu&*otx#dPEIXh|8A2oqo)M{HI4R3Nci=(|I+VT zn)LRaNXJIY^)JGN=+r-f3f-c~3P0f_vk913>97hSGqBRhImqp;zy*W~Ehfgw@4P6S z>VvnQa=Q~>|I3Pr1~7evm!6-dLMg)ArY)e;)u$(He3lZX$SY%SLx9?M>V7T z9K{(F?Xfe%Yx*1|G{z?++liHl4FUm2A)eJg0;WX>YbdKC==54-yP6GngM54D1hXdi zEly{G$zQ~<-_eJd`mmK8&vd^Kcu(&U{$+}0W;B+&R&d#f_f>mrGxYj#MopyJGF6=RJ zICMK=r}Dh4*m>dSJ`kC&cA29&{+rn(Iez?oRp^B$N*fKO&J!JOH-#Mj_{H$hF2cI- z?wdwK%`8Du1E1a3mY1`BXyJT!SW~Lt4?OpF{|g3!eNt10KF;R)yFAx5c1v?-Y$|P} zMm3c0jiTDXN=9~qaCv26=uYh<=!0q5{5YFJOYY?xYz;+!e4d|?`TCKyui))Rxx$%m zsx2|HroF=ZX6AXlC9M+!|3;DcgmE8;s*dn}#a4490Y@MB2+t#l^P&HOhgFMjty3@+ zL^Ca%7adEkAcM=xey9vVqryaji8#Z^YP>>b;}`s|%Ov}0O4jD0J8zG3%udESq| ztj;L~0NW=^W!hJvSsGwWhcaP$i;oJ5VA;_Vxk%hO2c9DU$kI4Z>_UNT%)MC_Tq2hx zXg=&liq9JLnF$%ng!Sc&94A2cb^b;*-Sdadh^OvfdM7+{(1o;;|Cq~WZ^$Zym(^~i zJNyi#5=?to9pNf{ceh|qqyJAPf4=tbto&JuLG+W$pN8T7{9;NMBu|->=bbPPh~lhc zn^$>{tFA3wrbYJF@yAC%V|I?h8(`%UPO!z~?4r~;rxB=I(p6GG;_*WvBaz^A z4&Mt~QbR4c(6w6&doVZ!_7ipzF!sgq7ireO>U$WnSfTga&-{_lpaMM4(ns|q7P|ER z{f_>RSHh9CCJ|n6-F_j|^k?3;ugA*Vx|6l{?r6W2G%XvI)&;U7pe>U{pc1)I+dhii zyL&@RzpIXmx3#{}C!FkaBp{u|0FCQ^0oWkNDY6UsDV7g`RLf4)W@P8a$tT)Vx5? zLra%uQNwP3vJa8y(@z666W*>7YWDVknwX*H(~opQjUMKrhWi}UbYPb)r1*r>_6kV@ zF$SDg=q+UjI+8dWUVoY|RPp8Xb`Np=cewostnKy+)@HGG*-rwjZOmdVOJ2Ty^tj8H4$ikZ7D-%g(*YJa2=d@#Wmf#z`ZK%a^j9qqTk}wFEA+xEKhRcMF&6Vt)^43l%3jBTe1WH0&2NocUp(pMMpE z`E7uHRB~#?!wu~&GbmeushUz%X$=ID?ZF0#X3t~|i&3u9jSunVC#hrO!3|(aH*YxN zpv<)<`%5%%%!ZwZA5?tMFLLV-;0`o!^!Lku=%Xn;wI@bv_zB`;3zwJB5pUTHK8ef9 z%J;+hKC`uB!gRT^?@#jkUhJ!0t+hq%D@lpU*}5$Q#L&F@js=jhvOoX8hbr@AmkPVw zTK(PD|I>55lmc?f?lu73`^!l16fGOdH=L9T<%1YnK*qh z_`l@0U(yWg?QG!IQ5SAHVkEghM^!-l#m$<5Ei^o}D5d?37Mz;+8ylW@K@SI~1`mb8 z28ulxdK(-p3WPWG&J5saw(QqkaGHB7_(DrN(XYtXIDk4{w0I>gS3t5O7Vp>9d@_+0 z>>3ZMO1LHdsM6s|w(t=c$nlL4lko>0|5DSU^~f1!tz7t;cUh~=|4Z`T-!(qHC#KD@d1*{4BOKm%G} zx4z2ce@TiI-mEWaH?Z}eB|87|P71Q%90CJbI6&*m@^@p`aNy-3{NHQIdyABZ1Wg0) z*!>(+%Se?G7<*??=2$>r^ifepI2vWnU4^BW9f=X7kb#?&q5ti0r5M21(zZ^!`&rg$ z-#!P3Qw5vcqucdpseAO4do)dt>UaeCGAO3cdA);v8v9KTW*~FvD!4ZK5A@%n@S0T` za8LS+Ax-h6RO$WUy8+go3%+!}_Wdov{FUyvMP?7|zpd#K_&3Z_k*zHBscECsy+hgJ zfQP?eU}6|8^p=~++w5;-KV8Ry&{2Z>n=07i88W{14Bfoz?4X<8r~sz)+z;s-AiDXZ zgnR~LvS9ebTCEKn!Oz%D@aH3>3NWgyS0@$QFNZmCM)$~Ya>T}_-th_LZ%gsPwYjdy zyL*KM=joXZ;bg(@9L*cfq5TZJh@bd`yX@Pe zz2ogGOacWb@jN1JC0UT?F3|~w4B-;hcEW#tMjdMkcJiZtm>D-baF76ntej4Ui%1?a zaB(YdD_Dwt-}aglYXiHp!|$8C^=Y6?1XH2G4U5y%n%fNs!e?_OLBT}}E^W$h>W$*f zajOl8+0Wpz6MNOnM~$D&tG^|je4vrhVu|A0=NMZ=E6W{K3-hg&f`y`L>s9<_GC#G2 zO_`ri3EJUOwjt8pYKiq>-#PoIg;ZWe8DL1&u8weZKz>sTs_x88DLHNn!&$-aH z5917hHCvTpUUmi1in%$as9synA0^h$Xs3J&=&VN6lo2eOP^~io9bUq!vq9hpSpN`Qy?? z?p@tFb#Gd8P4e92#6Fm3hj4y?+@*HWZe`=SM8WRhs`*LCNm|LALXs(H@3w$@fWX7) ztycwxHU44k=C;TF8_P?+eTCCm%_$80S$e~7(@;~dNPN}%kpxZ`TO*18aFRLU?E5M> zWIH5l}(@*9#*0)Tdauk_cYO{mMl8Y#u#HlPi*U=IQ`BCShzn#@W)iOkw^Mj*2~=Av0E z9M91-x05z3(WiHw#Slx5(=n#D^#nE|avg1Hla&aQqj}glf<7*1ZPJ~sWS=kQM0Aj$|_ z5-n*%J3?KSOx|mDhm+q{O@VDRIO>6M!gpF;wdh7nJFyDyUaclIm)_=1Q>p2C-wZrU zNHbY7L!<60zJGV8ik-Knx$C^>MTkaKmf(c~rb1s&lUBi=6;{lqJeFot3d9EkApNX7 zv(j?u@(VT78z+B;Q`WR#y_vpj^|A$JCo5}iShi0_NCK?JBc=Nuvs;7_o=_Aj3 zSu@W!BvDdU{Skqt?N^Tu)MEYxE4mi$3is@Ad|?qvML78wzIEmknJ%^q>8EnVR&*Dl zw<6TU{u8VRoc6C(UIk}HZw)WZZ716{mOq)^nf1~bmwydP6?lsODM{*7_BW0^^MhtU)V$(Y2s(A8! zJktP(0>a7rRe^Za4*TUqZ~Juwp;M+rAX*=+C^BwWj~sM$WUkV1!R8T*cn-M@qX#MN z)#izMr8rVxhOQ{ZNrob#d`D!oFG$15{?5;4h8&GQD@inqeW4a!IcX;qFaVA!!n!dC zArA3#W>l}|Z=iqP_VC{J)p_}94JIBgicj!fkuegtc6Y3mbU<|`Gs3&Tw%OfdQji93 zl!r8&z*mxzyH$Cjwj`RU9j!WNGk_ek#2X)P%~oKIq$SjaG?GSV55dnyUV7Th&P7Xk z`v>irK}`5nLg9ldasrQXCRi8Tn72k2EwrIMvlhOCm6QK*o3Wz!qYG?&wx0~rQw4+F z(*->B*7B&?>-A91me?$Z=WI1SFrN-(!8`Hpp4m``ijZzP;M4+JUwpFtv#DFfhGnVq zCa30zkyPJeE@Mu;2MP?V36Kq^wt3}^TaqB!4eZqj;|!pjkhATrj2I52sUJc zS-v)QnK&=cu`yFJRj|MDOL^WmChu*JPx#f#q8y9PP(_);p|1nBb?tUCp&5Nlg<2CS z(>1vfAADevWftA9a5lO!(W)SoEjTrR#VTS%HjK4i zKPzqK3MC7phBCENqH3W@nvLjqhAq}O`fI4^VSweV?)TA@k(TJ`PEF@vGY&QgMMu4W zvaWRURYF^dvp>_1vSzw}U=iK_X0^Ki>zCAhwqV#>OkV;k)BHa`zBqe=lY{xB(7)7x zjRtRO@NN#M0d5vSwkfC1p7*{w%Y@dV3sa(3ZV!Yu*ZWk#^)DI;@BTf+I{Z@~A`Cm| z(Ue#3p5(_7rRlBd^_}*3#Utm@6(=Ic5=`fdNa-?8M2b0xK`P0hQnN|9k%$~`_m7m8 z@#|(N1Xf}XpC}#8FEiLVD2Tx^>gQJ^$75xKDu#Kbg;d6Lw@Qs1VW5y=s>!N=`!N7B zu$OXLdkbMd&04a$!V8NYuK=X1aq_7>&8{^EXnFM1ONYI-9r_{77C1{`4Nz4;8rS4P3 zkmc_-IYB$C15$TNujqedW!ZXd+!A z8XIaQ;d zC~*=gnsPE!sM^bOQA)mgT|?|CGCb7uV-wv!Hqjz9iM~je%_zD9k~NAVD`$AXUf_oG z317DFNLTVwOF%z3mMR<-nu+EvD=zKrL0V@*?^<(1p7-aOUQgPF^tW;D%$vzP{ zQnB1N<=qm;mx_9mD-|^bI;5g6?+}a=BpB5n0s?5qq#~riLPj0cFa&eJJAFUHC=rNg z_fFW0NIcAmMBNYNUL{>SO{ITmhY;6P1C5wp0LNps+)B1-c8@o7IytqL9^T1K!FL! zPb*AyDogR|y7WwBKroiBO5f<<#xN}gBn?K5ajZ%Shop=~ujtaoht(ZUyc+xChGbWcF1V?BU6I?qxz2VnI@$KQr9qP<#Z%GJ&ZYIWrwHvoUEt$C@I6UeXVY- z7up~`<986QrFW@uTn*&k82 zNYvnws+d%+ zO5A#ZEi3b4-RDJUm}Z$u9nISEL=5^-pZ+*IjMv5ZkMDMrK#P_9f9Yry7@yNLxh8Om z&{lziqz7*6eREOn*!YBn%^LlWjmVF;PalB_)`kC>UM({NU4)K|2|7%FMwo{4WHCK0 zWgR|6JqoMwX~Hul%+Se~(g$Wcj7RZVPyfuHIkmRHy!1&FvNOhK6*8EY%oLSvka)9J zn;hk2YdK=)erbEoJh15zE1j(aUEI_lQ-oBoaAGznG<)e~*oPIrK#UfsmW8v~d*+`) zw{HD1;QYMoNW;H4F07CprbrNCnABr8^@F)6Pb!ON8PTeRTK*WLBhR~TZ!_2<)9XFThF_WCfZkEG;Koh-? z`lZ8GWRFn~^#lZ5TG$*?{zGs3Tdu=^#zNV9#%^5^9iZ|dgUin!jKP?#o>iSHu8n4C4$@j>|)r&$4xx zesQBu`=AqEa)e^x%!*-_1#Mx=$(M2dm-prW(KyHO_*4PKLkOz`5f{}H-s*=F4`v`r zv?KP|3<$^jc3#gB!2bB$o{PWqO{l_I;J7gOzSsr6NxAR=TXLG<^EM_7I5t{re5d9B zhtUH2N%{H3!qFits}WQdtzMiv%HHQX0h75Sz@KKJi<<5_2A>GOH9q`Bq%s;YV^XLPzoU!cSFA3zRZxyV4Dgg$q>_s6Y5<+{6L0Km(TI?veDjD zO7q{Y!@@ZBzx!ikV`wd{v)%_%C9N+Kz zey)r3v(;UvPMtb+>QvP!m|bUSKi@78J;_b-*r~*iLR-STn-kV|V|%&dH(1na?NLbo z*sEtac^F)1$|>|GYk`6up#BK!f%@9QqzeBk{!qiHl=U^t|F!(|oBv1UClOypl%I9e zon`;u$&b+gf7AZ@{g?LFsSa@s+TZ`*^2_pB^Jikmmu}-+bAI7~iBTI;K{!_Voj!s7 z4|0T#3uCDGMRR6H=@3G(QTWWBnTPs`!tSJ(ANl|bxOP_3u(s@+C$tHkrYwvE!0zrp z5g%R;s6hOqTkegLFv50U15h=O01s<`#t{G>aR7`C0h}DEDOf51ZVj+$Nka-oH~`v& z0M;3Rn*<)Y&Cc}w)41h-f{;2^jj{vZ#Z%y1FjuP{8g!vN$9zPyl9VfFB-h$b;Dqfc_zXuMsm)c<|jE7U2pFuqpyTe+R(22MrHi zG5{Y4!0|1L2lqt)IGy3(LAl|$E4|ct4cyO}; zSSl2}sR1sE0I;{$^-UQq7RC|^F(kP%ZHD8mhkeQ=m&L{|a0NCP|{0pL;x zK+6!oQwG4EMNU?4QjEAI0>F2dhZ*s~JBAVC48R)#uu=nbjR5eP17L9opuGW@CIGh! zfYz^vFqd3kGu-Y#85TmRa%)Cp2ufF?P`^GE0pS7%Lg7DA5Yf<&7=)gJ@Og#e#JC6m zU-k)eVmkrgA&9a^7=ZU?l9f+ufc6mpo_7E|90G_p0E-0R1`V(e^WF8CaEk+AcnIKq zmuA8k0qCp&o`?X@)dA2l1mHIS9R=V}x#Gdt2mptBhk0=KG}Eqz8Gs`Xk_Ug$0Bs@w zJmUaZw9zoJnE|L2fa^5Co<$9LaH9htHv~{QRP*2w0Z7&Wk46CK;s9tB0$5-Gt`UGw z-UScneS~K;c)sm3IBIt*pJJOU1|MCT-pRG>6X0P>z}D=OcVO+hm)eem??2 zh7D_drR=j`yVtSL7F-7V?0IFMO`t<2Y@c2DKG+nCSFpG8@tJ*Sh%W3~50Kp#lU4}* z3z+S$FEMHO-q>fi(yKp- zP%dW}LpApAQ$%!$kp9U~3GHG=RA5de@J0pJA(z_=YC zfpu!PG5}o!;6@GbiLW6iCOQBF6=fJ5621&a*8 zD+2K8MpcBXBLEyp3-jQn{}?U~Hvm%wV3`I;iU6>}0njm2gyseyQvk+mfV~SF^57;1 zz=mHzfk?ylL7E3q0?n?@$?-=KIfDgwa2E)DbGmTJR; zp$1^F0Q^}4Bt!sM?f{4i6`_d%xLN?N(EuMVXvl*J4uB4opg;uay@8qsoduw+23Q;c zprZre^i&8^8wyg10XSMj9(?q+;z4c%fCD|lJox9whKYj=z{>*gxCUq$0br>EpzwB3 zfCb&yA87#Y7l6?kVCVdXJh;{YkR76+B3ttyLjV#rz{3#$+BpD5(V(DaRQB0SgL0~n zjM%weF(M}d%I-_TjOc#~C?bx14M2qeJgfm4M*w)l0q|uTFam*QqU@7dx*Q7yz^wr` zl{RF=2nRsQN2V&)8Gw-j5T^m=MF5C*0Q|Ps08BRk?F3-kI`Y7bek($eusEZe z(hbV~0&;R5QDpp!$>{oBRjC6Z@hi|F8v6UIG$)=GgsX%OjDI5l{ z0JjOinYF4ir$+#2>;RZvV=D6=1JFYN{;2^jj{vag;xH4g{ zkO%V|0EZKeGz72IJa}6G`e}gG5dg9r08e)Y08gZ_Up4^q1mM&f#e;$f0JRr|i?E3X zgXoq!41h}j)@y)X5dhwC0Q5a!nApt#SOPFZ1N`t%Lmtd_0DSrYih#Wn*k3(B^I+fo zWa1SXU{wTw{tkeBM@=ofWB~pu0LTBKcyM0?fYaT>JXjtAxXl3EDggh`06ilByzKzE z^0?tassXrI017q0x0pn(-xeNl0K|p>jxxk5{c=A}ArCIo0Ix;>$Z!BWYZ*a$&H$_z zfFD;Y9^4fH;6%4D55D~nMUZatW&=r5iy{E5aRA)-g{}oX{xv8A1?4V{@+D@# z>oa1C1EnLKAtH_k`)Nir6M%~}!1ECRE_DEG{@GN;QwCu7edJ{I-xVWni2(53g<(c) zy#$<$r#Ox?0Dl&Ml^URH1c28Z0PYY4?G3<<0&u$knDH;BuIn@6b_Yt)TPR0kl2O%H zGa^M$x)MdkzY!2Fa3FNu1q7+lM-0MO_mUHzzoj@aE&{-pe+qMA?N#6ewsc_pYXDvo zfTuM;`v?HfI{-!>1_h$w;|)Ne0NkJf_RVR?gj*Z{w|-!X@P4LdLO%iMtO1^g0MOL| z&^-j;Hvo+U;Lw|j2V)}u9KImTgOVRXf%Nyo48Zn#$i%;BfHn~To^b#ybAyQqWMVS| zP$mG^X@EVLNUkpkH#z{eMgc$u0hJk=2iFQfvIclG0zelBK-?Sv$cS!%0XRnhK3S!B zkQV{q)6_5zPA>pJI~HMx0r>abFmup5mEGR8BN=XEi z1P6+@8R}BZ&j$^_C;`~;_m4Pb<5 z_?kYt2%q0cMz}OU1!lJEGa}aka5D$BqSw|MfR_ZIsQ_sGIx_-FQwPf9zX3&>)%^x# zvY=GF21Zc7W=24GuWOhS`(6ctXy{7~LQg@MO9TLL{=0rbN*n;A-Zq^0uD9mIFL#g= zS89N@5da1`0B+#8P&o0L0oW)2zrCs`m=*z`kptkP^@f7G4S-hwHfn%A5dbPu!aOMb z7676iFE#+f1Yo8H_!;xp^?6Y20PutW{&Sh;L81Wk)c}8w0C1H9;GtEZK-$&c48Z=$ zWa7zJ6c46G0624QxCrNLGfbRp0G<(mbs8W&0>D2V07thPfC~-4BmtPN0ghp+xIPbN zIRNs$F--ibm*&AG0&uwocq0NpKLsY%gc%f_eKCXbxxQEk8o5g zjp0@Uut5M;Yk*540IYWa%nng-z5#eh017m~H;Ch2p9eD>0Kdc-z4S%8=7C!PdTD@H zA^=?B0B97V;8_EZAOJu7P4VE)2mr^sgn4l2d{98UPwCeQ24&AAa`F|8k{SVJl>?;% z?Qj{7bu<7^3Ba8i;3)Qt)Mvzf4uJ9w0FXiLfi%sCd;#dL0iKHh(9;2sV#;AJH2@b1 zfW1;N;^qhd-*yf&;$#*m5R2tn1MuB# zn8%^5G>cpV5F-G8)d1}x06gaaSo0D9q>E^20CwI=R$i|GJ}zj;gPR=ym(lAbEqiBA z&4b4Tppynz5&k2VYV=7!v{D^NwL2%;(5dc;GewDFX162521t z;AsayYkGjCMZ_6^uP2fR<1|3k)P_8`!2$4T3j?t263v6x1)#kKD2o8l*#YoU2w=Ve zC=!5uFDf34i~w+`Lzo8_y$l|RBn~zJ{RQ9&4bUnAz+W5yZ@vHkk%Jfm&{zP*YJd;! zZ^(n|8~|w?4T{mUxrgS#j$6pYHX2}21b}1*K<+FsQEd2!48WrTu;&HEgW(YXK1mMq z;O}o53bGBrI01N612m5S@T3D^Dt%=%6_kEGeX%Y_M?o2`QMOEJ$cQ`#%E)t24jG-l zZ2*qkOhz=<0Nw}ymIL5P&gzH({D1*iDFEA_SBw}K0bp1AFe9pmfPzGhhB6GmeFCsh z14Ksv2si-F2~lw3BF%%#1z@NEX#Kk3zJ`n#>OlFF{#R*MZyJ=Ed@>@MDAcbHL_mmj zAiNktxX&QGBM9$4r#O)j0bonJFei=;Hk{~b07?a5js`e!Z^JTp9RTOh2A8_{w!7wp zM*s$BfHe^S208$~=FEx!ylMd22*9t;sv;Cc0El(~eDOK}q+Q)*01n3g_;K?0?4uD%|tcWBY z`IF|s3IRyh053-XxZDBo{dWLhH7fnO%%I#ND8Z){BW{g=a;$Zj5q~>rI62+`bQge^ zHNg210N!u_Jo!EVM4mesfMeH_5qD^SFYau}hDuN@*Fyy!r9mQE|-gk=z# z2*OQ5hh^`-qai15bpYHR0@#(RIq|^+vho}a@aG5s=Q{uv#T(TSFaS#g;9tv?G+Yw_ z;ERMX6TaaJ1}TEa089{oL4h<(p8;4U00)*S9*m9v@R=3n!S{4G2@hNbV7dS- z)c}bR0RHL#@O=sZ(QZu*z?A}Utp?bAdqW;v?*Le`#uQ=ed71~Y0?{yEQfd;{{-h z26%r`LmrHC0OW=MHg(lJ=qdoMHGn??Kzj$k)&DR|oM!;+apXbOQ;G+}A^_}*5A&d- z0Z{t2pFw$9Q2ZJtCIU*C1LfdqL&m8TU5@(&V3-Ejd|N|CjC24z69QOo05SxinFe?$ z0zfMVz|DUJ1u~eKVE}5cB_k@ADn?{S0QjI~m=XV`ze^g#6$W6d04xvytzS>y+OQl8 z94LM+6O&f)!?~If3k4;cDAcd(BOnZRAlw?F;|+r_LJ(^ItO_zC0zixdV8U|4iF*w| zTLE}S16&aSU~`KwCqAUlNy>1E0r>P9vU0WtI6ko<6CQE^EPoOJGA{h)9LZC1^E1i;a195Rq8{%w0OHb?!#pUa z2`=N1?gpUdYVzO#4e;YF4Jnx80655jrBGmZ(L8up05UYdn-Ks8H~`Wf1Ar{k{T~A` zUjR-#p?EMQ0>H1$!bM2#i9SXgUXu(!t^lkdKzM=ZWP{USf#`QvITwf?#+_au`pZBp z5Iu%SHT4&Ws`a5yz+5x?cjTnvX(?C|nt?dc8y~_swAgW*f|UU40(q(9TAG{5NAhh!W!LFF=@jEkyi1TM-cq z)M267S*e!LdQZ2W({$3j+S;h;Ez-BMeANMDhNCwS>N9iioVyT*wxg@+I|P@XcDE-G zGmR(qW=+b;{BUYAF2`my!g<1{3KHcB&al5GI#`Kquffd&t+k%4m`OO(v#6;=3kfFY zbpH_Ln}jGgU3@hN<$dCZNeE@Jq(ZipItpd4ABAWFzGL>IXhGb{n7MOKo-2^##v#Oc zWs@>bOzoRvtUZGD_-xf|*?KyO|gc+8$))JPNo0f95t#-(J1IFr|!K zxz)jy+k`9rmc>K-V~gX4_;ZS5$eo0o%x%-!@XE;*ls_9M-x`)AfhB`+?m%afntkHO z$n1DIPqE`6v?9%pp=5`@cNuum8|UMe#gG$6{hqS8G6%;KyPp6b&L{YZA0lFhxG)5H zC@zS6-lMsIMud&8pztD>KMe&PjXKX6@@r1!=IIc9?7j6J^L@^P;9p|Q97fDX{CPk2 z)FVk(#7aocJZCP>4tJp)sSmL~b{XOe$frt*Q}ljfZW@>Nb^1!Zc@Z1u5~}a1--1;8 zXXMu~jo4}I&%+km9kVC60{7QKSgrXBSz|)9J4|$c?C;OqG5vOrKP$oAeYdMS!o($w z&h=HePwaP9ec`UCxysXZlPeI@j>X!^)8XGopio6F3&!{WdkW9hMZ*zC;iB1_3=bRy z+ifqp8O4DxZ^<_yO;}R9ZJknH7%pX4{&*mjx2ACc&OJGWgZkpv{e~mi5!^vEfGhLF zoGVZxSGucgPv)j+ca98D1e1It0-b$1nR{oo9pd-+AQuN_LkjoKYT^z|i4Jb(+1gtM zryoK{>cUI1{T^@JJcQCoh?gaXx3Epj9BGgz0Ro3~~z727j`JRAt$!5V^y^6G@Z_};U5Uig4M^3&&X{P5UW z$j50VAJEI9#=hyV)!0i8{W+u_{=0#^lzR9d%@X{N<)_a+{P@)NXZtU8Gw_=XUJTP; zA3p;9g$ln&;d7r3@TD{DTNnT0y7;Dk2axU4d$}g=cFj9g3}Kzs7QNRHfoppOe|$Sp z>+P|1)ZH9?*4h}veUVdHbp8J@2Rm2$w{lf|FUQ+A!-gHm!`p+cwNW{l<#V8Rrbh?& zBi2N4FAq~c&+fl?5I@risi$JP^>~H(@OmZ#$8U8ST9soH| zXQSiqXP&m^&j-E8?A;;$mJf{xBt4XqSvjj6bl*cUW!ahKl(@=Sihy@Wz93>NhR_=cD)2@e(riN-v(coOSRyFt z8l-K8fXpKZ?e~-88XA734uq@_!uM^o;df>@$+$|$!1~_^067kT=n%l`2H-sbIOA7_ z-}DFojU50(v(4tFdknxL0r;l|xI6;DrrKLVOqjR8FrkM57$X3)2oSa$dm5YumgB}g zPRsFi+}Y7@*QvBL&LPr1MgD z()KMu+4-s@~2b zZ^oU{rgr5OFqY3(K~t1`uYs^?`9{Fq^4XWV(7_=t>NEJGOv^z0 z^wN8ysu`rKu#J4uP5$M@wXri!Ijb$js-+u6oQQ5Ai`5u zxw@ivz8;TGd=|B9{@!Nc|kixC}ly-bqdjpk-3?0160glwFYBV_k)NOpga?Ly4AJW@V1%TQicosYiW z5Ny8=`3~JYi<>gq<#G1$K6oxeh#u%oG#5ktlQo~g;B@`EAl|pnL+mspM4*A#3Hh_- z8Zk!jz&qfgg%r>>_VZ&Y=8d7<-MuJB3{ew%B`&3o(-@&F3#e=@Gm35y2*fauut5_2 zC?^#$mj1Osfn5^~y%&c-QpvEt zF<2|OmEnkRBngHpd$n5cbL&GlqJcyIZ;;TL>X;LkZ&)|Pzn;%RC)hWS(HxwL0BejQ zH87chs$4jL$_=qZ%tOiEud_#Nsa#)9RgKHr4?#=cM2lp!AjE;nvl6o6tVG5GOvp;+ z#bjJ` ziGzrHTvk@*_T{CCu;j_#eEBs9B58RA1RJ+;j2iFf24CV(} zhTluPh;cWPu{Myis?)RZY!}7-{o70jrlvpN*t7s8|_MSLk7@XF*?{i%>&yf%T;kC#*G>Y#5Bj5 z2Qb67P>N)5Z7v}~@EeS2i_c*$xycGwR|NgdOM^xVeMFVC+dc}RR;^b;4cV9V(oL8h ze?oPRQqS*GeruHco(d`HEyWbxG72w86d|F7d@+hrRl#J&Q6_ohAtbllA-ONly)nv; zJ+3$@7$UX3N|e;Tk|&(>_y;EE$|0DPT86fx)Rt3fRlW)zWrNgucGsZT?T>Ft!KsVh znQ>8tU2sZY9P*dydxzC+zXeyO8rrvYzDz%EFU6bm?UdVSe8~!C7N8)_?JaNW_8zV& z^Y{k-o-9$Q@|hnKv9%)p?Lh1(9kbvOZ; z>gH84_3X%cGR3f@LtQ?A26`KT!U3&;{;*x=LZEu1Tbc%eYN7?IsTL>%!}JbJgHjua zlv5y4$EIC?uOU%9-nBI(suv{+(K)@}6jPwgmGoZ6>~*8-ib`Bs9Z@-;Ma8N1Lf4d^ z{YrkmhfyM(z`So(fK{xqY~OD07w5Waci{Mt4%UK)@C7An6<)g#Mz);4fj;Z*n-f)= zinCvKhU*m7c7$Kg+p+>5p;PxGG&{qK3VZQ(bKSRjSv(&sv+b9Q-;J7u0Wpl*li5P0{zCDNHDu<#*;n8|x-3`bnS%a|vX}4jkI8@>PJ_nz5z;yK#{^e& zmCg9=2rv2a?=a#RLlT|`Md2v;xHydPq*Y9DR~(KR8AysoZ*X{IAO^o#yU}Yzu?Hze znQ;xBs}u>Y(NJr%L_EBw8d-r2_(F9R_`6XO$c3mKwDTz_I!BXLa_E3-o5EC$KP$@v z@fF1fmyN`&<3aFoX#bXXoLExq@_dyJJKaZ^aBkZBOe})V3 zs*CY8Oue(njI!TFa;}5q)a6U;%sch?Zi58;bV`mrOZ6W&yMKo>E+=PBhB)&Tu5uRU zqz<*8pC)0Bn|*R`)CO5`(|YcyT5Annc@Lj!51xe^iJ!G$#;IC+pZfTbB8iFY8jqOB zgDQV>+7~P|&VTRj>^WpgqWa+3gJYu?QRBnUpsMuvVTQ|F8)q$`m{b2{l^ic@j=@cw zRr;8y*Sri@^eJfUpB6$9_h4_b5NxJBA`KY5iZZ^{VPshgSBo`=Yh z&lLyvq?^5`%MGh*WFR#$7yTHNNlRR~sZ65zmd0vKDz9j)V#EPOl0p03R}nh@C-W0) z@i(AAREkUfj+4KW-8AT{vc)FJ-h0Gty-|tt2U_Hm?8;tG{hYmlT0GYp49BimQKCAK zE3B*xK7y`wCD7z@*H(D^h~B#0@?NEt41{X8$G6iM8z0X=J1YA|wIjt4wxfSOs6^%R zp$$X@A%m?oiaF+BHJa*Vo+8Z6LjiH1o@OwtdosBC9V1J^O!(I^J}VHh$Q}o==&=(T zf|}MQ$P7vgq$3NgrgXUQD|&t*Uj#O$mdWp2^fh;<9&-io$9~#FQtrX)*pmBiQ~mFR z!x+c_XEzEz3EjgG4Z}km1dnGL$VHa9;P6A9Ff2QVMa&z4e2ZcbO>n9!P$EY<*zi_J}nEqAE4e(#Lqf* zR-QdFGVC;qrLa&{gHVNm2HcdZ17-21A%g~j;ASh%% zRwA+ZF&mROyqD1^ zL~>Sz2VZ;qNn1Ucl|0-^o%0fG?FqP|*^=h}Mia+hxD}R(Iw}Jv=vWIr$5Rh39@@zZ zWW##S_3d?c-!mM;JdW_(a0X!n>WSXr>Hb-DbAds$)ey563HA0s9MZ*yY*BKG327K7 zgbh)Hjxx$qj+T|f_)LVxHWxMKA`XeDJD{& z=W@Zf(Mj3IH`S|WOj3?c8ysB)kNkF5^g(mJL*@=^L2oFc-0oGmzMbw92iz53GK82KXB3fqIwhdfklLMj$Xfg* zpF;pv$@|U+dA*<45Qf9}wg2{AZEdIth*Uf-pDs#`Lb;h0lZNbjRQr8wU*Ik|<_Tn@ z+FPR9%T=|LpRD#QRC|Rrzn^@otNj>(S?yi$)RVc(dZ-yMki}uV$@T4UcdtUVk5<)w z64k!L6TQjPeP6X40>&V_j*_z!_Hft;)kmNtJ>5-3!OC1n${k84T)wdONpWfI1Ljfc zXhJX@P1!X5!VgoX?j8n8JH+1xDpZFvWq^BJV*jela(jI%E<)%Fs7Cyy?p?=53h) zK#c0Vo6=mhyLgE5;@6<)t%OF}|1>Z``=17;FyDow-#aUHa^oUI5LRczp?~EJsk_1+ z;Et~3tZ79}W4E`aQ9)lf$nkW?0s^Sr?X&(g1S9L19CZq8_TDdGPNWR(aA74E72c4l!MtAAB98?T`6Yz`o_Cma}z4(*EK6tympYKB@ zne*TuDFx1KH>KFl*5xJ>;1T-is4`BZL-Gy784xK`X`Ce3PhsvEo?s$qj}WFB z%Gt1p6I`GO^KGs84y64strI^Sj72kP-os6^tyd}rFKn4s+o;-u@?&Br4K4QC^D zWnEG)A*rqgq!!(;Nd0cW*+?Z0NJZhxaYdb0iC^;f9I{qFhQ{RM>LDkL7hUG3$7|ac zA;V9`P0!$wgqOjE&+}_srBy{2y1b{G6(k{=NPvB3jlFFHUcg-;Jq<<#)BxbfO=u zlEc_BkjsPiKEj0@^o5V8-lUJBy3>ghV!$5ZXPJ03utbPN? zcQQ{lB%bd!PL3`931brbjTUFmt9~A#<5Nk1+qcDqB_^T1Ol3^^b2GnyRo05d#BmBI zp+@X#ZW02smh-78nGZAL=dy=c0kT|yso#{T^BY{=GttvwekmRWhr%t^uIN&8@AA%w ziz*UJf~<7XNR~tXt21DmAW?g(v=y&35S}DW?}U7C6e2QcLgojv`LwWo^+C+UF(3W- zA|~f?Cc3^b|B+=qu{AiD<-@yxr9o<_#MAnf67kDGFqP+nWi0))Sk8SKv7)-Ga}RK&11hX+gaCGS{CNY!SNg z?Z65LCX}OLX$!J`%;03WRf4^WHgaYCF zAsODSNC8Hps?K;*gxwB%n7V%Tx+>ZNAgFzK`6Qr#!yT zbFG1&hR)iv27YbMJY+RYZQ%+G*zxKd=+9s$`v63P=dT?Gb3J}_Y8cO=LknU1ro8bq z9fB>T5cysZv&e;m0$1XmAFbjq=Kuc13Gn68##{lIs(5UlsySX;oPmNYCK6gG^Pwd3 zE$_uRrDV%J2I+h$$atx;hkHila8INhYH%Qc9AT>(L8#3j`3lKX$y9ym4`!_cD2*ll z!f)Zw63KWHObN9HEtU1ZK>L6mK9g)M2*AZd&VsMQM$y}T0{S8wo*rvW8<x?kaar%S2zJGFY*8!M#1_GJVf)v6s)9(B^4E<<^g2>wv7NIB zy8Sns-W`-RRi((nWn57+YfXz_AM@TSor(0;+7`j{@V0qT3`&cx`cw;*Bp#P7t!EU&3Uer7rUv@F&M>b3u zk5|ZMEk12n6p#>K)aEBEq47`F`0`+TCx2U6rEVnp5iiMLk`!Om;-_pYp&35j9<=ZP z-+YPPxIgmYB&%m7*kmoMz(CswA2P6tl2ir>!(*5W6PE=s7ji1WD!r4bkpun@kCSXd z^=B1zWM+x{a~)Ie!T&?Sj;4G_9mLKc=AFnt*Wu`*o|_B>xZY_k*+gn~bmgq5Y7Cg5 z`5vp)%dCfdsAW-ESWD1}UY40!v_q1F@+D30>JH?gvp5w!y(Jq$uy2Syb{Ru~h0jcv z(FND-i<(jS;&`~=1-OOoJr5s=dg>tgHF5jX%Xsj)j9;FpDA``vLMAm7h5Q?Cyqsjg zn%9!=@X+JiY9xInZdoBh-weY%?0!rBJ&m?^x;?O;QmQ_+)SZM#}Ly)Cy7TT%ocsX< zb3enViyEOu-j--{#`KU1#l9VpltVRz(&FeW-w(P|B%JCL(S6^D5}!8RH+wkNg$o8P zE=^se;JQ5;HS1zY1(+C2#}iaX3ch1?pwlkh!xPb?g6*YZQ10|ly+{%WP)3!r=@-Pn zQ<9{? zvaKx0whvf zY~}hO{BBeFCoAKORk~ejsUS{d8)ExFToCIu3OPX$G8iz`VPATLqGMEvp0k1~k=leS z5UVB@DJkYr!diJ`o`4044D9NIaWA#{p&mZIG;J$pGxk>WEJO$iZ2gtZ%K(QBh!eou% zfTN)BsGuL`5dVoy8BQCJ`$ITei)}s7l2bT|u=rV_hfnLt4A*a(O1^am%L9k0CSJ5A z6xa&hn`*CD2u^FwurHF75fp+zA&EdCA3~McoxbOC39EE0Tr-Xm)vaFUSd7oE(j`LR1Z6DwDe^Q!_f@iOn#DB0r_HcOjSswTAmM0MF9mfec z>~GtGD&3Y9hoL2Um-se_lHu|}Ts5n4)FwR>f!N0r^ASJ#Z=8LETN(_ovlGBSWL2_C zlIo{^n(4;esjtjU(yg$UWr#_0=WNw!vH!DY!YHIzivGaDpMLb-;fT=){DA7hr^e!{ zQtA7BtN1bazwo2r+S{V+U7PDLqe;S9m@z*A%y@PsnGxHU37@E&@B>6Q(_9qhgt(Z? zgp*amXe2DNC)7>(csQlfn1=stn6jrzx$PQcd0yRw52=GcjCKpV;pmBr7qm!tXO{ti{WC5lUsc9Bq%b*B!Ubk6`ltvBs**m>pNqefKw~rPteAH#|a(7aX#;Ql( z_QIn$_2}6#Y+t9}t<$70L!1mv+ENl5YMFm;3H)6z2s3U+N_$h?gr{1B64oW`K_+|x z3Cr03!lj4hzu`3)G~>E)em9LPPBQG4O(MJAIg{IsGr4J8t(#F@Vyl?~`ri>ZL;K(9 z2i5-f1X@qfuQEf3Hm7C=Ve!lJjcQVm{&y&7`IZM2H`R%xStC&ySzy!xlPrXjzdV=(4Z6%1d=^IMInS-JkAwSMFxi*EJx%3B$~i$^->_K* zY=_Yw$;B~q5rvoXL}U+RxfS5AV+c1~)^}ln%(`Ozk5#Nb*1xzXoZa{>h$?Pu+=MA( zIbg}oB7t2ou1dj>dI+AX+K zGQ0!Ui~%4HWv1oJ^e`M&;WyZm`W^V@1@ggiyKcGMjHJJD`(|0td%7qcY%Eq1$+w&6d)%p=0|FB3X^B&1}dADOX-f}fyn74)E#jR>xCR~de3B(r; zygSOibPhNYi0$T)?xSn^Z1fL@p8h?}4f>-Z3%)39%rABNefifj&uESqOCflKm4NXA zmO5f%&LG(fgnc=KWG_$#F0dB}YbLRZ4I2$cL@WRJ$!4?jUA`UQd}Fv*8x`D$V#6is z{i=rJrS2y%iI9*C59F*YKK7l=rtCyz?>)>l3>|8-yVhiv>@LK)@ne5Zz|6`|<#-!h zfpyn%g`240W0*`Hhhy44v>19|w_4TE=sfPGRqIDD05^3>Knn+QP~tN<1EhMA)zXu& zy{S%hhxf?2W`6QyTdUM7QpIsD(!nKwy*wW59D;r2$!z<#)4Q-tL64PXkUWx3(9BPY zhI#zsGTig}6@$p>1Jq>N1%%?Xrt+UyB}sT7ju!Dx`{Bu(6KB6S?>Du+wweTTkim_^ zoW#Wp&4(A>7xfNfeCGOgqf4`swOgxBuZYISve1P&6}4gdO723ENxg^hQs}TsutE%y zh|&oenBtWF>GB|^ZFq(8GfsxzTMT`T#fWa*%Zx^Mqoy#auCrXt&RA>4xAz`B*L7lR zJ^dNOn6LhHC)itDgv|FS)*c}#7ljUN^T%{iE z=cAvNvA@8MD%ptOplT&KL%BXYU$n3-*H01l|EhN3uz$sQ!e?11ZDC()`A- zd7cF##?PJEKG5r+aR+z*z6oTv`VB5+}GeyaU-+mo!1NY}ELEIm4R zZn8o@)7@`}H{q56XofxV?+s4|XOd+5iC-IJ9DIQbFa*Di#*ee(6+#?T2YW&4FOxF( zQQegr>Q2(n2+`-A(JiX*Y8Un%V&&=fLew!zIU1U53eL9wFV(x-zVAb++hi)P*oTHn zeJ<;P%Den8QlIy!M>F{7d^|$$10wBpr*+}Zw!S0+eJM`*K;|E!@55aV`o0(<^mQUJ zPd+8|eW)JQT#QFvJksbD{5yIHM1)QdXY520}$?!*TKtBxA~{9IZxixw9hq zAAbVLyO&BSnyE*(pcJV84eH^~gQc_sShSURq>6_3{Z1L?r(;OkKtz=O>;<>5F5e9H za&b=v-shk@fljmWa=On+u#%r`h1Q<8Ly$4+kDJrD9=UuI4jMQ8C&xU6m~n4 zG8+q1+}=~kR%t(IVo#=8R%Vr6!aIK+^mpH4WMD1mEDw|?$L(+K_CFZs@@|weMipU- zm`f!dLr0^v>H=JvdhBF>G#hM|?FDSmc^p4vkb=tkw8xY7uiygJ1znahu%0U~M3Fs}1PxC<^^6%TB4%{4UF3d6P(M@aa$yiZDwFD}bSj z&PF;}JF@U#>6alWrvU@87Y#yhTKb0SO|w*Q`h+Xgo92rt&QV&(^^o!FO;Pq3fZDr~ zRA-vc&a_IjJFyd_6O%n1_52B3pq3>o$L+U%0ad@-w~A+h>(a7hwYbP%^@P(Av{qP+ zN&ohM)?MAWyaDq!ZL#7+1@?iaNwzZ{RV)CRIq1s+u@?>m3m$r1u>enLP&_s?#DWyf z0(9rbd)DVPSdjNPSg^B=VnIrn1@!LM`4^$z?pqF(&q z+WR$BZL4&|P%TV2sVW+UKT(H7*?5ot3)P2*s(eXKFIng#KvOe9O_ zvuFNfcw2=IwE+jE{;xIlkBPRuX&*#Q>w>Tnn{eU6PEnUXDH@tBI*$5Oq(bd?`y#2f zc0Kw%v<^CVF}D)v@-O$jIN$5|X{vHY;)A@z*(ZP06a*h@kp25*)|$MeGH$jQg{$^l z1nJ%MJqAK?)B9prH~Z_^SZsyBA$hJ~Z~V;)_Qc-|SOtN+JS-;)SnER zwMPeCe6scQ?G>&r$k z>|sAPqoFITvM)n_y8fKH?7ZXt`=ac(e?DDne|#5sDDyPK2VjMDlQLtW*voz}^*ie9 z_6c;DgMP#2GiBfp)|X8m|jU)8sAV(pSiG3KHw^Moj8Ec*cSGk@o*h~Rocr0AdHpdb1*y6{H)ZB#gf{I6*YUt=Klu_4$< zD$Oa}#@PSNOhhxorZs0Xd;LB%v*&&cHM2l$^bJVegkPzK7l{4k`npe~Dc&nPg~8_P zTQ$LoKJ?K>KA_)cAyQpn?rzZ^4*%B?>Ac`=DLsT}V435x=CYSaVKax5j(O8*$6pA( z^l1Lh2g>Y@^wuNy1bd1HS`SxgtaFS>@XT5hcf2CH=u*2kc3tpY7T>wJ3=Ind7AaVN zcADK=r`7NAO64>*HQ9gtj+ip>B_VG+NEbi404&vv-!>1PU~C$MZc;`iyuSQUk|Hzg zl~wffIr7c7b7i-%e1==_zxq%ltr@Ol#&1}s7SH=kCp7Pya&iIO=te6HenoMmfu$kW zUg*NX-+9tAlE3AJ7m%kZObx>?O@1{RV=llbVB~>rGM~-7PzM-c=Sz$MosK3M{bfP| zwrB;`cNYCkFAgAxU3LF)y20W9 zP#*;S+aKtsgjOE%=oc*d22TpSeyPa#fs0EUdk*=*{B)gYi*~^ zp3BcTpYsjwJ=kyu`SWCMwHANM+QI@f@89qRreRtphxnUae6p`q%9srNa{g@ffhQSh zi}5fD@6WSJWp=mwRs?i~FStrJDRP5i1q_ZBYJ+w45q#{;$Kyq!4AHCp6IQv%xzX_3{(hbzA*iTR>*mt6p9pDH~Np0_H*|g$M~H~ z6(n(X{x5M{IVZ98@W-`-aZr4_-phyNL)vxZh%SpO*b z+=!~uHXNqu5=DVy1S(-~!VRnw8iq7Li0Y#Ikp%ps9=8@_X%N(b@$N29T_H6FEzT{w z{=zB*jXh3{I-qElXw+JSl0>B^go=+bo>?7;Zlka$z;}*001y(Kl0Uf0TA4c(-9R#o8f6BJk-}YOrnu-v-Kn%pY z0s;6`|A^IYQ_m+K&I+PB8M{|k)Nvrzf0+z4lRC@>`yoI5=4-=Z3X3ws-ubl>1rz|c zn16uehO4{575g6@KkZ3SEJ9%7r|IRO=!cT=O6Db3vVhRP;!8kKq%w#8{gsjm{mgxG zZ5KT_2NGfSXQ+8LEKbWO=PC&T)i1r8-;Fxh%O!wnF05`2g`6-CY53Dd0Fk(uAY5)` z7Om@O7Eo`$&MSLTp!v)rPvWM@Pul z!O;Xz3Eg4}@M(kfiyb1Qg#0#4IjIb3k#!}r2A>s2Kxg$ws5bOb6lpaMQq{}uyjVU~ zQ!ALC`nR*bnTfo|^cl(g1NHwxD)v3=^#i@*LL!icE{i0s!mm_)79XJMUGh8ku+o2y z+WED)Ru5lgl0S^8 zZnEKsDByk^5IC`Q4EGr7Ba|)HEd)J-5d(f*j*t6u$T=ERDs};OXQzauthSPKs4I~a zojz8&b3HBr2mAJ8Zx-h~2}^N(L&_p~YNHs7RBI&R5;5o)MP?57ToublIy3CCL8D6{ zjsE+g$X4sdc0ZcYYH7w$A(by-8&&|`ODRf~UGu8!z$&~Lo#OQX1&L{buu;HCBxQ-y zyriJID|#}(%yYuv8|G^FSgrS387ih`G3RomWATddYjDE2xf>Th;Ff5Q|5cqz zA!TF5h;Ii1R(pJhvBl5h`%dXkcIahnEdF6IO%aS>axAifAgo|ksIYbTWreMh`x3pu zYKbg}$ys=P>RhCRQ3m=crhz2TtM{OxH^Ta$tCUH5m@wdseC6+ruIO^g2jY3e6{2l> zcEnk0?r)EUF)%pVF@CE%Eyz(ifNh0<>^4h3s}1 zLL8gOH;jIvlVu*5iqVBi6GWhSb!E1}KiU($_ct8gfk!I@e(e4lvuDp;TTX$bwB%-1 z5JzpBM3)6&B6q@68B@au6O6g-CYQS|hHrCzom{rM*}S(KdP3yt5@2sjt*heeSoGgl zqRD!$#NPapUi5}GXH#Sy1uw8KtHshmeVglR7UA&+K6B&#kE}gzMaD2dUX%T&Z_6?it1qiP$>4x zFNA?Obww5Szw}z>CCmxQ%p`&g%RN?L2?!*M_mFACa_DMg>XVC+doSkB1|qp=AT|^M za7eW3@KC|OTYXF6FgaVlUIJR!{bGFM;9qB1;&l&3nxRe(Dj>knAJ$vFC3#6 zvC%H2xPW6TQ4b?Eu6)6N_UsmDS@PE zRMn)yCH>FLOf(75BZbJ^sm77ot-^fl2lK_Pf_?Jpqw34qJ)^ZKs+56XC;b?1E!1&r zE#>lC*Th~LqnQXa`3{8D<-F?5%>p%teBAH{lZM)6J^QYUPQMPN;#MXom%az~{uZxeg za1gh>vIiaVfboS6s_49wE zUj7{4Rx0H(0fwPgE|dp7T~vH3$twLE_n0ouLJWniyoB;7mtVD{f}wPM`!Kh}k4v7$ z8$7}69P;PP(@1Wu4P2vUoe=vy{=!{))@h8)I*pN8r!g|?G)88f#>lMGm<;#_l3W42 z!Gs{*U>(^QT8(=+>vSn*onp$&v{S8~cKSq|xAc~z(Djp_juA+C^%Uq7(PJzaR(@d_ zcCfo?NBSAHwz{OdBTKei=@lcH!{NjEifzU}1xECbmiK#UK(eNb3#GM&S_yQ2XBfrv z1FUp2k{^{t#~c#wv%IfJLcRFFKMINsfgB{+kC4$y+ryM#ZyA|L`B~N*f(3~f$EQl| zsnqs7z5%J@&=*1;w+9O-A5d)k%Jxn;&iFiVDDxG@;v^P2STZvn{Yrk>L1$Tv8-9l3 zs4-Z`@n6o*eq5x=B%fg*v800Z!TczBRT3(yWMVkF=x%%S5gri2$qa5QGy!AbeA;oD zDo`35(+twfvf7X1dwz^XsD^LZY3M(f@pDj>hEf(?CM85N`-Sl=9`Y|QJcsVDJiRNY zoU~--Wm%704xI@3No5Z5lwVb2H7($rPg>#0*+qda?<)K98rI5gdLA$4CFse3fY8ed z=a`lf)NzW-51C`^b>9xevl|vu#!!BN&r#`Eq??t?@t3VdCxgCSms4~G`a4&Y*~74c zPh|jtQ+QaK_hqNhARs6UobT`4-0x`~1J79JvN9G)Dzhb1JLP9Wud~TdHs7EGke{6* zKa-sDGw3>}{0tA}04>(p{_0_sOEI|(2oxiN$cX%I;HO%*a{RdjaR{uE*Cb&bk-5(< z`&@}YU3vLSx+(y?3}Q8Dd6|fhwS09X36uRDLNwYZH7=I0NY zvg3!4fJLF~Cf2SFjY?ds#T-eb|6KPt-SBbQ!wA-YsAwPpD-b{1vXC)z1| zZT|@VQ9c8Has>Qtc5E15vyW3x%!l%phoyppSOl5rL4`2%g}M&a=0ZTzKhtTqvr;+a zO|Jf$HLLz9{_Mciylx-)ge&<79X=~ltP*R@Ol-=++M{z_h=yFc3hzQTsH~Kg82Sto zGk+f5p)n;}CDVz3{)_RqO77%ikT!)}p0Q9_iXuOF-^N-{Dup?f$aM#&S{Ggsg69f} zHdbjLg00Q#H7RpUucAa;rQs?KA#L|mca0I#L{_9rK>EzQ46!aTV97#VB0fKQ9NL!o zgF2VT0K(nK z@3AcCV5V>{oATE=TJY$!U|(s$3@?EGIoQLr;L#bu6luXN`6ieI9>D%H?HEs}r_e{v zu-43JkGe4LYX!Yl^usjK54EBna4q_wR`kO((GRtvAMghHp;q(*u0#64TB9xdZ7|`r ziXhVvpaf@zYR{w6Q0PMQ(z3A}5A&Bs=inI*RuWBPm(mrZSdNn+ieRQF#us6_E-TG$ za357S;{&d$++N=%z!&LPuGR1 z6Ls#M%Kdjt@b`k@Qa{sVuZ3>cs9U*%>*mMhR7q`?STzz19d%mO4U z53g8$*Wih)ZH_r9^=Eftkw7juql=oMdQN}L4z|zJ-BpokpIN0`qil+;(x1*_*{u@n z5fQOM>Oz{BIs4*xMSZXj{y1H8@mNjCudyK-?RQCPF@8(-6y8QnBl#jF<|zO4J4D&d zbR}SWOjZx?uUuU~FeFDVOK7eSM_DA?bzT!|Y>@GL%A;TAI z?G*6$M=S7<@MQ+VWN$qor(CW^vBAuYk zcj1Z8aiB(HS4AxrM{ILNpYb3{n)ek#uASLS0ibU7VJKM3BJF|G$_@9^Aaw9q+VqdK8LuynzW!Fre+wNT?aR;}88`(2Pv%ej1Gka=2R@5fWoJ3rVT z;IfP@Eskw2ft{e;VSB?KFxDJeK>y$>P@;zL)5HG3O4Q|~9BUukSW>Ghmh#q|)C=h@ zoR#Xrputyx8V&SGYhM+WEk!t%W4+mgL3R)|68jMYv2F3n&cG5mn(+Gx6zJ0(nQ+eP zFscBzKenrqTU&1RV@_$|Yi5VVt$lWVvq5gvHGf+p+oGNdJS~ z>v62NgHS=yw0)Z2_}V^$AMb#r9pUT8iEN3Oxt9~!`b@`jb>F#^Ioi1B+ADxtPz%ZMi-T69A9BLIYWMztL?1;OjYBv4PY@|9p`E|kW6tr3{?Je1zKJva>eU;CyVi8JyOGSCLp`zd_j((&T|^i6xCVaY*X3 zOQ7Rcw`E(ng0p3kaUk|+V``nf*qdM{m#Up0`Q(D4Q+;M2a{X~0Uvq?}`~*W#S(PY^i5TKp~O$@N1_d0^88_SJJ# zeC6vgyz&ID#Q_CX1$S^E;uLPOBcWViK{biS<$;&l6FwmF{0{d}e(Ysfe`V-~z2_k* zk`nyG?m3klnaxCIZbl^&7bc1H4tP3=TxpMJymrzNDv5q0{CDrI$@SfZdEL_^eAn-- z!KRQw$UkbZ|E`4Wif@y17T%pYNZ%yzCP&}I@n-N~{{%d}K6OZXZS@TJyCIB9?{R%f z9Ja7k55!aa2CX}eKOP+w?LFR8E#L%y=6pl`QHD9uOqs^P8$s}}0zAahi?7KAYy`9x z{|1V3{athYcYu!rR*WSdf3-?0pj|zI+rh^p1qEEy2|glJB|i4}Ue$}7z{8_vUi0(z z_e9y_OY1T)L^6p{oFou9Ns72Eq>_NxDTZv_zEA6L)YFC>O(91&eg0c*uJ7Uz{+y%W z=%Ba|uCVs*qhzfMNKx7T*$EZjCvz^&rLGfr?N--uydE~#e~)l`IQY7|G4#m5q$uCi zgh@EIa8izMd@r)MW%j(CQN?h|@&Q;i7WT!9|3RM-=&~k&DUCq<$oL!aGb?qh{a!y9 zS=+H0HPH6pZ%_+pKBdW(<@3%4CegXt3k`myd7sSl&khFMv8fcd3b=xw6t zeWs|12X4%5gNkVAeEnxEv0b$kGV z#$n|A=t^IB@za$a6M$8Di6X6{;T4u$oRZpfkgEf(@5+K z^J#s~V2x2AewqKKD7#%>YIsdxpzYVEAoA!oZQ%q&9EZhNfll=DXezgoO4U_4sr>F6 zj!gP&yO>6B zvAzr~Hm3~?%|QGOXYPu!lR>@FmeU;ClJZ-Fzzq|keTjuqZiunQkn zWBZ2jN`~z-<)0jhW};gr#yGCn5DhH3hvBy6=&f_1G5KO?!zvHDWw&aAT8{;c?=D`A}lyZzlO@CsgW0tu2 zT(YaJ7vCdJr>q%-Zu1UEk4M)~1OppOt%L3C=Vf*r*Vsqu_80E2;ed>S^?Zb?^99+O@>_Gff)(;qm(N3QxDsvS5g)gC(*Io$8 zX1;3AULf|~Tp3ManGv>U!V@-`Mm$CIo`n!m`*JhSJqhcx*6Zr2eiW@Z%y@nEzp%g4 zV?l*?3+?Ye0rdaG{$6SP(DS}YL6ytcFH8RB$=`hWI|V&!)}*3)Cqi4~bmLTn9EP>t zg=!7PuFt>^UBn{4ldw(^ZelLOm6OjfY}V#AdZ-nY1KhK1r*Geogy}DT}!g5fb6*VdQ#OA1Ct0WWe`8>^CyVFBYWH&s> z4UBK>$vjj5pQg}>?v`}gjY;Prr5{dX1BfAtW}V6q#34)@_8qC5Y38aIs&AMya9d2f zo;`8gP`gGw-Sqr^^dq2A1o^>z$hqAs8Mg1le)5@9 z8_MR4^#q2YQSK}lL@C%U-#8oP=_m^OPP+}z*eLl$LsZB+mND%_<7=1Fjg1ed3-3rT z$NbKXYy+zV)_A`n)zQy~RUNJ4ms~1bk8aQ}AZQjM@1TTg0qY|$SD|JNl${8rQ_cnc z_j&@O8%@G{Q8#L%43&{soORSr2PxrRJAH;KVP%~XsuUa^DgKGtQDQ(^Sz@Jb;J8yX zQtgnoaO1DEfB6pgXgl)U(Y#?l?wg94I>nOe-C{^CPc4?@%7xLOh1^klgEaAZ(?Kuy z_L~-Rn5j%AAh;O!)w2OfiJ5Z=o$cU8N?mE`q|q)DG)VYXk!*~GRG9128{t+pb{;&^ zbSP}wXS~cxO}xZHpzHQM8=c4uxc=);2^ z0mb%#j|=X?e!`Z`bA6v?dyh7C`#wO>$?QGVYW`5#=O!R@QeF2z?%vGye%&<3dgbK6 zg)Niah)Chiteo~VSD0IG?D7OUXXZv9%|(>*ieO{N*P-dyX|kVw%qbsn#RdjRRrYPT zv}k`au1~DJ?>{g-?+@b7`?!MHa=~w?!$6nM{sm+6z(~VQT1E+xEJ^!nY~KBSBeMFj zNal;I|D6Fpq4MvyfCEAM_mn+vdJnz1%fB!UHKjtvi>U@T8aoCYJBFu99$|uP6n#V= z8=HW6S&nOY$p(ZnM$>5?=+be{9Q?$$SuhztD%_C$ryj~ErT+`Fb+^mNJU-#O_aVQD zh=o%x*`BI&vW+0!7t8R(1Uz$vt*>vi7Q4;MPuqs-7GxXO4Vq@@`@Tb%L92z=4 z1&3We#6ir4uMhsdglxF_;Ox2cAiv8;dQ8v z?}Mf~T)q>ouKQdSU&WyQ(&I2b#*+5H^k@WjDLP6;UdE~rPQHyq_7ju~(xbjSgDr#j_@_T>IeV$p8fc^enzdwGwUSyu$NTRS*#ai{5({+`Jm0u~IB{Km>JSaGQg70y z$Y^-GRL8n3?651(YWrYY-LuS$92i??<7*>g7n8|ojC=>9EWc{6ky~l+V11vxTL`$h zOLTYntitH-L7`tSPjy8$5hk->{Bw}%-mB;~R>n}nd34Zr$jg2A8h+(yXAxZVoT1hk zkLOTpd#j?~5TyN`jQoEev6LhKeYuY)aavX8nvh`rjqd0gn)@7mFu6tmLR^}-r)$na zo@5`4?&v~rQ{}3Eh@_-*=AG}?=MM2o=W^CJr$f2j2b&+gvGf`zijh)W>}$M=^}id% zO>fA*O#a8E`s_fAIX$r6G&!B`Mc&@I44w(bqZ2>D8=w`}cI0o*+C%w!Q06uqH+sQ% zI%}qlb?PTj_>fDaKkB-kUyJy}0@I({cbVUlPg>3ZI1XF;rTTA_G0`2LGGW5pr!lSt zcINmLLomJndgGfSDmE;F@+oJ21gosG=++Io#1C)niyRtpXmFQ~dxYMQmgc@TLjZNu zsbO~q$PBv!WQ7tCwD!SY%i(sFh8|tM32&?K0-yOi1OJQWhL{aMJ|ynYPTeU;1_Mi$ z=4P<}kQG>TYd(}_TQgw9Kp}A;dKUn%{Cd*Y4z$|S%m6w3v77<2E$2)|wiMC$C{61} zH^8X=_!z^ZFf_w{@3TA4HRVpyd%R{mN)kwF%wWlw7a}`iLuBKREd1PWo`~QFf>^B( zBu#?(e#NnX^Cr`dILN0FPFJ_ZL^Ki}v)=%Vu~L^)OsTI9K*xxxMAKFsB{J-|Rpo(H z)3~u?7LYq$_nFYlX>I1aU8OgAPfJN!PnNr^+<_B!}_d zWPEvJb+Ljb0EzG-iRF^ynHhN}`ZcofaQf}UzG?b-n9@u|;@9nCZ{i7y*|okJhA6ai z90VpC_|J-Km=8|v?{pYOO8;F%)GD0yu_o+1+nq%sQJ$rp9hT&Lt~ZhT-}8E10etX9 zKU8Z|SriZ19?F7;0l~xY;9&t(S)QfA!@A(XHkTmIR%~#RubJ`n_q9H0UdRNeXD>qg zJ8W?Tn^LOLn|PiBY7sBt7pB%uiCkJ+I#UaLL8nov&WMES9BXQI%A&mJz&;BqEWty~ z9w_{(%+MDL;g%7ogV?pWtJLzV-&?`sBHr>iFMl-wk(Z_>ofSKE=h?C0J0aPUvQqF8 zj;@+CDlv>R=iCoWgVm&~oa|;h>=%I4NNl?{SFf&$t%&{8OwTDPbX)mU6?+@cMD|Fl zVy^~p%P^vE(ip880NY^iPgs}&-IThC>W9ypRdy9t2r({U_d~Z$KY#~Jka>Iz$4}8? zQ5zl;1fJvBK!yY*N&`9eo}t6ruljW0lVwqepn0XLvfjTy{!S|+Lx8#^ge}#tq?_s_ z9QAOHZAw3oQ2X{!(h&OPe9H^f->=tn*0yEZ(d6WkYb@;;6U@&UxQ6&}dGq?J4J4>g z4@@(xO{9SRGR^82AEC>HNKsN|bM_U$f|YotYzByN>*MgC*El|Z2zf*Z;fwpPFF!(? zZ*@Rx@ZV*h{q{hLRq2zMy@h5eGK*La+OrC&SP*(&G<~hbQ!NLzm!*gvL#XhA-k+@# zdx~=SI=@N$Ms>_Hq!Mw0VgX%YE!7fQ*mc|T!chHEBP|Y~mUb@w+w1JmLviFv^+c%g zo%M0bpWZWbSm6XY=^u@RFHar8_|tg>x%^h7$P*k@=&Yj(>~z$WH_9tHwD4SaqM|rd ze_`)D%5;l#N{-?wXlke~MBqxrQ2iHx&Qo!yVY7(sZ1<=*Z>G-n;mMA#IOP7jb<*wK zaDw=XimX^^krgW}vSN)zR-By5L{_W-ZHl|tmcQjX<2F&lrw~-IuDPkh#OMuei39xG zgWbr}NaW7Fo%x~LXOe_n^4zxgb^7}SZ>HJ}k6%<+osaRAsRFQN19PMGVHMCUG?^+Vob9&J$(Khx@~!Bs9__~=>K2#|H$t9?*H}TS@=i7 z*Mk`esb8t>fJxwo%UGa~!)-aAxVKvG%kMB7q?e{{TJD}!mGGc0?k#1{f}r0me2AB z<^AfZM@`xoRz3M&X7&mCzoKfKpQzxmj8tn4ig#3y!L0rnr}%&gZYe^pVn08CTYiSO z!6XD!orHq-WCU;VjjW9Q1kO)1<%b%M@1i_TV4zFac29m@ zlt~FPQ~8r;XDWC4$L{IWn1{VaT9f_-W12AO%l=(5&v{hYOA#+$ki%XId0|ULFFbL@ zO&+Ki1C00x9YN!;gWfn_i+zg+P@piaqWL<#C3;`KbQb<)V;>NueeC#_W5ZamF=Uix zV+aU^iGbp1O8Xl_CnlZM_^cmGHOR6WJNyOY3h2GW=aYado-y_cXYZ>x{0uhlVkg4w z@aBGzvTQDJ)OXdu1nP4#u8u#r>ub(eBJh!<_}6#{`ZR({Lumx5E}I^vkYByrU~I#g zNh%2^I z*p|i&wFrXc}zJ4p+-9lo%`XZ6dDH zr2s=icdbZqJ&jA!E?Q{ekGorxBAPxsG3#*PyBY8IPph{7eN>-seEB_U&?lj}p-vLt z3$H4>YG}pRQ`!uVeKsn75f^IWb z%hKV`j!oFf(T#^qIUE%l{z-Jmg-oy3Zf z19H(>adcl^Y^ke^z(%p;$N!Zna^p0Py!|V3ps!y=cN2f%?G9juxpp=?zV_?YX+ESTz*b83`3>1Vr2IvLZAtkU`D@ z-mBt2EF2XdR86*d_8H?TzxWlle`*q?C`|*^bWor5evjUvjM7J`L1f?~N2@_?sj{=O zw3>4dkM~l?x}Sd()?fNLUK%TvOtRmBBS_9tkt@lQwy#{i)W@38Vj!U&su=GMa@^JY z_s9J2p8u|%s=2Ltr-wBn3e*~7#DN`1UkuzNzUNK)0ypAIf8}yICHy{r5i!4PGBtT; zoTtg(@z43ZzjHEw&cTA9x(lsMr=x1|UTW`t$&QqC?!?O}I1&G26)pCQ=IyKK8|PA# z*7Ll%6zvZOxw+N5r!J_ov$iP{-7kM@9L!BBZ}OZx0=IB3&<*1+BxG$Bat5sphpN{K zz8%61hhn?Pt=l_#g|O^rVoU`fsaJ9|D){$@6Y{)I&c;BU2-g_5sJvfdV(gr@{NI1o z(83~GPfI421(&F;b!ys0q|ziP|2vCG#gc+r2tn?P)xcwE$cGo_d1K_@8bH*3PffZ6$qCUXbgexsZ0 zafkU2Jg=|egza9jfBu!1_zmKKsAX4$7JexyC24?uck-x2WfKuz6?-b>UZEH?jZq zDV=aP$*ZcA+26fhbj42nxCX-UDQrH;lXh4+Z3_Pk>v{p2D7gDCwqrTz$F{SS50xca z^wFyg*^VV!F5TOE<1#YF#>Xd;0`U{&QJnlC&%P^hCDpa!N_-^AUfJJKH4@#297st3 zsL{Ypbnh$xcpYP}elqWY=_)@1a-9SD;};F&XU7}Jqc=H__0e0_xv8mEgfqxw8|ajq zqyjQD`=24BKHH|tof0QBVR?LK;-!8ABA8p*T)Eu#Q~oUWw67M1KT&Y+;r`@BoVREE zI|pCUj3fjtg6O>D-}r-koV_P6Z@;|h*Rz5thxYoX-PQ{K*))MlV>g!pjd{}H zPFaErL51-2rWFPTXb#F zymNFO@IU`Va(Y$U8Ls)Ns4=IeYpo{cnV_b#sEIizc6urEYIMkJ9|qkm@%ma`b+<%) z;#!Wft2uSZE#=aNb5PV06+@Zn|wgY{@`-IHC+>3gGG)|F8hhv^A zq1~czY>e72(UJh3lXe@9?#Ykz)tjVKI6e)!P3yrS*;4LvRD8)^g}eGYp{B#)~W54CQmM_x@ju!S59umVvpr1Bg9vif?a?zKj;m(vRAz2DTqf&#rq1&!9K4Om7yo)|-y5H}{C4ErTy!PVJKxFKJ1_PK#CXN=8(e6LCKQ`_KVm zuYz&!N#gdt?5{ZT6deOAS&sdcW46n2ipz1ja(s3)=XZ&WzF*+WzI=FpX7u$p|2tX6 z#oD2T_jTL~GiSCT-e()4?X1no*FM+R0r{CPUm{a)-qM(Sdn>d}6uh;;;P?k?Qg0ru zkhIJttyNNlB={xKyT=e+qr3-`(({MW66@RBxlE(DogkO{zt&I`(?<84hmHo7dhkF1ULM zB){cIiRCv(#gBHhLFT3TId_$nGWX0uLhje|?gxa-Za4 zrbYp8IWL8*tkW?fxm|)FY#soim zVHWj!GmoH1qTm^q_#}zmB$xDCmvn=YE+9$Q0AqAHryDl${Mz&N$W6|=TyXj4TrgNT zeQ{S8@qd;XTEkK5fIHgWGXTD$LRd*$wjFOGbH4vu|=2Ggx(EEFAn1jQX(8!DR>O*>UiM zgY1Lj;0XtbgAam(IW1ruylfvFY#fVyB}*nbj+OmL^Jgs%0un#sSaD`Q`(>k$U(H0T zp_9avni?AKIW%4s@GOr3)AE?bwGR);;@WqA=5y`GKG#|UPEh4??UUb6bFFwua!P?? z8sR5n+yvEn^IRt3rFkZCt@oHRUFtFkU(GWa(?-c8{vJ#|Wl&!w)dY_g-Nv-)cydB6 z(<&`s+C%PxY2O=}&9upZj!XN#XJxtjsXq&6le)Qlx)-NHMA4D!jPhSTYw~I1VH8OebaRQ{lIX2= zN%=16eI-3hlDFWmEE12?5HVA{=`&9~$%SAi&qaqhcMo2Bro*g$9UUf03Cr;#a=22= zc3Z7;7O?{3kFL%e`aCOk^b-!WFq)*N%pj9@`aCQ#@c-^_gKDo+wZ{lHL~|i| z+&z0YaCgn~T7x*KsC711g$;ck#X>Pd6TO$OxF*jVAQ1nUuIq5>GWq9i?9;r$BU@DX z{tQ*f3f)zBohtljj)QM(y3RLV1HSoG=imSLaC5l+F(L=9qo@Y^A@z90=}P9Sk~68K z(VKmrJNfv4&k&F4H@#@i_0{p7xkcR=p6#Y%{Y#Ghduwi+X%{T>FP-W8ZkEcku3WyG z6*vi_&0oiFRVBXpoR#DX;+HYf=_Z*bYyirLM^FX63pZh#Q!;+tWEjm7Xc}dI!1D>= z{MF(7R~j3e-od@>dB_pfg<^}KK1(?sbK?I^o}Jx?k*G*>niz7F|Wav=8ro14eHY;GB=K9sq}+yx8-;vf2uR4lz@yleI=(e zWu!SK_rdt*e~XWD$18vlwey*CsQ-UEpK0}%`m~q%`pQ>Kde#4Fmg!$!uR}Ceo>hhG zb3wB=#YbM}oYS@kOf-9oJoxIES;U9(o?T*lzImYr?Tl)*ut->fnB0mq3-4u|f0mMx z-q}b$G-mB@3^AWac7>v|%4+f=6hsf4b_L zyytuJj$}Tw;#vf0UtYY2@XVHc@3kY4?{}<0^i>~h(*}l>Tl^8?;CHArdEPUt!havD z3J+6-=Tf2fx9ve~r&F8FAHBpMcis4HQ<5twTd=Y7UtdNAK9A`k4)ps8*!#PW`9Lmik+mO-4?D zbI6aZ?3fdnnUOV|o4DFw?TYFuSQCx>DpdHq-!R#pPQRc39&lw%wv#SovR!*K{rm)v zS~uB_T@BWX)k#T-Lhtce{?N5+Z0!6|7`WXKSXG$z&y<};qBLy3tj+byzUTbg$)ojL zWosGYKX>I;<9AD*djucW%sldHdQ@7W%8^#Yul|W)U0vwQ{XfKBmg#`8nt65DFXZeDo&Zb1(d3U+*Qb>(|IS81MAN^T835@nr0vKii1yz|vt)rdn`Tek1nA6p-~?S8A!KmU}}M$rRG$w8cdta@LFOB9Sg z$DP9wzP;b>BywY-_bFk+&WZYjUX~bm#T!>Kv-v|YQLyWNrhtK;({rI|q?zM8J;JdM z|ESj%)Gy45=W%$O zT>VWG{O4`t?0Krpin%%WeF%!fP!$}8LV~(@=Q#Lvi+)%*uLj$@k8tKCjsOIwqu$xT zCPA0};(S(zKxC(*93{TAb)_UMr3UQw5eyz+be^Hpw(E9-n!RlGm5z_f$ItCmWLV5G!rZu>Um6Y^tf zVREq6kytK6f5cnpM5$DzRq=D!A(H*LwwsD4u5aS=9=n+Nyuwsrc-83)RMxwg3A)ca zue*MW=bcv^j-6Gh9@)4?>}yw%nWp9x1rHZMMK-K9zJgv>1UTlhg@d$A1L{~@fWtcQ5_$~@l&K_ zY-DNjII0Zx$GN^RZ$I1&UsT&VzZzY}`Bncn`oRwIbe+B>3KpzDb>JwqcM6OG>y{d1 zuA|fs+U|2%WAC}$c@qsUtOR$U!z#fVG3T27v=6g<4Jeq{NNir1Kf9(>sdof02g$ZG zlSXE#L*~fR=4eV?EUZM=6wL!S=xr|r>yyFd+N?QWt%*=L$pAHkT5*@~!d{I_3CGW& zZnlVHLrdk6)r<<*-9phJomERMR+(WX-ldcuMfp|3O27^R2dRt=3DT z;N5l%<3ArSgL|h}=so*6YS#^#FwX?A3dd>~3Qw#SoZ!U284)lH-ZJk*+6$7|(suhi z?rS)H6Z<_gSwPgV*K-E{@oFS!g5wa|^64I0cy^C%%SvlIf~FqPHKp@L_DCII&ma7Y z=UiF3q~#=p%(ck}|HbNz3`M^l`(Kly{~cyh^gm|>Qnc@@PKpYAQ1Hw>NYT%eCPj%7 z9q$xEN%nX&sG1bR7c?d4KCGS4mz!WI3>Zeku41&R=S3apF;Crosci_2c=37VhZ3 zXEBu`M>gJ+N**E$K<*LAoCA^{3DOP50fOS@KLhDOKBP)+1=3!?;r&8Dd{@1V>3Z9# z-sM6(7*KL6^{#kU7{LDJ`d9l`>)-v4(7%3N18qn1E^Jdxl+~xFiob#-i=9(3`^WCq zqWWYO3QqqM)BE~gxzwmiRUAgV!Hd-jr#ppKY85j`ClqFt6*0Zz<9a^pT^B(Y*-0Naac=#Xy~Sgk+UD{O4OrBsJY+r>-fm5=U5r1o77ck!Us^Qy z3NZQL-#Udq?=Pi+Ku%mo?%!R2C;evW4M@=isu#9dWWT{CCY)`80=-THi0?bxKzjTx z)9LC@v+?%gixUhuW%3&Tqh)%izKjs2W$eiU^gIm&=YIF?nVbTWi&T}M!LI^o z?@BRe(dlL-&-j&J66s~x$nFL>+a3nrGgc&xBdC=2nQ5Oc9OyFl`GGRon^$2f%SE<7 z>1C>T>zA4K_f@3T_U{e~V*>&q&T+!9&nOc1y|cM`ARKpx26G{)WhtKlV^mNRXlNAK zI1e^iznVM!IkU*nQ7~>6!~3}-w>Q09+1-S`r91im07c^M?dHOmW&!q~Nx_$M+VF7n z`XYvJCGHE4sAA0U(IK}l*W`c)fbSmJ@Fx4$2YT<_W;1+NayS+))d^j+Q59|=iqzU* z!mgbj=9ur{kCP7bl^EXdbMhXoN9gbh^)b=u$5UsK2W$|osgQhm&*S9@C~n=a8B(d} z_`iEmR!C5artj2z7yLxll_N0qEvnt!lo~9h%BuhUAE*kCJSvyRI2CN4GK&h-L^#0! zu;1QYyIiCFpT$#lH)RynV_!p2o%B6%!JVcxpr|5fr@eRu{)hdXM!m_nzTm;xm#X|= zr6#&}6Cz^Fup^fVi8)$_3Z%-sHxjDWDI*H{Wu6rNMy1o95Mt0NHmp?31NFr=PbjT- zp<3@6xBD7>Z~xrq;b5p~t56`*v@sp&W>shSl_(wKiOHS}|NYJMBl*u3EO}l6;6C$g z@Lu1dX~cIiPZX36XK?dPBh`Ca-x9s62bf0pxVnD*rA4k~Qkqm{Gzh# z5k2Q%k2vL8>=75}$i6N4UU?3C#GC`LV9ZvD!*fgg=2S`)szl#(iC?P3`IJD|`j_-D zU1$`U{(q&|Ex5eLr6>1Khq^KQU>|?(Mg|Ql^pXnkVzAu27^NY)vXF>y-KZw@X4b^% zKgvG1!%dziGljT{R@NcE3Z49_k6I7htwoy0v?!3Me?S1TMT@P78!Ea@AIRS>wTDzE zhJ98Q-H{)fvy=?FKZLpRde}6HL$VIhUCeV9eRNsLoV)l$&Yn6bulq_Gcu!r8PG2e2 zVFp3|Yr@ejbutfOmLMI=-+*bDd%r9S=kG@M__EMDK?_S+Ex5%|s>uvt&2%nbkq&GE zL=eJ*l)y(f;xl%AWq8n@DUYT059;5l;P(3?N}7-cE8;~ujYOaw%;0?+w=X{pz=&tJ zCi$@-j)#ll9KvbCC0EneC7&V5&!Lb32uyvBt#=uw;fEE*TWi1p1OW;?{?E#J1G+Tj zHKyhw&F`Kso*Pp{JhnDXwjIae-y8pm@eQqM4Eqf$xLvX^3=BBwa^V%O=mhx*cD~+w z7XJC~v0@YdiptnXu9)q!1VP!zviz6xY^B7i#}7|F3_hV235?jf)EodP&H&KC07w%^ z$B;vbu7=wzXb_`7^Qxd3??Mg*(3~Y`Cbod)=Zk>`U^=!A%y_tV>>NRst=n zxMw-c@;~&)FT?p?d843O|$0M#`HEo7ELmDTjv zw!AcQdgz4@+D-ile+#FUD^rCsm3zBBmbf3z0t=bXxMsNU&Fi~`WIbsMi*MZLkm_z# zU`1h_z;caMr;=5;RJr;wS5(^ad;dQ%aU^>G@eWp-FSKc8wK?K4VJ)|V{Xs;F3C8u$ z%k&SiTvH^kPzz{+eYpGV2Vc#bR$LuFd@>K=WgoU36+Z@(-}(44pQagc9)+R3Ghxr4 z!>)2$OOf&!PH1N^(Yt=})!g5Fxh&G}SH)hEXs}{&x<6U5;6GhQaHd$9Q-)d2xt;8# zKVWZ0hIo|N*bCBvRrRRYzwsdRmR&)0(Umi_(3p(KtYDp*=$*(a^6AOi(C$nT?=7|M zGK0=SuWW*kpyaN-Zytgz#W$z{ac&Ck$=qmsFnfzzmKFTH4_8B<+}ml!GP9v1tT2xO zyoMI>p6C7Y9GZ&mCznSu{#9f9Wh#t24r8dVL#Dm%q=L$JHO*-T5Y@wr@mzVajC_ue$8g+T+55xpNa{90yOyU3&<=*Si02=oI2_@_W(rj@$y9E=k0N1`nRVN#BA7 ziO@Fa9vyg1-eNHmP7Z!zY}pGUm$$H^!lgXDKVYWGHM~8nu zo}>s`&B`#^A6k1;?vicF3~d}rpEa&NA&+%l(PikR@r{A@nE&L(=)a4bh#L3YH@3)TOUIvssnN2^0GY$}`@boY07>*aR${RJAS zgbHxoJ-rEW(PzSLkb3X?L4UhE!OZk3UOe9AEy|xhJqKNFRQ`iYReo%`{2Px`e!j{d zLHQhX6+g+Dv+H{1U~2ZC!BnH1`CCI(*~ClS{4`h}oN>_fr` zf78zOaaXF6%pDNYrjhUIu_XGz_;7R$8z=a%c=MlvST0p>*fPucmlY~nQH z803Jh??3XxMGVP}C4aoLp4C$j$#*SU@LAg<)% z6=uH`_uE^uw!Qq8EvFi@hPFLA{4LDze-;c_g?tot2{q_+Q)uDj^o@syIQfYDv6~4e zm#0qPxohMoCbRO?_jtCzB9pW3EhRmDZz<2*OQ^#o?&871P(yEk2)*!OVJMo%6FO@p z{lhpFnx9f1Sto7Zs7v(b{>@$$_Z%ER;2x2ie4DCbos=ln33#e0PxYUOmqAx98q`Z! zvrs2~e3RzavihM;3R}lG#2@*XvFby&$w3DHIb3&*wfS`W@8P6>cZZW!RTgscjd`%s zFD70C?8ZUjEuVuP`H6;~!XWAj1GkDAy_MHz4OX*E6CTpPnd#F|-E=>H4H2VCxb!cq8wY=)L|q-H^9?eDjERqX zjccx^Af|OsWuoKSaH0zF!8Fn+-F=d+e>R33qQhENS0*2|p04&LJc}1p&^RG0=WNmk z4p_$zE{vaF*cRYUmCqivRk+%`bEt`~Dd6}N_+-D|Uo89W%&yQM@=bQRpjU(eS-PD*Xw_oj> zrm^|V6U11#8~H`QpFLeFKzCleBgUcVJou&$40+HSGup+(e@Lx*xq9ZQKtsE-P!Jz#@w{N31o`|%Bi@tr|z;{j% zo!etXY`qQ zTDQAfq>n0eNKj`VUb%qI5}!V3Cp9>DqURsAn|kojZ7WM_G10i@vCnWZ&l6TE#knSz z8q^cO;ox)7^amQB8gGjlMvShbm~m+S&XwYtV4wwFq4yNrUh(_eohx&oxJH$X#mk-)K%4 zpdf$Obap$?B_swZ%B1lsbaRGn1@~^aYkLdq)?Ut>U8H-9H~M#U;2_ypmA_mkdStDj zmh^7!I%>t?j$nG-m;9Cy#+g+vg}?1ZsTIu0VHz0~FI$d{n$gE?*bCT=)nUm>K2+l< z$9+dHp^EGf(>-CbDb=+)F@t;ic82E6B=e~FRWEV%(h}Qu8#U=D7&q{Vb&{yr&*xumw4bx2P$126hsXP=9I11ENowP$L7PLj z)bk{^l86`;`=IK`x6Vp*tCFd(YS}lZRrPsm6xSaoy0snE@SjLAp?mx*IVquuC;2Rz zp=O&rAVb3Bg^(i*Nl?|1z$R5iq~$AZ6KU)#og7X~D-9LxucWO?^4;T+E;zX2(bN>0 z^ESS z4S+!e?WA<5;ZZ*|PfU#-;|Z4h^~$JHD0Ia_itz0Xd6RcmYH^6T1pD%hoVhvw2JQ_J8z+>C%Qrs`=jF%Hian_n%YIBB+;cGB$rUK zI=16^G}JurxNDhsW1HMdA6{UVgYE(KiQZq`ga-W@Tj$D*D9iKm{ml0A-)mIT|FYR$ zHo0u?^FlT2@3v}|sG7O%l9i<{>Gw*iB}t^LYWf>eDs)>PtX%&iDe3SA;Hhr&u$>$i zj$!mXNZQx%yI-jOFTB(DHW42=)SiUXubP-&MP1driC@Vd5g?#nQ(Mfv(Ot~BFOVvN%vu-b zbbnu)Ka=gK2q3T@%~N4APL0&(eHkhmzApUbuuzw_eUl#>i8$*Ilv-_TQq@2acWF>; z;@3Oz80qUyoV1j1u26GHX8{DLG#;cop(H~t^Dup-S_?6 z_l>jozL4)}>L;)AkLU+q4n#HlCQVbSjQL|{A#_S4ra;Q zP*FzF5x#a6b zZ6oDhoz7%*4795UsoMXD?tyZj@;Gs5=%$xY>;9{ulRVX@KlMSnr}=(%{Fq~0ZfT$C zj0ciYO=;Ml6(2yB9qp%H%Yx3-Ly^&DJ;-RlB%DK}*Y;=?3nnUul0Z1NB%_-rO}dDj zzY#foUP!)+gR2{fHCIB4*j7j7)Af=lIQ34W%i-5Um#yY<azIv+I)fP{S#t=%V&ye;#}bfU}R?2i9BK zz_aYnk=|T4*8^*G-A*$%hbu83zvuorCvv>Bb+ZhDQE~(oY1k3JJ zhXGn4v}MuG#LDgxxlH4i($jkdK$oWmsJ3GxqIzcNiP}X$FM7%699uwUQ{v`#JW}u}%1wVUD)rV2Mt3gIhC47gs~( z{wkU%_^GR{4L+BmZ!c1t8-2V-N3nPy_jD(7Q1pVq>ZNhsV9r{kwc8^wLNmEJ@W;l zc7@rNZ)-G69dR9)8upQOccx3KpH9;8N)mT_FKt2s(0q}aM_Da+<_>Tf+5;{zCz7g7 zqC@XymWv#wl+tjEO`_!^FOhv|E6drx^X>oP_HTq|uc@PE#t#^^8x_{LXYYguEWEw^kIxrrPT;yVfZYX1gU$&YmB z2Fh@BZDkdwbsD*cb7^69XvErZn{j)J8eQil7!w7*N?7Mt)YAFUn;e6y^B>+eLHs$G z0~}e~RlCk=t^3=~r2Abc+`RiX4S07CZGi)u1CSrd-K~m+X7XWehQARFa=8J)<5l@& z9Z%A6$6zb6C-aCHkUfVPmH}7DQ^WDoJlzin#c@ZV_tmjg-fShni~Z~j3AdT+D!Uog zF}ydaSJxfdEuOjo;{E$|VbUeL5XHFEDfR+3UAGDvsSwp#EQRcwLR2#+Z;gI4$dgXnl z^F<68oSf)_`h!H_TsVLy_m?6Zdn36=-HyHCP$BxqjsEMA=icalI{H_5A8%AHU%pn7 zZT)=4!f`tCN^Rv%zb@@<-JHT(Vp>zWM_;}OxT zpZZwtU2$6L+>*6L@M+o!Mf(GJ^vvxKtPc2O_LdpO1h`?@FS};;%a)q`8nIZ)$i-Z1zx_JbjQd7^P*48S*EWl+91@hhJ} zv)}NmPMKb8zwXvC?@n!V%w8$1rR8?;D%+JX;=TT!nBu;&I$pE^pk)}WvFKJ<? zY2J_!aq{&#y4AXTb+cj@?q5T|hUN?~oK(W!YiEC0XD{XW{%*(j*LQ9}2U#|rem~Fu zyuX(6Cmb5_x@NxiUofUj*u{=ui@RPllj(OSy81+RgWD0q6V4fBrIGR!Z3KQqVe zo(J)MpfiRUpM-t{@bSlUQHEAshC!=iR5Vd=nXB#Bms49$mvpX6y7wBA_9v;aH3E9` ziM7-k?ULuUJ`ad~(+>A(SE?$Z4STre?k)XuEXH{7E;k`QX3xBRS~ithke*olhpa+K z^}CvH&zpbbn6!Kuu)oho?tXfWfpRekW1_--U&C8Pn~4uV@an`FP1v7y^bE~iCR1v9 zU;jSe(C%V1U}T>@^TxbkO=ZhN3)@7u<}(aSsZ8!Wm2_=So9PGhcfSayR68)0kq~Oo zS&4AyFC7|FN0ZQ&`6Kk#4k_#)dkP{Q!;<#y1-b*HW{%c;Np z^drgD&edPZV_~FyXkmxcK)?O=p@v&oT!)_Pz-2ViJqJYE0teBE_H=MXI`P;s)G(1e z^6brNgZM(xJ)I&4d=)Bc^Ht~~4)OEeIn*GVGB%htp$pec3>~)&s6zKH>!Uji9cbhV zMGkbOiq2}QqWoWzI*<=sm^=@=f{OG1tisTRZ&JtdpbnnbhVERh`quVYm#$G$W+*yS zD3PN$GiIOg>!~r+8X-{`QEp4@U>*aT%pC;z5xzX)9B87A0f~i!HE)0e4%aPw7O#jCw@S`mH%4 zsKXFn1o>wx(pp7)2vX?Lw~<0PMeUD&$7Cjt;_LWx9Z%^QNHMs<0sh@w9QcOy&!3x^ z0d01T2gC4n719LjUCRX(-T};noC=(7kJ zkxebRh+T6ncxW$-OyEhAzs&(UkQ6}cI~P&0m|2iYr_gDneiB@kKepXlxx?9C@n17^ zJiYgp69v!R0s*^z?g%Ik7uHGr&)o|F*A9k&pRBiOrNmHBinm2op3J!DyUz<(ABmIH| zFjq$hjoeGY5A6KjZd`AgPleu`0WD_1M)>ayo3r@uUnM9I}(*v9SVIKb%~P3WBK zI65W?Ge^hW2%~HA>G$ju=G9izos!4(qKWI!-?np+g7#6PpXTfSs_5?g$kME;AaqbA z@*})`g;mfcw6OX>1#$Dz-&z0ncPnMir`ZiR8~#!#oNUKMO!vHnx4&oOZ|=u>VK^40 z4#{dLESTRTQ+V0V)1n^~DpuY06^9C3CZvkI+JB~-imup{$vXRkJk^)K+Rab9OGEQ# zD1jo(LiQxje9KNafEv;_4f}#4W{x%XY}KnOo7;l%6UA*J*vtB-D4$> zwmyi?2=n-@dK#Tk!{e9kaSV@}-Q##3|Lz_q@o4fVI%6`ATIo}429JyFaZw#VygljO zH2!##yFoa*NJEsjJKURO6mL=Y_JH0RBQwbMm>wh7@FcmB7n#7*B0UiwWem?t^&A<^ z(`tL-c(~3O+4l;bH(2U%JZ-Wkg!>{-Pn2h(U$oUyJM*+dPoerNQPu+DWKq=n?5BYR zd-(aSoZ7kFA_PfG!-j+*3HwNr$XTtJ1=B;o@&A7yfzSU)DIF?82dvansh&y#6*#g# z(z-rni*>A7v=CNvX1v1T{LpaX94uVJg=7}kbI%cp6P;e4qT2@Fc)3kp z(yYX*m=7`cAIn#z9nSAWr6qgu!<@4uTplB_cN*k}=*}f;^>1?N+UZ{MjtN1&U zMOoakbx^hsM!RedrqswFqEU3nM9V~Yp*Ebq$jw#eja>9iQ>wR`JS|h#T{*cBAig`j z3`xJ7h0y%3moq#3dbBSzov{>J$rSa+fr#3*e``fxUT}O%f%$EyB}mGbpktHS?NDT*@!4t z>BgWUD}Hjb;*OViRSl%a!la2 zRIfUVGkYGv4hkC^!43-B9l;I?slg5kkL+yhd$%LHvm~3GFx5dfzR6ZVO$pN2Pby<3L4Pi3W<9+Yo6S0>Quc&wL@JLIwlzu0BY< zBDif;9Pgs3)657h7s>F?(JkS-98J?_WXHdMf^k~PU$_1tsGS94M@(m<55mvo4 z?IgX|7AM6R%)Y|BQR=COOU&kr;hUNbDZaoObfm6X}hV6a(#~)(uYWF6za)(VC%XMbwAT=u~M{+5%5McUl+Zn*tBGWX10bD%UWC+!jiHPeh|-n$rX zXuHPP=>F+2-;R%R6x{Oi)|l_np0>U#G)15Y(K&gd zA%jPT-9yu)p>zJ_L)Uq3q16<7(T`ez`MKkP`OQ@=VP^b{wR$t(U1rR{0?8{59 z2Z8SVB0>iKFeVRnA1*ysC#X38^AfA!ZMGln@2|S^i+=T#@pf1|pj;Lk?u$SN|F1Lf zGmf+qDjmY=w4Kfw-9i_NX>EA>`|>LxX+!pTh zZg{&1ko8UBLA$X!`qQ>)0*Qi2Q|auAe>r;fbo6@hT1PLx`=CISz3CVT_RE!fA(-T+ z*Q;gc+<-sKdg%Ih`#$=&Q~fKLeqzwS#5wfleRat7F1pLQMW5DxuAa5hp}VKhp)dcL z!+;ME)4ipQ`N^Z{(CQU?>5w=2@Yb0xIWRM0uV9-vF`OG5dU(zl<8ve&qi*wv4EW2uj7+D71Vnok8aD+M60;C`}9jpajU;y z1dHxGFftrXt^Jg8KFaN+qozD_JE_m-F{8z?jP^ZG{0WYDpdb-O@!3t3RNk%`U0bB|U#ONpF$V*lfl!{vF%51<8{~WTcFvubg}RIckzBnUUG0TH@?n zn6~Z#H`-yW6!FJPnvGH38VR?s=*U4bw;AIvBk?j>?d@LX){ixkFGO=tQFd6zXb^Et zBh}$!x3so>)%K<1X`uFdgd6cbCCseIu=hfe9nqcLhT1j~9t@a5z9KNtUpi2S#Twbc z)wJRFIp)3VaGR&vO(h0x_fEf9hpleCEQ3}%(0I@Pfd$z~E> z^If&#=aAQ#jd){b7KRF~ARTd1i=C5gG5R$_ysh8iBdyoy(BU{|f_Onx}X7;%0Q2a}{*?U_%aF zzPN5*bh-0z=<>%Gq03PQfujrS@8(D9n=@~(LtD_NIrEO$8}q`-PQF~$D*b%Y8PymB zJ~{VAzo*2YVDf*VpXTH&pF`He&a<&RRW2vNBiU;xr~m)klDW$HMix*EC+li1>E`_F zWG57Mo+_b0xUe=BvXG~Mnm1oz)T}rMYMv;sNTcSO=bKS;(NCe~f%w6Se~O%P)>oD9 zb(Fo_7ixa67?JOdrF9#N+Vo$i!GT-~yr-HIbF`gm$kEiA6Z5QGVmkV*%E+HmHNjY8 z5BbYb7Z#-a^#^2gGh$!$m;S8wwuynQa|odlIggix`AcbkyoDmgU$Q^RfA%T6u+`b+ zthTAH=nn|_qDY7~*sJV<$aNE})k}QeD?r@)Z@Zba1Q;2kPmD{?q(UYCHLmVD41_Is zq2(ND(3kR;k?S3Qa0^~HSosdD{gMQs57za8ly>-ed~f*K3ue*=R{R%VXo(shDeU_O z2;nSQbZ2M1cL{V09|tohfrEG6ayTe)+@`Mu%5>yIf}gA3^uSeISz zlRfsP9R}lD26}&f%Hj`kpGoTGjFIj>^V3F+hBRx48;RhG0Rzr)_KTfuuwO)XYX3eq zICU(KZ6e1qaitFPzqgGPOymn&+dB&)ZFyoFb?5$UrrJo9&4%^QQTyB}-ubAjAB=UHlUqG338oJ2w8M38dtn>ljl z@hkTwcSauya;~68@8grR#7^_s-NcUfLCIcFrRYhyi6%Qy|aSyCPG zT=h{E_`r6Fl(4EZ|CCVlU+6CA3YFMcDu@F{IGj+!zo7@0Zz)(1K}N%z5t{#?vJKi3 zn*U3CcrA2$qaJ9iRK$W#nhO&J@p0qwyzjm4&^1{$+etc=h(*RpL3<{^-kO_mQ>&G| z^(M5P)8zIhqV?kf4bFc}5~Vr_e`DDSC)8UwR+Q=&9kS(eAs&0s`Gf~VfD(V+w#s>R znXJxwTwmq?zkT_5I$}$x7fN};6Hk6`ck7XE;pZK-fPyT3Lk)A3+R!xX8hSbFitwPR zg|jX-H9&nVr)OOrg%PS>b3H>B=JqMcr;&v>;l4}2XW{wC*AS}&3+>Lv-NQL5B%1Z|G;}i8rg5g65RZ6L=YC@;~n)Sn=Lh9l=J&jPE0!87 z-f)?t;(GR`eLg%qI%I-U5uwysn(E{&w2fWG8`4?MlsS(un3zGIuakq-^%B>B} z)FYeug&N%2;n-xTr4$nVr&aj02lIjLQ`Rqk|FlG>uaPBVHHB*nH7w%Uqw*JuT=YQ; z!P~mDfFX5%j=XFB;`pzQ8hsclRA*Rq*4X^FeVKWToNaDeTI5c7m_=>}FKQe_Fy9Sa zirx?YYkI>)h!29s7u}(Fn{sYp10&JDIF6Y$XazNY%LYP_w=)Cz4V# zd?rV?P&5sHN3_JBce=qRwpjMijjf~0=GU<;n@Rm4gC&QbtoapbE#U)xDhxmP{ngu2 zQoeXxa$}dP;c;_-;*s=1zJ)8NU4nmO1(%|=ZS<!4Sr z9codS#uc`0RPRf?gEA#tIj)%-Ypl6-C@9_iq;cy2m-G)Mc`j-8xCxvO*tpv9z3;#E ztIm$^bN00E?hf1knNrPpd?NlGp_XLWoZ(}KpKCMnD+@mv3vQ9wS*QP)*|BS={z0QT z7ThxsYVD_-z(-kdizVBf1y}d8%WgWcajMyFTe0DObh({wHB4e1uB}PVbJg~kK8R+D z352J*xTX+NA)4BFZ`|W-xUy3U+a%`uq}ZDo7ylewa;fIK%(&0~&?qwc6wrUg6GoB! z#@hLwv8x>Zd#Tk#r-4_uCU=UvL4f|Q+)rIqKZlZ7hMaCPR%(eGn`^T*I6c_|u-h~?BMp#9Sc;`6WW6~< z8SD6h+4lDrU7hzAG&ZI@s;P#QW2zI~uecO>V^O8N&0Q4#YYt?v#eK;b#s9*J+Z<^b z_0fs&vpcrHVRI4wYBO{?{JjD&KK>A$x#y?oL#5K1Tfa^J?kD|w#~-ABYu2YL{nXn^ zH9OhO0gMh@XgYX*R_CKSU!|G4pZDPJoTBXyIL;T3VVc{*Sz%Q}s`l`{xmfdTsZz@Q zO4_~}KupLSg+5#u%O$&ejklJ(bdih%gPpZ^j|fnp9KuM5Za z=$P6m7O4Y_atB-?*RNr@dwCpKQ}}fD_Xe{+ZnoG1oJoH_XyDe-%Pz1nf57({k`eX; zm};JKNt=g|^b?XA)mbVHCTL?g&uhOIOupU{lMa6;AP;^1s!^3Tb|$GdMr4M+IGfqt z-(tc09*uxLt@fT5qqJnN8L}ctF87EioZop>6Z5>MmOJi&|IT5(@x!7p_us^7=)oA! z^2f14OQBcTPbldiK*C}w0#@6S0G?%-!pGkJbVRxxuUd!ZD{d<3E?abEjd&R7B;PhZ z+>DLaUH}^(?gQep@j$h_S2o_z88-gvQP}tz+dSVV8(&$t7v$^wVh-!tOLbyG*;aS> zEp4Qpy~U;)M4*$C_nF92?7IbGWYgSmuBqdN5xWche5Iv7<6I8>d`$1U&Q51_@dxiF zj8S8q<&?YwK{fJESDjptafLMX3gzeA;eL`=lN8h6sqXP}i}WQdoU_zAwb+}mRus_s z74;Jt38}pDj~!Je6TG5C=@oXBhTkY6g7#=xXW16fsQLe}Y`D1rUkLTsNuC<7-$RaM zmEwRg@J^5OA=#9r0q>aPx#fqDjQO*#WX~91_Q1S>?CIOd`40?!1iCG>eP{AX{Oo;^ z@1*qa_ivqoS&H@|sE*w=F zfzGD7Mwb1V5e_q~M!yp={%_TciY*@+-E^n`uh9XjE}{CHX@aL7wb%2vByuSyp2u+F z+2YA{oqiBe<=7mlj*lr%4dl6NeimyjOf3S zgVSS!`U;1J?p%@DpH#;Gh5}em2sOmV+NAPU@8gKpj#`;A% z{rblG#WVf-xH>kWY%+a-DzHfMAE1$D&bGtiHhzZ6858_zbE!Ihw&9Q6CGf|y;ZHFw zc(Zoo;b~uJM^P>8nReEUYWTRei6I-63{soO z&5*p}WfoT*#W*oSlWeYz?HL8nbtaaIV>6&_#x;BAJBP&TI9;u!6j2n%7FNfvEE4Oa zPHFUJyya@G5e{@HCYy1qh@B!DSaGgy7!^xNs!5*I_ECJJ9X%pMN+V?7O-vGJ6s4;4 zq=eXx)R1c2x5CwKieoxy499lZM*bUK8^2M+6%(MFFW$&onW~At1po-NM8QR8BfOqn?6h=Y3@!cWmvqb+cq9|kB5QIX^Gy5! zo9W9aW%|L)+>&3cOqZOLDS47go)6X&@=Ot(+?(P^n+4O z97tyNNu(MeB(z+O&wETgi*2y|Xr$O-lu-97?cka`X2cgCZj+2G3>f=(r2xkc~> zY-gcSTznpr1b!3mu!(F+7WbxVQe@F5s1w}_tj2Y^4~|Ca^8yXRc5QlJa-m%nI%61j z_?>tYaB+W{OS+6C8-HFeOE2hFZOYpH1JKM?|Jq2H?~-m%(z7nz>y--5URw_1Cm1zHSG4!-^6=~wG z@Lm_L(Z+1g0fZHyt70&M$-BE=JarAKk~?A@*NK;Gu+-YZ3949{LG=*_=zxyDh(x17MnF0_Qt|K~gYKTZ5UQ~Y0W zOqFr)+x>(1)*J85p|*GBx7nC(O!oS2`iADnVzbx&*G^@ij%##%Ki@i4--cnb!Q^AF zYOUSEcDeCkzTnUjq36yC1)`b)3!o)_e7w|K#YtOT;CcaNs!#7x0 zhq`>b%Hip+f0f(IhHtWanLKH)os@pK$?1nTqJ&r{XK!({hkq42p3Bk`W%58;@k?B5 zqt7$GzPO}pDeva2%}yC4W2%8_Uj-pfR#nGd^VaX!Lrh>-g@!q^L#~zxGUVEpI#TCB zLk&mS2>0`&6xPv%_Zd#5azp%qFTJTG9e7BQAp9C}(brp(RIe5qsURFX zFgoOhQ6SA(`e&rNds})+P%@Rv(jQkm!l}r6E_`PRA9NN6JIOf!ak{T}@-$J?uhh@> z{GDnc(<#GfI;e!JDu@HodI$)MC=nndQ<2liy@v)moJz6~V#r}1Vx21DSt>hgHD{d~d;!tk7t09fRWB0jKDfI5Zfd}W?#BN zwdMxz30=pKE2o>8sMKObvdrIRa`H>@0{!tze}YwJz<+-D6F;ni@$pgN*uS`=e6h^; zI(nKY2w#t{WM|@ZO2KR>DSHGXK*It27&@hNYN{{e!)H>rj9YA$paakAirRJEv#iGs)Q=pOofZy6EPcf{!-Fnwl6J8FtVB&2xd{(>^t6xJ!%y~;81_a`8gbq`2LGs2r0nPc)2gWOijW~x*Il&UIBVT3X@Mje9kVQZJBqCj$Pg17(n;M%`CsPhzJ6cEwa98Yt!Jhs@4Zt@-qJ$zRmF?&f zVdI&WR8C$pJGx~jgh=SA2p@iqMYNEY?Buhg6`Il+`O=HVO#Ml*gcLu+FO{1A&1e;- zTefzQ{o7ECOEUHT{H|CN>i3 zVqpMpz!oy$YXF3smZs5S14W4F-Zc%gTl83~UN=E65qWDCi^|=jwe~N^p~w3WhOzd4 z-dg*)T{Y8e z?u{fi9~;rs)2Mo2J_M3qk9KVTfjaKwkNE#p-l}4&Wfb#6&SAc-ry!sVTF#+bzGr$M zvo_{F&3&4anNXi8lRz@A>&RqNo#;KPfuS=(_U*ABsDIYJ*~4AlVD<}os!1DN!KqbM z@~znr!0TetQSUbxf4;7#-phpgdDgrwAaXlFISTaU@x)}$CpSv~U63JryYy)@@ql45&4_S34wjHclH zXcO@PjzZ56`WUkD6BQ$12LX~QI=i4fOQ}_H(s#6(-iN>YNxF1MeLqcq!ZrPAf8Zuu zQ>q^s+T!1&XiW!8KJZ?EXCD!pI`K%Tra8)rs|@#QOh3%dr(5Kw;?yuDg&N9TRmCZ8 z*BVY%&YoHHr(z~E&S^zDhc7Ko71Oxm57MY~cY!J`)@8vKXUKu^hnhxSW@t7U| ziC5x3-9&kd|HSJ7F8&iwLHs8kiT`wwwIRSQpwup_usBsoLSdvJw6Hj(8@j1%H{2R} zt~m8QUp}hBVg;1iWfc~u2q?9S3fGgbCD1h1DbgW`C)JqhOacL=CXpF$U!03~b&7Q4 zb7#eiV*gE6alUtT-#a&pHkGDbDAK)Uw5jf9|0CYiz3_x;=f8Zoce&V9#gzDwVpF}z z|BZ6s-9_G$TweUai+;pCTgSZu$}PB+3sRL8n94QYD9iENe`RQ(gK{S)(>9kq4`;?S zCbm(l@I$|vt+~Q2GFE*hUA{o?H;Z2LeF5Jn7bG@Bn%;cA%wSZDtO7pb2Ckvc%lVIL6TLtGGx~qw zR_Xr})B69((*I=@PEQw(<{CfVy&Ki@_fq!>5#xQ-Rc6M2HvYypuOW@Uw{2SbKjLq^ z@MrU*`Bd!-e-{u=O8C2QpZH4@TwQ^&d-cQEPl!g?U5Fy$Zo9Ng3KLtfKNtPtN74_y zdt)FbQ7}LSZ_h3GR8Y|8gLK(5DeL{j72JI?1%Kcd^qnxLe33SiXSLWxrH*l>UZPY; z^4IH?TlD0hX!ADLZ>98S^90Rgw91>x*lcds?yoEj+J>wn#Mr%(W;^ zi79&sRM&QTb>Ii*5)R--mBf^<_>@1b2ifr!?#_GxTXnx?GE=NMaU}}!vR_hHXTD6? zNzsDo=Y40be`Ri<)^^zyeVJ8J!9UV3nf>`rpT4;o!kZc#uqC#XpAA+>4!HPSI%L5VGv4% zrGy0y%v8f#e@4g=m*$9{Pq<}V!p~ED8oX_YpUn;K2P!UUC3oVb*{r>shx5) zX2s+Ok^%xKNnIh}NWq&|2A$=ldjRkXAId<#qS8>q3Y%Rfmn%X!;mIrOnuv7s6p8G$ zp3YwDCbo2U;1|SS+h#qzJav*%BFExHRGvDDXWL{wy&`o8&&84Umag+-yxKl1+1O`Y zTE9P)QXIF~G){J0mk#ydQQ@Qti=F5NOsv3fj$x-}{Py8gz0@`o&h{wue)& zaZ*-}*D^2Z1-kdVZbeAT?&MDi7};Dt{}v4S^0~;j`pl9^Fui9McRPl$9q6vA*?agW zsA1!~Z!!7*61iAYTp^f{1dP^wsL z8UF8LA@M`W%n9;!r`cFn4434Yxie*3?7Sp3SK`d`6s%ZvYG{FMJbkiil$Dr82u!Ar};ZqsxTp@^$%`CQZQ zoN!m)YQliK&%`vhZPa9N8=(jF>?&L}AgSH4&IdLic`Vm?_}6Y2kUTQ5FW5?bj1uM( zr9gUILRoKQE)PRXkkNSFN5h%nTz$WriUsqcTc1tMi|BUYg!8CZnckc+`%rTk|2Ka- z1c?%R=q?$eZI_P!+V1v$N}pacaRAyjVd%qIS8Nl;>oy=sF5M4$)t5znKOo5gNZKOI zd+h@?Z`*)igD^@YgG84wT{jZh{>5!2(CE|O&YG@%bz5gN`sXXqs27XyEjGxh%N0n| z6sn&>%Q{rp*LNO@MsIeYk)zMUAB#R+icV$%dY6dcI5cPXcf82y+XA7Ous0^{Yvf3w8l9k>Rrex)-X0YHUs(`A+28HoL@=^~QziUh`>%X1ZPz5UA~B?cW;wtt|R{W>;tQdH!YS z^Y+X`(r5biL(%8G4ssFpBS)WSKNfu?iJwTnjQ*JVWeA-oa&;?YJC*frEpPj;{VPQ- z&X+og4)o4_SxTnYrp^fU>z5$ZdcsK#(Sf4d4n?SBHlZASKKfsv&!P3p^@q_fq{kb8 z!*@<^PJ9rZHYN*+ylvc_8{OhZdu`U!XynxO??fhUh!nIrBAWl|f%h^9d08=p{6$Na zCfc>NGeS;&G4y}cABvddKeg>OU3i|Rv?QL)re`R3;jg3b=a@7H`nyz`uR@v+OGQ=_ zSB!bmDX72N?6`@wH`)sJ3x5R1UyV}^DovB5UE*bM=SEnA=ey#{s1AmQm{HwKrT1w0DJGx&Y**==6GK7FzE1F+|eQMad!{h#`+{>a{Ooq zba;Y5phIYbk$*V^9gyFTb-tSRvmTy4l44S|$rNLfBU6kV63!HJIqIt-tGa6$5_9Z` zs>oB_lY{g%>zh?KbT>PrXZVzT<&EaMz@$?Vm-FQ|E~{@?UtPXFP3pE2AvHLMR5qf+j}fi@QM*4Wp`Cty zJEb4kU-&7A-7A)*pDX^H($5*hUh_hrpLcRlN!J7?KiHN-P#pPw;9#1ksUOmR{^9z+ zi@-ccq9l>!c`bkXQ;uA+-K$tOCAEM*T_@>nCr#ssR%V(yc<-+}AfA#hhVx`aB%qy2 z{Mnpki`^vs$-t1`sYyI@^C56dly_ko8k$bOElT6Z)M~Vb9`YlI%~Lf9nSNs-#9>)! zgG1$tA_`SU#<1x`?s*+AhIft4GlpZ+D#MXc316U{mgzsbQ#i8VituPUOV#9nH8e~8 z2@XwVPUsTNmS+!z=GmR1Dg5rZwX?pH7GboKKVgQ3P?7-(B&2!ri=i}UD2s4FeEuL- zp*5cS=iwRkXAVZ~deEuq1cU##`19JzgZQ(>WUveVEP2bYJ0yShaPmUe*mcey#b51n z@mJL;CAX$QYw@;F&szL z5e?6_j>kT8nJ0WdBcGGc7%{L^RI?uXEk6WD`yNY$7y3}Ad8$9KP4qKbjduY6!TuDt z-c3ssqRwMo;rXxBqEo!a4dl^!vjKrt&?vE`M1HVEtHkyJL26jqe`JONe24KkBfxjgUs&LOeKQOEKfVNN(|zK3g@r8eZ~dwx{w(&t(0X%Q z^1iNn(k0Ivic?cFRAR>dfz%<|o$nt=vn+exfJS{d5N^NwhU1TT)fs<|RFs9(k+JBU zfJI@Ln|tNI{$Mtv!a(mdui(bw;#R9B#jEw)x>g}^aFAq-?cWMIsUIt1nv9{4jGHJZ ziw_ttQVE6muk3PswE#})&@SdwT)milQ^@3#za=JzF2)p}BRmfHyt25#pmVIg@I6Iw zXsbvDtM7a6R_4e1{|v7mA1(02>(h^h*RM|%OpYl24s*A*CGY8)-B)ka_g&0U631q+ zJ9FsE7#}3{fey_YA8cr_K_YN7mwH*@@jNA-C0_~pHi}-Q$%_SLk)Ib8LX2-V0GLlz zkI$?TpjH=&xOO}LFfUY=Ptm)CJ-(fJq(WLH<3etgYt%_gtPuZ8z#(lYWoUCVc{SymCRW|JD zxIwxrX0AKyqlnw%>Tj~pD+%loGdL@AK(f0#8re?xs5{Qza<{ZjXrNjAacG#C2<#(F z)&Erxy#~Ej*V3GsgdK!bwp=`K^#Jn^4sOVr&|djWXV&iX&oH%kd-95APxFAvTQ-gxYip+{rb5-v453;kFB$0Wzfm$Rn2)zdD=K?ejx(bQa8Z=;I)r1 zXEFTpzQK!XPK;6>d@jk4f3sC^4q=#8u}k!PvXvd9vMxXVla#L3hS)*ld8O^Kv~UTR z5>2`ZaQNSmwg`NOU3KmmoYT;?cn#{bbEDzRKD;f&Jy?KeQZz^#%si6sTSkI--nA3) zv=HaWIypyn7%XmnISJC)E*!;UH|xl`_|UB!LFn&Z_o3F0_J0<*Om*L0fa*T|hLDMV z+nNC4#LTXs3*f5_;43iY8Jk$*{}dm&Yk&VRms_idmHC11w{@#KUMKQRKfc51cpTNY z9Rd^&2QMfK+Ur6EAc=F~Xg#d12Fh?RPk8Xr>YgSL0|iWCvs4p{z` zBWIG|EyruyMR2WFP5ctjb^DppBzxgoknFc>8S6HV3JF#bfnfW!&P{wC*HHEc@69Iv z7mpms(04Y6Js95;w|7Rx$m12q5I@r;4#xj80{XJP>M5uK{trwYDv}Sx=WW(_z76=f zbHwT%wwqj;O_A(7oi9@XV9vxnCokw{^WQ8(rFrp{?mU_7!(k@+Lg^OP>eJAC%|Cl9 zFi>C{0_QdVBaH9LIR7Q-ilu8^7JPhj@g6VEAAjoMKN%B#GJlOg6uLy|3Rq0IrTqHC zN#i2}N;m2sk;RuP*sXk1o_1P~dCi_g<+&Q`wr@BJ|^Vle^!PGh!$F-`T`x@qQ~O z5G~tGMyNLipjyN{awJfaU1itUnzy?(JyntKlvE9A7+n3N@9+jzzTcKxcf^w(4J7lP zEaPX4+MP0H!G`*LvQCU)|4m-YW$}UCtJoj<2=8rsL=^_BfEuxL7479D`(4(2b6LLE z&bX>Ha;b{I(GVw>hf1-TxYbj3Vs#rxqX#P4t6HB7e9AVH#PykD!c+D zLNHUiD6H|AD;sV8TNITP@3-Pg1q{2;-spjLc_bqE2_1B{yN~Gy}1hK05 zCI3=Z(5stI8ylNbhM6#%|L-O);ho4WE4eB)>v9LWRziofS=+u#QXm5*p7&aAK>taN z4o=6W>1WUXhdyhWvfzCYjSL>oB|UskS3us?kavY6?+TF@7t|G{m&Au04V`yZ#f$q_ zm+y$&^A=RB9=^4@`Ninoozb@4-J@;$FRUK6qdIrDvSmya@nw&iRWo8Ise_KZta-9g zoP)POFIxU$n=`g~AY{I^zmfSCBlF8nKksDKySn+r%VML;Ozfh~`x8}s z0Pbf`*}FQYp;Dpjux*iWYF-yaL9f>xo$R~(`rjc1nRwHnhw!G=ew&J?LMq))({DVl z=1BDArkU6id>a~j>IC$s$^JX+$ZZ_8sQ?f)3tnPhv?P!5%Yo36Q@BT7>}E_CtpcD=$jV(rj$v1=+_6@PWPX* zf0Y1Z_79DGzkRgw7Hsz)QJ_vdFWSpg{px?RvdH*3DNyzkWgyr3u|G)O6ssXEf&VTm zTr6Apa;N$0cb)QGh`ZPn{rop~837**l|N3QJ90WSqa%X7Nu_%QeT?Vu|ca zS(cHe-%}rt2ewGYC+H0K_*HKi|9PK3^8z~cyN}Lc-w*Oq8b`!ow-L{=`c-#H(m9qY-;dmvp6bt zN&A0tBT)-AFcM{alK*!x2Md;QYLDK=mj!N|R4sph?XaJ$4nGNiWJW$mu{Mhxl8CPL z748i``i{eIZB_GnIU{FPm9L#Qy*l2vG`b~GRsL*b;avf7rYX5W1As*tq$*=W`r{wg z(ch03%7|L*>S2?f>h)h4`7g|j1+8<~r|3F@yq2>Px2k&wPomo5NDNTo8XiW=_eJ8* zQG2AZI~7FRcBzd5f8R8kxH4$MKrY{8duFibz|9SU{uLMgOIsY8?xO-dG=?JMv;5_X zEr6l{y;ICF`AhRB_Ud6NJN59Nj0rwj4hHJCyZF(3C1hxZlyqqSKP)cmmJI1)2y7)j z!ki64vM4A-z z)S@x_b16fq?JZ2V{F$FcE5G_1%P-nqywQt$Uh*^itzfMw&e5Q!@wbMspSU-zg_ssS zBAqsWkFpni`CFRo$w{H=-`M|0#g6sQ(aGrFI2tiA^I50lb-Z$RVRE^{B|lM#NCfa_ z#&-tr*Abn~`ky~o>(lXZ?R4jU=~}(^4YWMxq{!pv4{@vtOFFrn(L!G7%@rG~8GW)$@8@=4k4o*)AA-DU#B6`N?pYK($AM5aT)rV1BXMITUoph zUZbIQWypRLk9e4t{~?TH8D=w|LSN+J*vNv%`O<$>YAe>4tgB|itSoL&`FNeYMJe@E zX2v2K%zP$j3#Z0H2$or)6ckzKGyXe}|BqMnVEg?KVfnDrN&bk>X0mjGAWct}PM^YL z>FyOazkHw+tZjbTzZ=8Z`0%VdYf9DB`}BYGqbI{#AqX$kC?bpPB1R*|CIkh9+UU~8z6BMX99U7r}ttX&;BobCikBn0@+tUuEULPK<3l`1Hkf= zOFA@dw_UZLb*QR;huS|WyZy0uTl@Q$(f-k?_80$~_Akw7f9Io)Fo$SAvT!L?r)l6) z%r|~Gpnjr^>VxKuk>A&pP9bkoPja5U&y?JYpOeq{H{*D;`%9t2?w6wva@fg(Lkfk& zR)+G2-UOqe*%*~`W`cj3@VVr)ke(|)0-u?ehxC+EE%1*BaT2o&5@lTvpEmyp);F*2 z79zQ(AvW=J*Z`QL^ZTbWscc^jk>_1r73;A%TJDwB{}aOJ4FNVL`B*pj{Y4+$b~_)*Mz@c&^M|cF1(o^i zt01zfvXI|GeoOc*N!gq1OCQlb;{D3zJ^tlK{;S>pIs`C7zp}Zaq;g%w=?)-ge#fpZ zV6Xd;H$L~R+??FTcTROy@`BcR|6SQ!L&C?Ka{;QZ!2df-;hc#Vjn%Lmb0rRzS-6tp zdH>vE)Vg$zakwE*GvRZ;*Bkf4gcFTSajwOZK4}tRScwns&VdiNo+c{j_BC$JKA6NK z*Vp}N9O7ywS7M=3o22@8WT6gl2<>NyaEWMJYW(Nufm#u^DE-`vee369g3ixmyOA=G zoFs}uvtVTiQPZ*z3rJ1f{c;W;3T(`H-r^6gl|1C_m<@Q?2mZ(^fQskUx#ur#M>JI>Bp?yB?q2#+{$eNujY_(JK0%2`*_}`9T3mF2oSHcT73`!rymSNa{e=%?oh~i_N`qxz-3=7 zb@s(EY5&MJWB-HB_(d~my!88j2`ssBvSFKHI9rF_^BjH!{G;qNY+P3;H*NW!Blmuv zBKUXY7GC&UG@t9uc!X;-MfWrjUv90qQ_rhnSF`XlLDPH^H#-+sRjio#{6pqyt#1A+ zxqlNsQV}%S9{UYokw%cE*kTU_7!efshr*g&-WT}~*7HT;DmY`F0(#aKX1GH33r{P# zE{(g^lGSQDl}NOmtq!as>?r&+`EB`aq%9}PgGs(91D z8|z<*(ZYr&R$2Qx3GuANSv(|kV%xr|*qq{N(RNY>ha?RV1lue!v9wMCVI_79@CbA$ zXjhlN6^R#N$3z)p~VM_skMA)@>t)<&1pZ>*O?2F_T8x-@Hj~iiE$OU(IHlw_{&D$xTLI z^ZWcFv#%51?feu@+aCN^{Xeqs9pDc1FX~A#04OTY>0h!n{eagMP3@`F=k;^66g}g( zAW2~_QNxlH-ZSw)M75T>qqIkc@ zgXrsZ6$Ly1Mk%UOf5SjEhC&%sGZk-V9{ZbqmPtRS=k2`X=U_xv^lPT}fPO`+Dj&T} z%hDq>z{hR}t3gNdpmEe&AHaMTq^GXc;LCyYgAP3AmXy8bbKm8XqC5GqqU`CKsiIqX z&^T&YQ1pyc(WlczmviZV>r~)wbO#&Z)eyxC3@zK5g~1dgWKL8{a}gZ0NP&n8Qe7tgoD^E?zfVU^6CP#7JAGc$Y77F}Bd3 z;9irq(7i6Q*UazBFDcS)^vfvo`4T_A%xVeqM31KejriqPmewQn)qfa;;VFmcFSrPYT;iu2O@ACLIhANXME?^0@kIL)i%HXPZhZ=2r~fPGo8}=-#D7 zK*J16iR;B?7bpRhc57_*caG6eKtelWZygEV)t0(OCH5A5_V-Bv)$)^o5Xoi%MS{%= zMq9-8J_9V41z2!n_Sd-`;X7CGF^)L+0!SYHf@wh7^%tfa9h_=(nKfz+wpxQv(8edI zf5fj-^`D%s|H&VRNOfAjAP=c}te|H9;j98#bbD^C?n%0{F&% zB?aF?Rcf8YAN+~oi&Yd5anTaMH}Ye^H?|{x#tBmnU6hDeWS7K9AzM8aVX0hW#Mcl- zuTe4V)BcuTDWIqPM?ln;yIqV$lqQVNK0gaHhpUSD$?XmFJgX55HuN!2$3U)5lR*D?@hQycZF5%-C-sV zQMoU9TVM6!UaPlvJKpmO@7U+OW81x9TfMz6c)dRGw(j@JUve`On;$VUG0fz>`zH3m zW!E_S;8^Lpct0<33n~xOql!;byOMf6jDb*0Sd{v&KR7?+nhmM`FMkx!)8>ILe|w6B zkp-uPn(hRr=|tbi!e7!}2N{Yi_^%ZH7WWqm@pnm&W}cUUe|$XH?hwKb`^FCqZE)V2 z6y|A!89E%k-N9G-Y0^Z8@^KF3Uhi~<^3gv9KVf69~(lL{AP*~^*^+}^xbDd-9+e=3$)TF`KF5g+dg?c3*3Wl!t#ZI>$5=z$pCnT zhHE79>2!TBT755MSJ9M{IQGN$vT2g}MOZ(Ba!y8FZ(Ci-XZ~-1|C$f}58w|tPfwP~ zC(p*1$kpvBtCI2k!O%OCNtV=g>dT;_qL5%%*P~^hDYBRTTOn)K%c|SvpZ)_(K%HGI zPL&$x*BEtIsgZ2`2V*e@#^u*z64n&h{HOfN0$B!_kAwZoi~iLP-&>swW*BMrKakl; zGS4sdVpQ12f;C;u7-EbX<>LzK`$m30u5e1ZS4e_Lw)AxF0SU_2q##2r2IVgx>WT8> z3hU42SrK&>)nkQvC0v!%V?7WXhW$6LRPcM4p5w|=W@f5A!+%`ZKc#ZY2h=k)sY&I} zyfR;Bh}H1o$^wfDz`9_Mf?!wy7KEGszCTsrF zwmvIkyKyzj8NIgI|HhAPeLLGgJ}$d~-()wS_{JiXl5-*Dq+Li8@p#AsFx7s87$s&X zcs_zOnt^*j4*PT_`1ek?9nE>o(n{EaxFga#ng@{?PHGl;q?$0~dzx7WY#a$w56{bI zJs%&zQv24m=0EmT)rk2$2U#Y5?exh+>?tDQ``2o!%CtlE45}L(dS=X%f`0x9{fElr zU$G^!U8T1p|NsFmzK9DyeVrc=%$6%NP*jD6zShnm#vhI^glwEo9*&a*oXeMQwoUF7W@so@ZwF@o`1~` zSUJE7C=w^ahdrbgLJp)jVhiIzvAgv};4{&B?IWs_dk6ax=e>h$aAJvbmQme$eMEJF zObBnYLijq&n3BS)ktU8B{2NL0qPpA%!i}$L(rio3EzLdP@8IMG z$x^-yKzd-ZclZ0oa5~xff&N|qJppQ(cxzun533TV;x4MTwGdo` z))!sHihDIVQ>UoL)EGb#?_Is7lf?T&l7pA3`f=e=W^I01S4~*e3TnlVy2Ki@)Zj0N z{Y`8TBGm-ZE_f4d8I*!EO@^QhuK?s>6~%8KLg zciWtti`t9Vt3;qh2vY}XwG?^$JhVV=-SHKR>WbO-;QE5#5J~)hVu(c^w>Qp9+fq?B zqVB|sruXZPbW1^D?0~nf6|E>Yi+E`{{liNd=sxo_{&v&A5%!T@$q9NvdTaCTEO8u+ ztm>@|++=q{zlG19>P^(3a&=QYcy>c?X4ICddu3*E%zO1v+5KS8@p5YVbpBe?O9DP0 zmHeDuL>7#-vJO{ET{21~tnKjOQv=d%2hYfr6tvwtvpgwHurEm&KDSpujAWmALBe&7 z@fqakHB-sSkI*S-X>#0R^2zi3G@g;idmF6mVV{auG(M$4>zzE^ z+E-TaG@W=XSji4vl2KmMppJCvHFI=O{s>pz^@*dBUkO2S=qp8%I0r~SGC2$$lP+nL z{I7zlZzw=)DiY@mqJVll3LvV@C@xn?`IZ@J%H7ck`}zM*`t7EUKPv$ej*l$P1# z0XcI+eYe@l0e)V{=re+c0nnU9Nrs>lG7)auIztFxBQg!05IAHCqDq<3YEW5fyvTxh z&unafD2jFsP-4y+R1#p+pNg(Y=iN~13DT_h2`ULt>Q5!tT@ z4n$DzB3s}Ow0)p7wf?mWeo3_nNmI7|&2W+;c_EFV89&iD7}Ki)Ua>DH&TVpGJ9iLu9wY2H{#C#`PY6rI1Jflt^%QB)ln zy*+sphso-|KjOnV`_C>#HGLya0q+ZVGOA@gJHY)ViXnzFy$-<`k@?Li--UKV%8oGe zpc9m*U>{onxwV6x3kOS8q1q0mHGQED8@l(Fx#2Fx)c=d}^cB{#v=fd`Ouw$k=kx~* zy^5682fDiqU8hI=0doX6cJNwJqQzd>_iroka1fClpnsU5h_3#%j?(9UD7R?WePX9x zAJixM&d4`=K>49FhPn<$fy_cqD`*wZu-a@>Lw2`h{{t?4S)da+2`6&zJ%(5IH&)tz zH(=a)eF5WI?YBxsZZ@T?D_f1yPY3hQDnM+k0sx!pPgE{4`4OwSvS`4gCKHdEgQ$3p zoa<&t3ynqr2V4is%HqrT4*C1|Xw>)<~^gG zPj8UGjQ4x^XDOc^0xO@ibk9ZieNpjulZI=ulK0*Vl)F5;+^y+y%vQp3y(#CPq*6hX zD^zq~P&7yrSbAS)O+MQ~(Kkx0!A45S|G4vF2WwDpZ%e9RMw|Dm;G?eKST*<4pwv+g z!@n&|mCC@dR;6aUQUg`$w(L?5r%PqDb*f5@aiv~*o>JvOsUSOM&798KdhZ*Qinvlg zSE=sVrH)IN%4lnqN^L(y6D*skHJ1eAhbAWNTiijh={2{uU$J~Xb}<2dU+ymYi;X+~ zLV(}>RMC?5H`&C^)^#oAq=tY}|EOj)lQoZ%Ko@DDvP6SxY2vJR!f9Q~Nh1GCWZ{r* zY5%mEDUmKKb-oCa?08axE`MnO7WW72U-#l)v;FH{V|(r$r|KE|*MBJN8b3Jt4y7qg z?O$)>Y`ew}j*BeNE|-nwFsu^E3zq_&NUa)PJ70;C)wr?_lo&z9Un7Pf``I zY8CI`mJ8Lgi+{BCPqg-rOn%N9AC%qrP&HnEzBN3kL&Kc^#nd*i&N7-D(VB4sldt*< z67^_BR!>PRPRSuXI_#Y{$C0RePO>gmq*Al9OFh7L3Z~5HLRpp;r>JTK|;=4(c*hLk-qL^@*ahR97wf z>u~wEGXKp|^#y>fu-|3HwfqWr=WkqDJkg#9Tf`U-J?@_v2xf{@ zi&VuwKd`EKhr+jHCMp`uOosC3=a9zM*@{g$)$wa`6Bl4xyUSz`ise?7zclYi9of!i zvK=jn>%w}I-K$teD}R38997Ujtx;A}w(QoOD9p)gY=%u}$Qu_Qc$~icv+UJq^V@cQ z`)cx8`qehk3O9cR&@&hddKvP-(;hToD0*c227vVkZkm%M%$op*~Hb7d9)bZ}W@mzOe?cX(Dezgk_s=`MB?KbKIB zD7N!P7JeU%dO1EqHVF5)EM7dI8b4aWW%1LwxTWZ__yu^R3XX{M4;v}yQLG!a!izC9 z)nrbz>i7-qRpqZl7G6YsVruPW@xIg%6$boH+QWWtey`X}v2H3Q{&AhF>s{`;yRP?e zT^%FLIJ9a4?;Rw}r&UdA)w+->wBNvs7hB?Xxc3J_%Bo6b#Ww<}PTdr7CSY~*=1R*1 zQyF=%?O;a9eSKJNfgW=T$xDlBR($T5Ce8;u3FTo_JqO4{lFQ>mpzNzq_H@{I3xvIZ z-@72}z`-FQa`-ky%Yd*(aq%w|pkl=RE3E}p;K=pVeCWj&o3qrvS?>-Kuc*6R382udQd@B%6mK2zx~)S&J%kl!olE<^a8r0!zfVl$-b z&|Rz>?cw?VkKH9)&N!TA#c8UeB&UvPekSZTW13!zG!d=u@~>F8QF^FDbsK5Lk3(MT zEL)&Vy0Z-4Vx4893EQuNX;Iio9x7hS$BHYKk0X_}A)a^g7q$GcU!7%=ERlHLKs`aE z%^4DO7MuT#)ccga@0u>HY9V99X|a2wk4w>~*y*MA(1EFrqSg{e1|8*gB3aZ?ZnR&r zxCHmt@OwB5=-YD-YXLonmm%Bs(OtIva2-zHEc+p}8X}# zok)|XF*C3)@W@mTCpr!Nsh9OcuD2#m?Jgl0G9tPqNjD>6Zri**)dX)1e+D}t*_S`M zqsHd^uxK*le1J6u*NOYId%H{FCcWFyL z^g9;qQBWN(=67;&Q8agZs67HrVp?SvWq9reb*D;5J^e{X-lmT=@;>K=-MK7IxFzMP z7z9k{_~TIIqwQ;CFHcQW^RRmO-^D-m5A56O@?G<4tIPeliWVg!Of~W4UZ+N0$jFev z9U1CGMZ?o9kxxKKI;hi=qqDAqoHa}n8?EAzIrwvVl=l%O1q#6@*x3CdRpQ4;mnH$iz-!0P2}X&yIuTR)@>20Fu;dsny?71d z$ORQ1NrkH7J!r3@peo*%-)K=)eBkl4WdnP_6YKDl-d zQf{z&SF^@9wItDPwO?loT9W9Dnbl_hr{4?nuRXw(7Noz$uYWIp(v1a!OVDG(Mp;T1 zMvJK5^g~J2%OtP=JM!<9za7fIx!avcLH|4cua|#uL!ut!SeX^b ze}DlmMZ!S-2Ofvfay(U&Op^fb$kUr}Rsm!yP0W5S8NGc$F@G}jj)`)hGcwKJcM z#6$Uqei4)ZOLD34jvy$7n(rX&^#XqHLjL<6N29qK^Xb*5C@2Ys{5ZM2$V9XO5P4@h zxy4;O&%jc5gKL15mXv)~Ro)tj=bC(8KnNkmRUS78WGPa1ms8dQN76Y^)RHs-@8Wv+?skc@PenOz`?Nj%r#X!Dam@()1}4-U)Iknx{fLCbdJ* z3_Nu8_s1idnu~1rpXCrBo-EQ6&8jqOZ=i1falK$TE0XdwCc$n`@+|QSSFq)YoF>O1 z(m*Q`2{$`Sd|xBu{56m8vHZ>J{k$a-(S7uf{ondXUa1qIa{+|cKnQL1GX|T(CaXo_ ziymY$z`RnTN}w;6+U2DMQMSP|vynsz|LXG9k$4`>W4az?lR+s9jFz*z@}XqdFAY>e z+s2qk24@qW|#${Y%WhV4E|8Jb74%Q2V$V zX^Wkj3toP<(LbLjqW`oM{m;`2I(;h*WwHQYZO8(oJj6T2fDzSQ>hiu8#7WauDoqU8Uwz*b54&z3s*=SepG zAJ>ac=uenpNdGV>PYs1#!02yXfX<*MV>F()U(z^yJxA5azg}dXr)~bbE#kvwKgsXM zR?+mI!MA<_{e0^|$@pyj;j6*=LlNZI^y^7E{>i6+FY1D{TX{QHT$}S`PLUM!cE8^U zwWcFS*Ik@%57%8>pkLxYTOoN}#Q*x@AYEafX!AH`B;Bdw{d>tE(WuRt{!Q!y&d6Wu z*56))fhic!?-gpiR7)2m3TUkxsCaBIcJ8x3+r*gHb2Jg)$;$|pgnoLBCC=7HB@fY< ztBeS0iFJLu_qWe-M@5tprod;x84^-wWiEe$zOHWGSUs%GY_8a~Bl2+y)}f8Z=2kD* zS^uiUhc!UK#d*pAL5>Ii`u`?m0X;{zn~(~`=exv>2wXH)Hv(&g(P@vRo)bRMB5O~o z=?{O>&7Jcvu^TaQ@%fR3H_&4O`jn|EfVoyNuLR0gm9Lv~nnuTI!HYT4?{z3|y|wR@ z06^JM6LJ}Nv7z}3z#!JI7e5xuU#8vl6@}jL=e^-Cu-xJ8eaUM(aG^JhY={F#7-6?s zSm(2q?VE*diAPRDR*8^m+hZ>Z&cY!tERFaRDc-#l-+ z2JVuUYLd71@ycI_G_rfEJ$bucu{-9uc@snZ+V94uO*s~L51LR~<9`w0f1bw-CHS2E zW9}3yOx5vDpp>$em6X=~M(Ly2pwIG??CGe${0ZZ%iqry)E*<@5aP!Z(_psg0f8?v3 zvnpeSSq_FQCzq4&Woh|_f5seRqVXzZQwzfN>mRT<`STN{ZR{}#b62dSU)7UFenN3= zvY+3_mbtmsKKW*K3x&;++@!@wOE^Sx>udyc-H7)Im8vE#SUmEza^OBK-&{9%E@!pv zRLJVkzKtde{qz&kgMg(C;myHfYfJ9_LpL6R7Kxtl(viXROSpfqqwK0*1;V=E{kl9w zD);ffE+KWG#PeQUW*gnFx}S~i_Z@Lq7Mbzt=N}3-i7Xl#lhyj);np`D|7K%c2K|q5 zBitVlW_%3Js$fl|L9o*oXK4nx)NYo!Spgy5>_{1(k1!7Z$tGOu$Bm9%S3rJ)rOYJ> zFCcV|9nuism@0H#Rcz>q_SK1_V^a$f-Rzq-0#Re*3ze5aVb=Rh(M@F~k+_)!_p31y zkIqqk;#CMh`8)M_e3V4%?9-$sM}eC&3%vOUavE}S<{rt%E~r0p+1_N{Dm@fuH3ayN zL3D!iEx*Fx)5K`aO_?Vzq8<%-e9W)IU$iV@VpgrbSQVrXQB}1gT8V!nNSoaru^hj9RflPpFb$P}<_x)!W8+Huv#X z9gLumR5kXHGtFZ|t6j^NS=l`St(x2X&(Z6vo8PJ)_IJ5>$Hl5n%g2H4(oVcY50?8OLlp4!JHb{F$c zjx~`%5}QWXr1LUZBBsq-rnCejVyQPA?}XVMaPjwZO@5a1V*@PqMQ13eet**B&f!id z8F;WiFO}awG@w&V!?3Iv?_l#`nf_*ZP&x_=9t!x zu?dsu1Gy-q8&KfyIsq<~?MZSjL>z-pMsAr})VQ_z+-GvgZPu)I(5)5LzaDs$#%ZDm z1%3RTDCnWsj-TQ}x|!!?{`T9Xn(N`czM?V44%OPonegPl(}Tbw^3;!&%D?AXM25|O zQTeBVI$r=3`1jRjaw@Rj6?WGt;R6aE?!BY$!)f{!IXclIc-u@#a}x}QS-~W!_XDX( zQYVv|vd$(oRHm8U=I@ItTm415QZpO9z=-#fdC}NtW;C5mv?%%bH@}qQznx7FL5G?o z0@I(V%w*8fcuggGL9J-8oWsel!~fd!{Aa3yryHP$=rD`6&;RAM>=a#*gN@|hdcsHT zc11dN*&>n=PaoE*yFek#0VaUMiN629+xxQD*3K;F1us6NEHn*xjdg&c^gMPpYTRJ9 zvL|x)25XTZJN5IiJgVzwry1DDRhztzI@kv}Dc6J*9U5+!eDFUBU;RB`tsULH9kEo! z_&^%JK(|fai2f@d+B_4fyj1W`bh;@vXdaK!wnN!1W;;MQ+BcBQfM8Y}-n%~J>Mf+IfxkbuLWBTLeuh-SfA>zjjIifBCnm`I(x0J7rZ~OQu+?z)<-c0go_ZCs|uCh z5Q5tw$ryO+>sFwlOYVR=v3|q#(`f0k+~4N)K|c**A6>u9ki)mwO5B+oCeG_pi8}l? zr{%9U9hqstmxdj^xSiQn@+29<6Qhl71)79bMBAD4>Z|5`czcK+B+5@ghy>-{`{zKQ zDnu`A7^xlpn8-4l?rqcDDm%~#nPHk-cWgB&!m45?MZcr@!|BCiVqYt0N&Jp_6z{+| ztE?>b$8b32>tFehwQq{a^;e{vaq@cDwA`AZ!D#HtLZ%T22!@{1tkB&uJ`n<%JT}Tq zgEykT@h$aA>^M(8$Oamg{I*4!G~G+mA42-qnsG6|&e(Lfej3;4nfpss6>@`?RS$bh zN1%+0)t!Ph`%)cf^OS6On#gRUYk%o}S+qO-y*s6lf`C}Sndqphilj%(;Z~A~u=UCs zXFnppm&YcbVq#YzN;SWdAkB40qtbuw^9Kos^wWOq-)xc3x|4j|aYZ2eXte_64=59{ zVW*}l$i6#ua5G)fzvV{j%A^pmbe&P4lJls1Y(XkD0aVJ~;9s5vSTcTa`=1HgF9?%E zu(>x(BC4UGztbiDqr`U2c=qgQ7QUe-zcXRkSk1TH^Mk)@63EI*H04qH7=trn_5 z)?iE)7(e|TZM3A^6D|SLPRl*<*AR)rm;e69F5h2Gv#)Q&P7u5yyVz^i>`P&@sbAw? zSwO#{5EDAN%ze;-mFD8ha4^!9=@rh_=d+Gl#_Tq~Y2rbov>{J@tiog~JBKCt<8(@p-xz&5k;$Jd`gU*4V(b6c^eyfJr~g0b z``xSl=k#^sOGbXEPzECloGT+Gg4!LWaW>>S+Ysx$*mShZsH^Xj$#+ETiUIAr9mBeP4InPLdX!!@34qREJjpI>E7t^)&eUbwk(l$fl<_^$m zeS42v-)>9?FPfhW7oaWT%R}_47>D7y)P92(@w}HtPR;RGkV;Uan?7zRzdf=**8bXx zTx?0V9aly1j_il@}?YpqDaaV3McYSz11^a^n?_WIcwttgk`>U#swi~F032c1m zbKkusXGI}*^4J+f#3(K0-sVR;uhQyBxY^_y9M0auZXu^_da#hwUn#P^=3J|-PXg!S z{58T*qr8IueUGTu4 z^tq1oU;mJ!e`TkT$6n8Xoc=A66+zrv>yOKVveI(TlM`k7Bnr^mr^%x9WN1!>NzVDp zqEMyn#3II`{b`+rx44-&+IjsV3xB~c$L>_XKi#uJasAlw{$;Fpq zQAX|^iG>|)e$gBLt{3_3%c<}Q{6qUIBHwsQ1@zfPTvU<1y0M*Ll1n0wU%-ZBoJp}+ zT4~1Dftcc|u54)kTBSL?qmj`sQWZKq-rfP;jea6ssM* z=-T2-w8k`19ex%;5locAiQK3E_+|2o43sj^N>}sP!p2db`iTjd{~Zn=;)J#;CN1vd zLQP&Q0s>-dN`N6wt?-8i_zTin3a%kzwxtj@WlNpHVgobDyTD?H4 zi;fdrLp>38ysGA80vJSd$lS&i%LjM|ClUw2qTW<8z3rIZOC=Kxdf7~^gc@uKvHHRq zuqw>P%KI@j*7pU@(Z!cmHtahsd7S@WtTJa{n11Iq3slS;F4W8My|gRxZDY70!#& z8OJAPAp%@pGV^ljFRsdGo{w1eh%7i#%OnfhBa2_;lW6mwnB+&d?yhWHvl&5tO}wu@ zw!M1Tht<6}sW6e~O`R>2ubgpQ;zUY}!AAX2Wy8PoW}cNPf2z5dniZ)~+4$Pa)VD$P zQH$mWYw#yi$=4zaUgo2!_?5ZU_z8<53#+LT37ybAx3b~G(nwQ{^??sZM4B$)3Z&fn zQ*kKjPmowG&gjX}v z2JMZeJ=6aqJGS|gZ+4}s9;xZr=Fp(c`&q<3xXoR=v)kPKJ~(b7abXsYKWL^sOIUr- z@Ff4l$b%aF`Hvi;!#ZvBrVfoxQlnROY;+a-w>upZ{Y{s5M6xVs@6nq&LvsHs*+?e; zCH_W__F^5{o2~Zl=-A#%Y%}j1zvN{d@tYX5w}s{HgPAzE zLwkMHUeAv0-P&b)vkz*||AE8rx=!2s<*p2RW?2)sBdVG=_#2ULf5D`ENYNhMKfyio zTV4K^%NC7wZcb+My?<<${Z`c>LQ(cxaQ=$|+nu4gra=;_Xd^j$mfEk|L_^Qn_#qy> zydGjOg9ObzZ3+8uu`H(o?5{E!=Z}AKvbiL6FrVysVxu`@j<_ePXZ_{`N!?G#-cdt*6pVzLgyx> z(!wkg^ynvLD=BQaGdHJBC)DAjiH*f3X4cTYA$bKpOuPNO-3A%59ANHzJEHQ=iF&aM z-t~rYM8W8HS^C?jwZ^_=Zi^N~9`B|685_#Rb|Zyj@{hrxc$}MgL9{B?<3My+D}&zw z#-KJUbU=j~%5zwl29&#nTN!KG3!Y2Nz^c|L!IaiP-U48_hoK*St&5?0-6{sEZ*+51 z_cY=ddm7t{lqHZjoAo+6=$|Y0D~b8CthzK5dkyF3)SYGP=Ii}MWIEt0kPm8EupxPM z%K0@*jACgbIWhSBdn94#_<4!^#m<%vjCvX=^M4~I1t@@*T&{*y^TtGrTu!+I*C`E0 z`C8cBxDKl01ns1r%HnL;lD6ef=9 z)RE=ppBt$xm}4PwRkCjs{t1I>p?%p4U&!$XT#% z*hmd(YcJHaP`HZQlTWN1x zQ$w$!BBucyHTGR{Fg1Dv^SG+`L&Xzejhn*#CB1*WNL`lRU%{`UIVRfuvSJP6(hjBe zyRz7`-v^7!^c&Cn)i>R0M83Eq{_X7bQM-}qdM`ewcnV>zyHeJL`e*w5wU5yE%1$XN zuPlBUwCrM6c(I2I?};?Im)JMn6KRSsDSlnwAb^4zMKerM7j0yyi=TVb8KV1;Pc3?| z?_2taV_-07wEkK!hk%l%;zEk7Z7Oc( z{oX}vLzAk{r2l++lIZU*y7t5NMNP$P^*Yvv#cx;6zvsRWB7r?9(bn$b4@C`s(PT-ahvFfPGeG`@mF$s_cLfeXzyV;ho zKJcGla+Sg(ekF!&2*eh5=!^kzN~+Q3t(q;09z|+=q#8#~Bs9P{WnGWLlHqGd7k2CI z#Xmoc^^5H@=p_!gkdUw6OTliLP=`<hbY&PomO@ z>7S9*tV(mNqVU@kJ%oC`6=w^I{RVjua@RFJPs6XYTzUpM->vhmgP(SR4#`<1 zS5~42tvdVaKw;#b0|xmH#fLPm#;rNek2dd}yQlh(dmr}KP|1e<6#}FbNly!E4*JT+?g`Uq(2vocn2)ww;s)95sO=^j zX;TCK{52Y=HRkWJ`Hp`R@iIgo+l}m_2d+EVKGKqFQ96Lke}TgeWT-K2DaK6ZQhKq* zV#gAH>2&vc7@z&$ILiY2sX*38k+VVjA(e^Bdi}5Nx>bUStl49=7F|LKy@QqSJxHo@Pz41|N0WAZ+N8S4X zzYE+q*XtVxzr5m<58kUb!7m!>eSN*FTaIX+zd<=Y{Zgt#@`Mbe;-iK`xWqkJ`z?>RU@{uS1Q_;$d5i5k|Y}W?WSnshxv0}N)qOj_oaI* z`g(mM(bofZ?8lCMd~MZ;HcesL{+S7dJ_E9Vgkfjt)9FTv@wcl%WtnWg#e|FYq zU(;tV@L3wF%Fdwb0aX7LRMk7Es-;6+XQ-~&$E$1ECq!qQQds}X=GC9{;c2e&!%5I%X?#1AmL79n&VpgOs@}{7rF5~6C1vNU+;_9e zeVpdHQ;hK;@kL68@)`DzY@D|@(ZFZ;EG?g1_L`J@232*WUtD!1KloU6EsMr)$Bn<9 zZ4vX1R2H%rA&PgP`;%v75w2Wyeup~oHV-MFTZ2w^mnL7poZZPs4vpqJjZ{LUEq)^{Td`=b(r@e@l#ejxl06-}tSmK+=%a(FRb zw~c6B#fLe2B9A_*#}$z!Yf0_SdM^9s9=l6%o{HPVeN&`?yuxc-k(V?psw#G$-LgM!UoB6WF>iI{ z_qV@CyH@!7`Xusr!J-Mp$D=*}Ltg?>g}=A^zuMR4y(iN4ec{l)iC9)_ z9c%`F^Zb94y?!)>8!bLN<;L*OJ1>*GiFJ%wfqe&!nzuK;%1+`}^St=LLZpMGJlu=> zdXNz%J_J)^FlW5hCzp$I+7$O>$}&lP2#d~HJ)%81yz$lURI2H;!_K8jcK@4e#`dX!5xnE4Tdk6nN+8=cEV)v>g+xBdhPQ=$2e?fkmI z7hCl2W3DpFC*_Xn7Wn}*)W*QHr2CJYlf{MWHbqgj4tAT zMNwdXFf(Xc4(l84EX#>3Fb5@I)Ed8HY#Jl5u(09$6YB@adrNTh-ko0C{tFvl%_U%8 zq^gh)s0?v_XX*7hem`w`B>uUd&=XNrQ&c!Nwy_}EZy_D5F5jPWg*sIqA?)F~L1z(% zuzwkA5}yJT+13^Ex0bOy{mP>^=Txr1@0R25IZsOyIBWfr8TBATjm2LpfUeAHxFDb9 zu#@!ZNqp-1-^gF{DKpi0-lOxFKHR)zf8Y-Fb3YxhEAc|QzjP3vJ$Is+b-N$U*y zslWt#(?+FiUkLf%rwIc!lMKnLV{59qQFQvnq2%H&S`KRd*t)BP3BfBQ%pexzwE+RMTV z$3wXh%njl2XN|+Sg!w1wb5#QQ9);Q|&CaK3@Tht)GttO=z39h`TC|KGq z;()`V9OeI3?9us5VCwobTzDdhSv#26w=pS(>S~7<*h23=wLoXgv)X`1MtPg3Ln~9+)F)|7ecvSJqPe zZ~yAw?M)l%Pv?`bMsZk_77;6&nxhwV_DYI@6(Dj)HFatvay>KNJDo7usFd%1DV zEU5#$1^s%q;}M_#YdJl$%LQARw0X6OY7ipwyWIO07gg~dM@F~!>`8re`zB2e+ zI+tj_*SF~*@x@-QEpR}^Y%*w7sBu*Ld})IMf7WGA8?ed84Xs{L3ryN_;h*H+{}G~r z^GE?jUd*x9pYjVH#)m%jk+E^xov;z7M*Q3}kDi1#Ol*tit)B2F=0}|WB+jx2JU*y^ zx8l~oG`H;A48~Re8^*2w<-gkf#_{GS(6ZqyE?ca>NsJ2o^=D@3`LA`la1tmI)Bh(2 zvWa5P8@ckf9RHG+1%KWtx_&~}jdp?k@7yO`!eU# zzAj0t(qoSRt)Ddn{gh6g?B{<_C2+Y8G;RT!*)NtcAJ6;411Rl@D$f2Jc?_B<|CMz4 z0?Mxl$`d?@#%37r7=XO|j4XPP$Ud|_T>ic?9=P?BABN-5{5R#3oH9D{eCS0Byvn#R zYfai83^M99nU9=hpW|~{TBJPAjm~*Cr_#)oJ)NwN=S`gmqpPKWp_J*>Y`eLb_3ba7^QR>#)v&r{Q_%{UiT`{(WG7 zyNL+`D}yQC@3s%<-EaI%s+|Suezm&Y$!$xgSYLN)=U697G6dZE_gO*zPQ}-sr2Q#o z%wxwFnhl@l_rC+VbkX%asXDnv(XK9Xo(u?_`nxgE8JRzhem_W$ZwzIG6===LG$Mmt zgCrq-J4kKx)~y4!_GIs>_@&(M#R<$=u|zyw53B12V6pf3bY;W7(>alp2X6hGw|yjU zNH&H^QhQA$c-@sO}=-%zowhu0>9=1N3yDc1_yz-5ayZ=sQ zRq@Lywjpx&W^MxCsdktEEn!{aCVybLc~;%N5;j)lJ@}8>9RKPAsX3C29lZ4M>DY&R zfZVz| zeYlM@3fJwH)-(&Y2CaAd?3C7=h}L`hQgL6qb)21Ai)tLPGkFr^8&!`1wKwryB%fsj zN9M%Wxr4h?5j3q`kTZBLpt6$Pr=sD&iS=)I&CGIXjh(|I4(lhGS*XW~3ie+MOl&>#gm~Q`hP%8Df~%$w7XZeaym_S=-~$ z(+bC}#Mrd)o3(NOuY|SGGayK;cC2_y4O=Wu@qo6#;}33oKDkK{}U_?nNR ztT~xp`)Bo9cb@tV>$QK$tnQ%euts=~*&WNxIK%d1ov(XX_y(upd*q}~4xgJ}*MFMn zxz2SxE#~ztAJ@13M7BK}{yK;iw-U2X9i)nD#4F;eD0L*OD}R{zdFuRjiZjXX^8DDy zf4N>LUxWC5rocgb zKdk2bkY9A(F!tll;;g1SJ)d>5+V}66n(6n@vrCE_<8NRpklAMSt9@PFE5@-r=DtF6X~ zBJ5v-N}D;fT)UkwhEHRPHTiWZ0UOA#)%MTW7^Yi{aI>E1=(fZ_zkOu_@Z4LJ9h3vdbe(LPa;S()ty`~e)O%1 z_2}uZs8nu^?%ui{7|1NmGPn=@!|~S8OMjyws90uN#((xBH;w@rM)qbmxS&x>&18Ud z+8|Ecb@|hg_|d3W#^b)nRyKSvsy>l8m3#llG3Zi%D%*h*99t_Z+R?WsiZGyWjf`fQ zOjuA;MTS~zyHjMV&M7Y8^5mSB*r2tyKbwO`;sj{%B$rr36Mn%|}!d8g#Y97JkAKIj1(?&aT% z4|iFEKaIcKd)2~=8(M$I4;~y+< zn>#TWsYliS(;L3tYhSMbnZ4UQVg&TXur@E=!~9k77KVz@xt%vI`7#Jx{TZ!y{(UyE zejhYIi=THsHo1was&Z%o6Xm}$(`{d$nZgTh6PzlU`b1B?&le_P71>Tpca~0Qe z<0N$|LOSfWXLDMR(g8@sAg+=qX#jnZr%3q!_#vCxRMQ2G;CJLAay>I>? z4CN@HP5)_YF?ffLU~@CG7n!=0dzO6y?RGRu^XLL>)4xuWIx6rl8zoiL=dxH2l9F7U ze_3w#nBNS>rPy7v%YlKrKM?1`De!-3@`BYHDPT~HkU~-vP}rjV1}P;gn%e7%>1B1AXo-6MW9yyb!&-Jv z=$Lh^zq5aB!5Ti$4Mfh1XHdyQYK$svhdLD+90r zKs}lv+6-7{FX#BBGgZBFrTIVkyl$u&hw}V2B50TrF}$Nce(H_u5bSmxI`r8=9FZzN2jt4QkFc^^!o#Yot7$+QbaSV6tgi#OqB{{zQ#5{DIGy= zqF1J%DgL$<%@)MpasZU+viWanZXid>9)6X1yo8{SDrUo__Di^`fc9yccKdotUMbvPuL|dF#qJ{KhCOuvL{vcI;(S@p|qR{@-NI zMVyjcwerqgsUCMFAl#L}a966>U8z=grFz|!YR1sSpbG}de2trh+~xQqW@*Re)$Nn3 zV&|O1+BpLjpcuD29E?F+COxW1@R%yZKm29+#y9zOX16U4z8_B?jM5n&bZ1&MKhNUs z5mn7S_GvM-Crai6Sn|_SlfU|P6Q{}^N{Q#yvBJ` zb2z#;PB=JFJ;{GQ-TqV#VcGtYk=!T|;eG6a7T{J9^5`lG00}FMT~=Yb@2INSC7#Zv zA2R(2Z~lgyN_nK#>#BfS8dr(HIaQG{Bq?z&)rM6|^@uH~6gpyhzlKpcH!yTYn(pSQ z^OLZF!hVJDI7<)i7fe)LDKXes ze~=iM$%(61RY;j7C#mKfRnoY=ex#1k#5wWV&%@*nW~qy`{c!`7D81Nim`Sh4Zp$!Tgk2olBf!>${M z0+@-1v+BFkjiGl+-z=vx39rv*%h6+OWx!_gYr3pzlB$9$QtE1KsmMSDlG72bZgf1V z%hE$tn(#H4AB+}98vp^E2efVi-c~uo{vh=au_1-Y--0hhnT9)$&8a(YIgMd=%BTeJ z@7%`688l$!&DE{^pIK#(%c<|#aA!$Q9T^P9mM*^~sO4pULWe5SWc*TA1tlpHWO^xT zP6HXqbS~^d=P`DiuC!0xjWGH4gQe8D&%;Q$89fVpO1V z3-fNW4StMmLF)~NLJ#|)L)~d$PPUp?x=~N~6{+S7{MH98%*w=X)6Iv#Z>w0U4x5eN zcQVR=pWKX2jSyd$hUb0?X7JgJjz-i%r0I2P6pN)7jKw$iRudS)0ff^IMFYPqyLl9N z(EVhe7163pI8*haLQmD5L4~D38&fl>@W-3LFZ9*mv)SkUpk?6x8c)(VAy zIoSuWk8%s4mmBuYENO!N~tZ+qb|+Rb2n)3E>eoAkiS8L82xK zG$?2yL=p(PtGgP7Rums7h#;U55}*Pa*aX;yi>ca{pW1(I)oSar79l*e2_R1&0W6|X zdHJ~Oq9R&>1l|AlduHzL-Q5I`Qa+k{ckVpSIdkUBnKNh3RLzt+aD^8^5$kIOG7C#q ziY`)p6QZUzPDen7sVSHVe<0iqEaaUDwV_i*t>ov~&&IM#EAEF2N&nh1*5LcLf6y$8 zY|l1k9<+eRv-+l_T4Yo(%J?@2wOa5Bd%-hnCtBsql*l5Eszn3?JR!JwYisZmTsIw< zVm?@iALk^eWIAou2B-8#ctKVuM0rBavenXB0F3^E25l_DxRZMBtbUbsx~u20A^5W^ zd7@_R7_Lr7*h3ae}pSn2^X?v18DGES{2&*qM+=3HHZ z(d)QI)LDC`d?c&FJ;QE`!~N;ibRN*0j&g@dRo_~fQJcG2r zm%NkYis~m8J&JUMcsYBxbu)elPtfI)Wy8+Y|%Bsv$Dh4={*HGH^2 z^E20c{Fz6*;aI6Vk>W@dR;AqeJLh06q4K$^2d`0T(JxT(3cv)1B0b+ce^(ePJwH5Y zHRpeXn~XFptM!|F*W)vrn3b?58K1?rYJi-hO6+774_7-8-Mj*sIsZ5+-^PoA2S|W4 zAq@@lfA`3WYy+4D!MAn7)eCRzX?_HA+ zt`kI;Qo2Wx$HZ@5#GHmFY=t4d@PCP80HI#{*#4t|KZ5nv{yFa_G3XxQsm|K$srq#G zKHM1dz$fI(1A@R*SQS5XI*NA?biyQ{yM6mY(BF6`Q3=g8gFp@Tc?}W$X)Q6|G9?73b%b7H;i~Ss8BVjo zGB?hWm1F-Tx$i{IRNEEn!~btw1PWyj2l90fZO1^J8Tr*wSqcyXS!x#bZBYzA0-5|b z*kJdMr;8InB_jSC@q;6nbdiFHbE68LiGoC)Ul0^08aZ4LnmGH-ikUs)%7%(ci&(Pf zK&iz}hOA#2$3}uK`ieC9IZqBmk*Z>5chm!qcdZ_GLQNuy%|}|T=l``(4;l0T@Phpj z{=0u9t&OEwyZMAxpGjHJ51#>RTS?o6AfLEp!}Qo%ame{BsFQFnUoEw9YfHU3t8Ykg z8`mQ+V?N{fd{gMHB=mNL^#=XgdNuop z-p0kv>tdk-?Y>XGWS;$Iz@gfo9cG(417P#nzylkfK22HiKLWef@Fyutrh86)s1d^7 zPx3d))#54TP~a7&LGo;rr@o^Lc__D)K+bPvw{>8C2~B|8&Fi>>0UIwuZScIil@j=qH2FJSe1D5r}7- z*;lC|XES#;_V4)_miP>q$Pnvr6L1CYX0` ziYA!(C<&IrJRlf+!+V~0F9`PMBo*mO3RhoO;;jBPB+7kbpjes1!Bu*Ggw5JyQ4APq z4yuBb@Xne5{m4=I8a_IfJzjx_*^er*7;}yEp*PIJcWl#@wH3oBR4AZ}VX1~TM9RWM zoSU8H_)pM#K(tg=p|3iD$9g-ALgEQN)lHiZZHz`OJpwiOVD!BD9-y{9F#pv&^%agV2z+mO*#F`@ygrVs=CGI-)l7&#)ea-#@SifoUL;7+vEzKE88!-^5Qhjzv+u!7-w@JUO^&kDkVRJia$Q zIlJA}m$~BWJ^5=r4)$GrBik`bt9)as0Upla92yxF1kbz3V2bV9=EUSuJJV< z+%8!;h06le4gMKPooXEYk~g|}scF4=Kb0|*0$vtM$V9aBD7`J@SYtH{R!@dMS9huL zu!Nxbpnnk4mZB$x+qdSG@Sc$dpg#`6JH)azmPqalbN*5LfKu})FITd2mU>tG^&kkO z$3O<_%7)O)T?I`St4{Mq*jC8c*I~=6gX7^fj%DDS!n_^jIHW13#l%~--kFMhIE3ci z6GW(rLdP=Pakb6q7`~CXXRo55Hyy0Wn(w3((AfgiEPq>()tj0%@Jd$SbjwEs&vOP!5iOUeR zAYZDiFS-_2bx9#`!-k}hK8L4)c|6C{z_J>i`o@*O2|A(J{XqQ=fDq?7LNy zxPSm)2T+8Pmw<`EMV^bKDHDNUtoZ>&&X*$AwQqWU2RCwd^TQS*&(rbAe989x_}KF^Z$sx zBsO~fLj8BLesFhWeO7zxiKS{%FCnpVBFOIQD^p1LWL{lyo3k1_#JHbRw}&|T0f)#Z z$NXNpMFv-``a;vG#m2C~yIbh0T5$R5tj4*6yAz+_6M0ql;h6tsbDyiGd??>b-PPCT zy7RBfoQ(i!$=S&WG5OT1usd!jOgW#`8L1t2PXXytFach5EtP4U1;_kJCZlyT`9Dc0 zQmTveQ$>C}=N?_;jF=+kI(DgnxU`Ym*l+hBwV@KcCs;rbx~rd7#KH*ceupnO!8G_WpV1K8#_b=l{DVhE`~!j#WU)z(W-0W7xOo zB`z-jynM3=%Ox^nAcrV@DiQ>Er=d_4tXlW52g4g=P_TvMPX^ zbTr+jl#*_#v$l^QpzXq{w)~jQkYL<>}%>0g=NqY!E09OgEjDpo}(x$omybx`! zIs)1xC(Eh!+L#g;`oh803s^x7?q97d8{mSn;XNEIyU?66fVIPoL|XAlBOBr&-!X+o zwoO)m_uJM8-l#YGWLV~ub3$(!c#EDQ!)q%}^SS28|HRCg;RTkc9{%6LXcIGms`>LV z$N@`-RQ}WS;KhkTKxw2_40|_Dyq^&`qB9~(S2mV+gUpzSWY~WSXhulA*~)`aGl3G0 zstVqVkl~GcMc%zb*zmx8c&`x?A*R2@sN_JAqdqUVp(;2Bq4|<$B1PO`xAUC4F>ooe zBjcS&R?#GwT~46kPFLKwMkt=UUTXHSW>7#@CqTUuE;+y%Xr80IhXBkSjBMV5iFjvF z3?n&?g##=cOdg3;AtANFT;*HpmHTpyWAQL09@S^oi5d+ltYG_$d8e5wX#Bor^)*aiIHV1)m59|{pIp+Nag?u=H1mZNcnOf#pUWW3%Qik40nL3(3&%w_&&_BFQ z9j6vTPtWop4g})FPR*go#aG&K`e{^z`xGuLP4jKX@<)g$7JO(2=F_L)Cb%@TVxEcU z_A5H_Esbv}d~3ru+TIY~ju|lr;{H0kMT;r;#~g?eO#UyztW5nk4PB!2->#@#>%U5f zRH|T(nA<8SRG|6pMpOJJ&T6Lh(twv50Ula^3bp=W#Skv^A8B+{jTQY5QwKq z1WC%mbf)|duy^?jCL5`*$XtdCB9{qnPbjUwI{CTyEpg@}g)$CbNE?m$4taiu?xW67 zC{?CcA`isl+mgCeN0EJ0c>#i2qnHc1$4E=cU5^8IrqiG;`Se5*sT>OjTEqSHt1$0K zp~pOYdj((Baa<>`&o}|^)O0w&=iGJdZ>XXz^)N<3`f#OCNM%Oy?>noXtiwFg_LMaQ zOr-^^oLDvc|M62;yS0o^I;-#p;;WuI=v%74vCT=;Z$5J}rCRPhaE+p=+Hy9pI;pC` z^o6toz~-R!D2U8LvS6O24DyTO=KIsA9yy)WxKT|9DV5Wu7)$+sF#mRz49-e)FgTA( zvbp4H2AW^giEj|IPHX=e_DRQr+qL|V&7(Y*(F1v46_W9%!niIKy)poM6T@tLaVhOW zO8qsPUT(%^g2jXrD@n2K)1m}1j}%qzDx)jheynh+FgZ1tNznON1=U$DE?{uMMuhnl zA;Fc=*hN*b3jF6YLyMyZOsoj6#+tbmlI-UWNZ9vVtlLQT7DbH6q)xUGdDls_)Jj9q zNOU}@s=amDRs_*kA#ZW_FqhNxN^qnVrZ{k@g=QAK%Ym0{yu*o?Nw^!T8C+6~p6G#} z#rZ>Vn~9$(j^&kEU6C}t$a^@ktdx(0^53^ctzQ;KP-{m=8@2KwJb!M#h|OD;GQeXu z`B-t7wP__|LoKakq9h}j4GAaHP;31^Bm$!(J4Sb%R721@UgA-9Sk#QvPnX>y^P4&P z&WQLE<|NauPt^EVwGvoX>v*CcXKURx!#Zt_P#EyGtG)`>rlBcjZJsE0Fyfg8j{OF< z@CbXhn!n|KL0ry-@Dp2XYGdeC>OYo!fAo3i9Ix2-b6NS%JRi^fod%^GF$%3#j-F$W zqvvb!9yINv&9|X;D$i*Hbb(}hq1Ui&IK_y+u`!oCAz%3 zkB*1`!rD1Kp?WMWn1wraHX*v`@cxZ%<17cR%DkfPg74~%QLcDQigHuHA8 zM(g8dpU>>WhlI%RFKN-Tu2`J>r|);!V)37MT?NEnVbXBJc>r?nNc@Ze*mptPy(4Lk zd5YZ=Ff$8$Y8^*V553?W^aM-w1sBuNMGd{;teNA%+3;4`u3TJ=f!!_}i_wXFI55yw^Xg}tgIqrrlY?Qs zwL8jSbBEPohX-fOmrEOPl#p=^2LtFWhn>d#L1+CJ$pB$+J{ro09scJ0G{BaR@P_>c za(tbEL1aFS4Q-FFH|omAoo|y;aMKxJ#e4o1$NY!L{pYb)BuW8xSk!JfoZaXEp+Qxt zZgq9hQtUW@|J}YX&53xe<$_i0|Bv%m3VxZt*@5oe0|Un05e5te zpAm*HoBa;)Dhg+kxFF~a(9V-u-T>_$X8V^e6}G=LiEJ-1RDngI6PL142xbEKj(us4 zz{MD|slFn9MC0>EfQZ=ktc^Ydz+n48i>?bRciSb7|LO?vmHlO~&=y6~%#K`uLczsF z4(_Zp#JXHxl1DLW0;Jn>C<=@m|06-MVH#TLCv|0(g7@C{;BJ=Yty6;qE zgiM)pa$#-BRDS8i4CujAgxw&s6A*G*j_BRs2!~EAPX$ETICdBBc(|TN)i7QpQm0cD?P#GZF7wE)4W{EcND;B|Nz z`WvL`sDMfYP=U65#|ze|?5$o~`93mh0Gyj+P#$!#p!|LC{#H;95rU5WM$gCX8DT#g z&4afVdBS3c!#D%eAVxOKo#w!g>_SM?p0NAbC}0p8uu(4}KgMeLk-_@2p-(52_UVqulNce{@O)?_S-)JZIwnbCK6LX zm;D{upJwTRGAR_YsE`(Og6_XV1gXpSsSEK$9GLCqy$(Q>sQD+}w5Z7dd>n`wE9m6g zzwSHd^8_|y70i|pBOjO_;_gW9nBMC&oH)jEB#63ZbaX5mnREu)hZ~%lAB@!B_9w^% zXAsaqCYb#LkFG4x)RXG|yw&mas(#>$`*#7Ae_{qyb8C8@UV025A_zEh?T#V?C z{v7)Zq2@O(v~?d8ay*z-eL20u#4GyI3ibd*MCG6O0ya;Jn=zXmgbu@0#Gp=H`yr;t zLw^JpAQ>~4SXOaAw>bzk5&eACp8-2g7(;OVD#(!tur3rTOK0b z-9kim!E03cNzp4(g&}6U1vlrCXahexD*YV(B$|xQ8&kZvI_WXDFKMT`<>$czToPOC ziWuE&!SupKhWi_%KLE*ggbnH~@vjwMOz8&TS*R4i8vT-Gt~woWK&23yyJc-;qW}>( zBIBorInvzEs4|e3(d^jT{O6pD=%#UT(@zsIW~91*Ax!k|=KJH;j^9w&F#(OIAt2ngCGp)onC#uo)@9!t|m+Sg_v=7&hML+6CkTcXj0Jffv zj?RTyXs5?2*wR~TM?9^)O_LwQ1zEY}hyz_%W}z}yHPv1>h3OBjU6~rsaq8n&*l1@U z_@qw73yV{_NHC?Xv%fZ`CL*yA{wUj4VpPUChVLk#oO5TUV7xpSB5Z6?K&!qMCgS=&bl$ydX!9Ukohh z%!EnC?|8(DpK(9_#!ED=7cYcnZ9c@cHPq*dSqX9FN$ZCt6!zcb9}OA6+~v3kF!`C< zaccaVt0XfpnuuCFo&Q4lQ4}A6L#_5o&b#bs$WdbL@3VAYY1O`E@Cv z6K?jruKmK2E_ifUSb{j^u8s%{3<6t_oM%A-`>K(=`_kdTCCqbWE@UNJggZZQL)BJ*+rFKZUMLn!Iwsz&sCkn+=^Xlxe4MT z6{R`>sNF(96$2{@nt{~jp!qres0En$_VzV+5J8Jr^a7MzR_OE*0_yr1GjzXjG5=Jipg~k)V-WGo6@rcNg+bnPrZJ>bcN{ba8 z31^NG@l>af3&MJ>`Fw+&QCW3{e}=`awvN%SyojZ&BmQQv@xy0Wjbr*b+`;+*dLO<= zpo!5Gj+agN?}iZnc@JmWx$mq#t#Y4v4$P+d^dJwO2;<#)Ef{apwn)ZXf!i8nXa*jR z#ZTJ5LbngzBYP;`6P6i)q>Z?&5B_)%+#6~46*`BU1G3G_&c>)z#E&Gk8XtqK*2C+E zz;D8E{P*oYcI@_7y%W>l_V#~G4>&Kce4AA06M1 zrvn5K1b1WGn2H+Y*+ejKNAZKx^4zNjY0 z@@vN9aKvEvr4xy4Fi2lElOti`J z{F@$?c|@}noWw_y;N+RlZ#f2bw7KWf=AP&8t!7IZp9LZL;62>FJgcI>eFjyo?l=gD zTyU@J`5zuxF;c%iAet(7GKaM`EX|x)2#y{9TSc3Vps$clQFAA~)5`q-Lwnh$a!o#; zK1j02rGv#E$vHH{=xzp<&>zR(G94OPG27RsVg@$95##x$veB4k5@vLPk)=9y6(^p z3b!d#H**owExP`K~f+_VvmD-1?m(YJu)3&!t&tm#nAe}jH zs1SD6**3!FDNBMyScxBOQ5KPg6=hw4mMN<&b=5qDi(vqT&$4$}rjKm@OEEN7^rdfx z=Fd^2Zz;(#fd^nn2#|Oo9!j+_H-D~3oD33o;`uSh{B8IeqA%Bi1O;rV>01IjCM$qI z15BtEBvv(R5;HiK`KpM{O=aWQcA?O@E9575IQ`J4r1ZeUcwh;kc{sgZrLJLWzD4Ks zRVsBgQ+t!nXBLsp>8G7VI*SKUA-R|Vq+zWAl#sXIf^$bH`pS8O(64&4(H~1~8HF5< zA%@-}ZRsV7@#B9yhU5`bl%jtPsH5qhP4qKq*TW34w)R|-=KWqEDO8x7g(_Xj z3&Cgm_6hfWibudHG{Gr?)E8CiOH92;_}}8cr_`6H`6YvNNhlQlYwn@=FA0l$tfw}r zAsx8|bt%phg?Y;Fv@Jvw{Jc_D!#{@nGm}VwiI!#&GxCv*fqb7T2Eqv+iN8e-`UcrT z9Q2-)5$0hBfqSGD*w@f+>M%WTHBQazNq5*mPNm+-)IlNUx>cp###Ah_HlqJmT`ugkwEJ<`YfJ=t z>0gZh0H>B3Vv$0^rHP!>QXU+n4ks*MXQ#jD{NWj0<~)B{D{Q9v=ld{!<*}I(HVD?2 z>3k2q8EaxNw(CcZ`7eg?18ay% zF&ju?M1e_A-A`IjV`~7-Vqk4G6M-V+8?n5D?d1uUYDitFpmq{!7t$4momFZVriL-> zpi(F_=cZON93*vEBr~l<+VYsL8 z(CP~et?83h>J+A4!v58Gq>oh}#_@yn)0%wgr&Xti`YDbN78eft6jqDC;ad`)^J(Qt%)UMwo z3f$>QggdO?y#1k!ym#=3(r?zPFYEY4#@RWS63^7`U0WJw7Hdk^nm4>|N2~??CQ?3V z(BTGw@ij=pZkG>NDp;I^B`hC0tJE$`4am))L&7d=R)ff0&Q2 zj)2`A#f*yoo&%^_zCoaiODEMU$oE1qw`ln;vi^MuyJdQ@t*zzzEh75TDK%0je;^$& z1&@GB$p^KfyjXo0zz^7C)zYu8O6|u~946RkE*dD88A5&%YEgC@l)2rkFj;uzarDkiR@70wplfd6Cs>>rNpzx0zf3m*N zlf+n#zZvPVPdE zW85#?I{ZTj|MIS}@UPt=@UO$e2EUZ+X zpUC_dp6)Q*@^L2uhuhfjaO+YIud(zv1$sO|ze)xgPSU4ueov6!f(L!CEd6AyN?ylg z!SkH{?7#Hxa4d*6{rB?RMeVgLv5H zhk#1m&s5>dt8#@eho!c}m$CE1tYvnL{4LK9k>krgKPPj1{eeDWz`;I0k5zDuBV6J6 zxvxs?$JEI2)mweZ;upbV-Y*1?S#t1YP1HPK$p-iY0Dz0!5Z^;fCX)l3ab{nu3LGNuZ)UHeFHriQUS z!QM14do>1SwW{vLK2-f@o8MZnAJB?^8tg;7aaTKRY&F-WhV;uA`$1a;eF~uu+Yh$B zBlvH_!-nY=mHHM_1=9;I6ij=kg!(la(^l*U!nexccEvwh##xwG8Qc;T2e*npJ2}RF zl1b~NvY)K&cntg%PASC6hX30Ne?08?tJJrcs_?%+;V&^iW!^hM{LPYATE_bL_LG?T zBea_BPp-ZJQ(^S{(Ock7&m!F6`Qxj%h-3QKctp(~`_z|D`9Z5KItYh?xG@#E zj))k#Sny<+({PM9EQhg)l_C0-e~=}KBGl&4kCyaj%#R`buxkzdxqU2t!xX&5gg1;| zs!Hv|)X4cUQGH3`7s2n2Y{74I@`>U1$V>kPe#hSbp&g$ytlj|H^j56>9^0v5`@IUE zVBcXYu{L~YNPtBj=K9(;91F4^g#9*FujV)N@9h*ZZ&CVhNdBdMyIFYSARbyB+2Ejhx2>*|omduSJ zF0lXeqMhzh^W6BF6Wjlxc|B}j7ITm`GT?R`?Em0|6vvNkL8>(5Pd152*oBAQ7^8;# zoJ##09yI}~1Y(Iy|FcT|3p1aCwYbpNY(AHSN&g;4T~5THY+m?+9p9Q08$T`2?>WS+ zSq?01DvO!l6BM|K1XpdZ(mwgtM#1=PJR;}!wd%txe}N2{pfap0{In z!t?u**!~Oel7p+>tsQ_IG@GmQS)0mkl!^T`+22e(LtszOAnf7wz@81l?|bpE>7$J* z^&_T=oVYBD9hiD?d`og7)|g=4jbpuGL8wr?q*WoPToVoA07{WyDA}Y@rzkM4__5Ukj`Z!6B zF&2GZ`$5sCkn~aVbhr<@4?-BadXeXMCMv=xJ7SmeB8crQK{NeaqNzxdj?}N$N#}oq zN8n;h{;PeIed^Pv{G{gpUcwiHc$_ANFOIb|5f!f(T}l1g9F6n3QNtmMD#hYY^qrk5 zA@xA+C)V+!+gnchbN6#PQ}+{B;0@unhN#nI6X5t(jIo9e#fw_MJYYIW4vyo-Gw`=Lwup z#ex!d<_QI^PKW0gM#KcQ^KP{y2k0h5Wo5iE*`JsER#ujFf;fe!4vttjG|Mwd6*#^- zi`s^fK9bEN2IDUX!%P{H+SS%b-T54jTRyUsuD|8Wi1JLfP@?z;F3;VV9c190!zzMf zs97U<&_Bk+nagg);Q<8uiX-&kNnpL#vVUqmsPVcXRu1are9US4GsJzhl+K=*>1f;Tt9V)%|M4-($3{ zMIyi99|rJ)ZT~~1_G7Br|L6gzjnpax$%NE8(fto)QhDVs z3gZ;^3UpuVD5El|bOFFI-J{p%w)q>VW9!F4IedJg_7Y;1Qt`bjj$Oa7$mM1D~>qxA`DcbE)GI!`nLSfX1pPD@=QEz^LLR-9m>@3{5?pe z4rZ$8p^u$O{L>#fMEqM^j~|N&${w-o$zu>f*&|MCnGPK5V3jhSdc`??*M>E~HO{r6 zPCe@Rkm;}JW=C?-NM}L(fnacY7s}#n)EIOg+R1^Jiz$Q-^+?WTk&qyWs$Z&dB&*Dr zu5v>eLp>7t!v2}wM~}@69&5`#O~;z{)}`P8RmzHNv}caY67iQ|=NGmA`6oMR0xw5a zui_V6XVs4YCn?VSt5XnvRnURN%Vnhd>h9)uy=DI3iS-`DBAZ7CInXee*QTxDC1mEi z$OAbT0fc#GBmj#e0dV57nfwmr`DmE!_IE6Ib{wC7b;t5vcJjJ~8 z|7ofP-e9n%3<=Y;S;91}i$Fk)p9ip3*KK6#HgMB27x1899_NfgIX_$?Nn+n*I!>m7 z2XNfC=bO;;%12=RwvKwAnuL8@sed)TAV+rO5KsnGkJR$^5-`?(6copAo&)k9;5+0U zrXtpdUV-jbfkfy8J%7!*uSVT7?RA^;P_dl9302+Ms`}3?=sm)-Kz=SwqpC)o16k)K zsB=I>o&6NBIB82TaF~)Eg=py!kfHb$|3q0n?A(NaOIubfLbUMCvC~qg7g!zkSwba=mfO=07KqUxi!cZ>@L;cOx zT+FMz{qxvYQPxpUS#eFvR~K5^FnG{n{Gz*R<%wp_mW zRJbmwmDg$vgWpTdTeAMzto?RiYCF9DRB1u` z_n&g%ER}$l90u8i$mxgn5@e^*^49wLJ1%9a~r{0a&Z@#tW1>zZMt-NJ9M~8bXnV1=cUB-REK&p2` zZsEeg7ZZF;w>YIgwJ-6=rZpf$4ku2%sBR52t~>voscQn~;4!TW>E1OLaE95Cp#nFV zZ_*V+y{^Qo`MWVVv+3K+PZz);CVILe|7WU2OyGB<7Ohq2Unp3SiN=M1pb}sIQ(Dd3&lzzA81}{)rm7#xaQ{-U9A{m5pu<&vxCalgr4-fjQjS2I zqFQB?Vyr=Qq!UpkvaZx!d%ktv#p>NLd(bVjZX~>`vno&?QViKqCNcO1*9_EOX5p$8 zwbAEoYBwjtX$&|McP$-q=6^dCqMGdhvH)%z*RMG0%A=^?DFC@23YgDA+<;uH5*`Rv zH073k$)patvAi{9iB8`kWDH=5%7cOCMmVV)gTlT?k453-= zD3w?<5#~Oz3l+*=Cxf;ZW=?^TXlMbVwhyDM+WMulcF8kKFDbgM)JOINlh%LJ!#(lc zxXq6Zf;i|I`MLf}eA~uvo*ax2*g@Pm?*oeR(`qx&^h$~vh6l&A9DqcgjZqHkTj46E zuV4-|fUw4|;(7;8tB?U7O7Bu|sPizsdWZ^>_djS>>1?q`!7i}Ks2iFQQa>@+PiAE) zYmQ@PImrqSr!)S@fDdwPQXh4$ej=*^EsuwO{yTgN*`ok`N?6Myf312rrZ@dphWn8H zr|;Li6+0<<{yQvKEz*}C={q6OpC;1HoH;}pLUH+3zNu}7_gmvUv2SyXMgU5**v$nI= zw^04VtnEDXr89mriY7aA4zehxGv}mj2mpoa$OX=w<`4H1BjmQ9>;XTRdx%edYcN}jsv&g@m#m5p0*g*34N2PDwxL(R8%f?3Zs zoa+Sw1(;|^dioE|v6yx{I2MqeZev(mcYgh}O9|*JOu#MV3|$BTe#ysRgX@0Dp0eh1 zrA9DrD*Bq)HzZ~B$t;_=p*SOvz`CnbH)8MGmH(|{{t~bve!s#k@%qn`T-CGtr%>$I?rO>GQZ^%0uhF;WRBVngGZfCu9l%Wxdm%2UC?X=OL_#bW~G zp<{C=R4E>;l3W^E&L_+jz$$XJ%q$op4^gKyMj&S9)@hKIR(;zowdNOu4pU0?&ED5k) zIZiz#tY^|O>LCZAo(Z}h(a%7tmhelm@ax`EeeAKS)c|$Yk3absLuVb2X#l2&1FPnJpJD+kkgIxB zia8#Jd~!5_a>|XiOBHvkOKn#x*1m>yH|VxxsA#5_)Azdo-K~HQlsBheN0LI5g7}uJ zZB=gF061OMqNqSMVz<<)8;!Whc#`-F>!HKzz%^Pb4!$0AxPn)`S@X=lcY;g@O4K}) z6Br13rZ{AM4x)DZSBl^{@MY%Oj9gJ2^2?FK*dfuAR|T^_ZdDqZttS3nW~9TYQ_km$ z!uKBBOQLlSwZE{4%|+;Q{<|>w>7^0pr=4nj_Bkrl^V5@r7jmgip6W^{r}3-y(3J}3 zU}FpcCzXDnB94xcl+u-j$nG{UcLyNowFZo-M-gAw5>lFV%pi0zhb7MH{r3IQxXOqd zk{hle%;BIylEIn`Af`650C>6rPkn`4jl3Rl`3^#5=iW(!c{`FqL>r){@h6dHH&KeQ z#-{y#^_v)KQEA9jCj589^SWgTQ2OsY456_8D{BK;Sy>ANSt+SGnBlz%1=Y4fOQYrd zu>^@OZ&No%>3h|LbaiRQ%g(IXQiiM*_)I=~CLt#=xu`>1^D|cx1L-xZP$M>Nd68T9N}`~Mz>l?4=qqql>#$#^MOROp2?1p$o0CDrCzvV^Pfu0j zoLd1|yJ@h(Dmcs^1PFyexQ&*9ifK<{j0o=3nMo9P_0z&rz|T|lsl#{`Jb)J4JG>Qm z<5yzunYf?pH4n_KsG^pj<$Q@NCBn-#7uH@_vms8utG;Q7I|rQy0l)^-(#@UI01}0l zYsl|1lDatS4=2Marph$9Cp8R4QIYB>8o0)4Uv95J1R4x~q_Yo7Sv8()B5>Y`<&*h} zVo(21h=-1xEy&Vs|fOQz7n>i|Haw%nu zF~jrQ(RPjnjfn*8X_0fJXq8Yjw7-#sJ&f*UXW?(RGVVd0S=PlWk6%3;RbCFl;9A@r zFcl#vDuvkscUf<4pWo8c`o0U5%6TORhDIlfC0pu!=@HFc7L;xdBw*_Dy-m}?P5xjL z7CE7Xwd>G+cRb9uSXF~=hmq0k+s&&L+&Oz;`fwO;D2Qt`$chyM_fu*eK<*YmpZX3! zH?AP)kz@HpKxUm5$k;6a)NG+bT2e!9eer3*zO0JCdUDpu#xhiW76jIRX zeT8s@dPJK#jKQ6q^}%E@pXA_Z$7&@veY*ka8$bc;<1ds2VgicG{es=gaG!ZoCZqH< z^N#zM(#ldmPGb$Wfw{NXO&&RHl^hr<+nz!5^iFniGy`s(x-se>BX%VOry*{fanf02xtqOQ3_F$ z`Mr4ko*J3NN)Je1=!O9x8))tqY^wf;-KM}q|n`BgsAWfXGoc9?z%R`_b& zEiZ3@%rHcir9y>XfuqoI{&#RDe|=?EBi?gsabP&kzc-!ZC)HaELsovhWByzGUB5dC zX?G#bU7Zz=RbG6G|5;SvEJ$F3_gM|jK#u0v>@14{I?Zi2Y>Ho>MD`-ai-&hOF0+?*%+(<9LWm zYi9vBi5-^Azprg1!FP1A(=Nn~^Clx46t zs`+iJWBwi{*6&5vCA;y#Sq;Np^~f|>xZ?b;!BBWyz>)x1QW4gNuAFr$v-fbD89DCi zbCXb?D}SA1{++0YeT*~{9t*DOu1TKiaY-ru0JKW!*GH`mR+f^ZKbEy$NhJJlrAqfc zi+7Dh1~t)$-c&Q(J-be6XA=Lm-*UJxyq2SKJpMWhQl!HU0vddGd5^Sr7!~+&Li(w( z4&vy!!AgTT*%8gfhiybtFUSmFKQ}aKxqa`#Sbh5^r<54}AHQLJ_C^%Zk9>S;+xcBg zJ3!{qQ`|@{8j7djAFoD{eKYoVm3COTJD(f6%S+tU2qAif@0R>a=70QyV}?{JlpW3FSk*# zWjblwIH=*aP7v0`_%#QeV))+QA2mwkd`FzQ{limBhkMZu;CB{uAh%ZLfG3>=9m&g; z{}9nsiN8z}{;nz@f7d?$cl8g32AY!Un-bl=_buCm(e-*v0ts9{Q1{JIUQHHoI=)YZUgFfkh4Snepk&h=v*k9Q}n>gTqOxW9}L=iR-QJq6cS_ANZ4Lb_;+s>eO z`JFb=s@!?@{rl98+XuyL6Vg7=h|)f0o#J-RAX?V!PW(ENpDO7;=qzv$*Sqbw!UD4d ztOgC`;CrVQ;l*OD2_vjqQdn1=;>LQhu~RZVDEL0xerky^_cPX~ca6Y-VpoH35hD)e z74M!I1wlzi-NRiS3nrpdoJQ$>@n!x{yrO#HlAYB_TxB?o;;b@kw!YL2JDcK8;oE^b zq-#p=kJEdgcb3v)3>R0T%AarJctLNaSoX}1#I~yT7F^z=iH>=-fWmEzO|0?ce`Ygj z&!K%YL)x@DejlYiXDHaFuC0agc6Y8C{wmwgwFg)rz3uXS6h=^i=2+g|vFv(W+te{* z;mC{xOL)6|`>et5Ke8_vTtR5uzP(Dno3*$(C?*2)Tf7w+Lvua8z0B`K4-8#cne_-^ z_cdTc!`hm_o*r(Lg-vY~I|&#wtJ}B(9B6rTGb_KkET`ur_(<<|<*Whux=#JSKq_if z@-r2ivse);5MDCi!|U5){uNKGNYAAHtIdBK*_M`FY}+#bF+DJXP^2*jHl5N)f0=FR z`DhIMV3}=R*xyf4Uu9O+gw29d6l`jus_HVsQNS^oYSRZAxfxIHz!M{9Mjc zn`Q)UH>m@0mMaARkotzEnRr&Ju6zoh76BA&)jyq8h@3;=DtsG%$e2XzZ|Q&9FX!{d zMfPBcRETYKK6x8th@V2v^TJ20g?VAE!2VL#segcZKG{yVl~^;RDW|J!xOBFFNsSvUbOE(^k>Yq#Qsb+#2>61&Meel;W4g4Opy9Ki_TK zZtHOC1O?86h~TIb!SQ0C1O1778~tb4#l{TyiC-s(6uEDd5%ssbnYS;b%b7@vKMJe0Fc`#B3xnY~$;KpUGO>6|U={i5aLh(T0xN}2+ypv{5TM~k$?hU=(-_A*k^uG*)c<1;O1sBx6eYOx z*F1o`qKXpn;+S_I^cb8Es&_278E?go8oyRSrq>YR6MuApw>Yb0c>irRaxG{P_D{>&;P1`lSIGA7 zu4(zjaCURUJKVAsj(7>W-#zE4!C!}}I0Lh%ios59tA3cgXb!%a6n~PLNO9={4RW#B zUI1oX5^>BeL-$x-xhxSVA;VPQjdd*H6WBc|zi}{uUb!1zgn099SNz||Fi*-a7Y@3} zs*13FFinM&8%Y@05Vqr=WJ-ib?gv!XfJ7;K9HrpDf;|3(j0eC&U%RH^=Ft!xu14eL zcr;2pv9U{UC>-$^FbUl-cO85EmbJwTZ%z!lf@{$Kp8N*K;@jdWR1vquZHxvJ?3xC5 zEu7hM!{Y}PgH-|1z=JQK;#6W2#d92%I1Q&dP;NN^mBm{~7!(!J$NuJ-*BDuy-T8YR z^M68xE@O236*z5qUQt~j2~%OC+vsavIXUi1$FiGyV#93Lv@x7HDv%Y>W(~7pIFW!< zGOE;Z0Rf+)EN2&1geI!c1kIjgM4g z5_6PqHA=p1LN99hW&&HX=V3m*Go3J?$$}5(_?^|GGSHs6kN!HyvRkr>>nmng{;0;j zEC{BPYnSt-oENCQY#LSDL0G4Fw;lO!+31bkGf+fsUvAr!dE zH`X$+F{6_&@S-zZOY^Z|EW z8942%Roi#Xf8HtsjFiV3+eYa7dD2Rg&Rtzp=&p7-R|v|K3hG|T?K!wtvh(fs8rc1` zzmJwvxcK4k3^oe&yY(V$0xyL|$Kr?3v}0MCcTGb@6MV`l@RR;C&G8R7Fb)dii@bFW z5ZCRd53bx)c80UMpl&AjG6&Z4q2w_E(yZ}jM z==w0vueyw`CCL0!MCJs0W;8NdHFC4P5es-cHJjss-;4 ziLet0l9XJLmsx&kP2e8>xI8bd{4%F;12`C-JuqK14e{=c#|fw)qo;%c$H^{Nd|lwL z*i7F(gUA-VhX=YRb)EY8CV$EW*Ulikp_;;#VP9GHzW_&aMSf=4uA0DU&LEbha$T}& z&>7!gfmR0n6TxZ_qT&N+(Ek2daS4{nKc1VR+CM&*V;bDeMWir06o66arEZ8SvMq2S z7M8z!TKkjB`nP%4cVM5eZ##0+5e>yFx0SVBi7_9C;}+iL-l6hix@Z@9DZlDi7a4QIQp#+1Wa1@ayANkO%tx^V=}}4w+RS+vtbe*Q4lX!GJTu=1suu zL@1|@C%fgiZz~G2|D6~SLI3=n&=k}Zab@4o6!D~Jpg5d@CtZkl%5V6%$P*V?%M)IN z^2AXXJbBILChb5!ynmx>!#c1zeCWR#j!xgUa3qc@EAM&=)@*V__~&y#lNY!tFLd=b z23gcw9BN11R8u*{=vN9;{W`{K9(SNYZxSgFWvYvL4VEf$4gv}--<-V;Qeh)9ZXAAv zKVa41b6BB18HPJOD;L1Ggp8pmp&WFv2zcK$w@JC|oClX7tp9L6=b_V6fFry^9S@Oy zcss*U#WO*~Zvvm*=ET`|j-Q+N%aP@`R?JKoRzAvUO#6`nUj@?eex8T}rf1&)ffB!7 z%yXm)^fq!4m*a}G%HZtsHS?Sk5MT#5mX&2eg+t%_SHaK8{QCuQag~jZ$|vxR^p}Yp zTJC~A_yD!snX{I&-68l49U0>6RZpHE;oR|9GAT5ar$JajL#Cd47>Ue-zG zPj4{OQS}1*!rRUHLvNG1t_GD`Kf2aYNH`y`As@e&) zp(KeEFnV6`mq~H{bJ!W);MryEHT-9mPa*#b?8dz(0ehBeIf~uUvTC*A&y%n;N#BHr z{}~x9!5)lmQ~{z9l3tFgmlgfm2@LH{28Jio6#dHERLpFns91l`N#HUH^?-_ynPL8E zXHn5@jA{#<{IVJ74R$MQ3;i>AR{1#4udTrDIhi&;rTd*R4T?#)&9=HtM6?-|j5eVc zdYhA_4gZvrz^g*F(JXE3f{XkR?-$8d8_xI*;EwDkx#kck=%f9F>{d|xmy%;JXIK(k z#Hw%ODkR6LBZI%9PboCXHoU|%Fox1%l*j`dIYTa6&OSOP!o?$q5%T5gd?k_jl9-Ph z13CvIZ^$p!%Of$a_{|L`g(5{Tw1(`GpsRQ^e=d%#(5mqenSDv3D)h~2|QoA zcQR9(Vfr6jvX zt?GhXCsV*Fp&BdLB8R>RQ%)Gv6bLrS$%&if1l@VSO@P$1fr$JX{{}3jAb8GkRGm&r z)d$n&e!+k%ZsUe{te@QZ+vgNQWV|=&=Q9PzzyB`OZ`ozo*%@qw5pdq8h2BVB^&o<~ zp1u`{0F}a>6Yi6IB5Fery<#m;IA5`_s~2L?BFqG^a=~|1Q^ykb*ei&Zy)NH(9(FG{ z?+Kv**&>Z#gr*KPt;EiV@NazWA@(M<220mBiyU zcWNsB=Fe!`f0Mtt7s+o;2a$bc&B);iP>bn&v=*9tNIz%`^lWxKbS6=s+eE)=M`aD@ zqxPq)?^VMHU3Ge&YW7odUp&xj{rHe&GM1k_9r)Eh!S+T8EEHD9-Cd!07UA zabe{K8fto5+^7_XdE)(?{_bz2@diB5_*OpbjhFs!8c#;!AcOcmFQ%WGjez_h4$wj} z{1DZv>U5qbt4`nL6L@#y0eJWDVT0Ep_L)_$f?^>?ISKv7Mmoi2ie%TqF90A6Rv;88 z5H61b0ruZP|D*Qb#Q{467Za*IT5o>;wUV&7;v6TS^f08j2xNm_u&LYBVS1;P$^2jp zyzKc&aRFGuB6C{2gh*l5NW!+F#YSN=@Ng_eQWR0c9A)XFB0tUtoai_4JbdV%iSk2S zW*>SEU0s7u?KmVBe+SU;Lq1hq0zlRHz<^Df-AM*43_BQ{FyElBlkfWZ;>`a9hnR2e z3S~n}{`UU+8GrL_qM}8YG4-f@l7%z69%k_f4BImAAPP~ez@mOmB|AhSi*qc}_|pK3 z=vQ-tDZsxxm+EP6+IUWBkxy66BbN9KNU zFKroAt5+>}UA_$>z`|V{120zS6#(Au5{2gLj@pFUZ(MFMx%>i^-FI zjrrqOZ$)$h3`t>4C&AtcAQGaKwv66M_QZU6W;>0AlYyn%SlB?x;ypav?eJhVUe{V% z774?nBh=+FU41SZ@EDK%04oF>uj6NQ7GvXjEbK8q`xoQvx-~wkE(cNiZ!*uP4=OYj zaiZW*Gtv|P1m(*y468n6)h-e)_Be(?=~3kH_}+}}U<*1+ z|6Lf0fKPd;o`#`=AIeR2J!<6mRSv4JvpX%u7(ezT7~@A&?lwmJ{?(AK$IBG1 zPQ$tYg&;+wOEHhU09Q_G>SHXnvSx+jRZJc;r4JzE!i?6UL^+LZdJhktIwiW5qSrB4 zfJDpcRx527Ju6@3(nM>AEjIZihY{{7axD4q*7cVPsCmz%b@*HYz3JM<*CecX1C{2`|?d_9h

    A)4unP=uRAeHkwfH~IUqz%^ z!MMhM1ZJ?-zEXaDfbS3j;syKApGb$fLHY40!qXOF|AwBU-ops6sMQ7|{nE!M%dU)( zWmo>MWtq5nBOoh=CxSR@{g9rc;6)pJxvxaaS~BI&khOWBb$AGzu&nh|edVaSk;W1p zP)^4I0jyvCj|+2bZ&iH=H5p+jv#!9t2kv5dR3tj=3r!v8baHyvbYxg`l_t|T|D>WM$lR*Vsx>;_|D{9*rX{Tp$u0RDQ6NkP}# zA18x6j`>^`aU6)j9Wg-L^#7rMFaWbUCcrlTf`13c8LH&isFUX+$!l(!!W|UscrsBf zFR>(+YVzNAEEr2$ANE7WFp5hp8!?i1>>eLy-q(ca@RTf4&Y9vZc;JzDpn8eQ{0b5| z`dA>)!~9IPoM9G6vdedx^~K{GhCOL$&LdfUNru~3n1-{7Gc)-o7dMnRF`IL`E_;Mq zttExT24Oibc|tB1z@F*cb(BQ6Ab3C}aw0GM6RVc;g$MWB^{Px8n$oKhW?I*wuRwLg zD!o34?Y$(oaW@Qg_a`_fuGzud$sg!4*rJqR!sn_Jp)SUA+}ec2x62z$ELx3RFl(5u z4R2y=B|06PG>Bb%fKHjB={OK1rP-w{V8S8%ai?UAnT{(9?O4f$d=PHL^UW&AqX<&&`L zR$E}`@>kfHk-YDd@$~O8XC032^@YEU>2;PtuYaQ>KHGYoUu?ZTs^wlkhn-=hr+ppK z>xGX+_d4lRO87{pBD}!=c)O$WQYOU=1x26cRmY~!s=JR*pDVb$$B@82;Zlj21NyA} zSkY(np=kO{sEMJ^a{v(Zc~=L5w$X=QZ1h13EscsyMW27}h@emA|Haa0spg{}idLg$ zh#B|y6kQ}5M3=|mhOaz~M%bUjSM)CuA3(rw1poGgC7Sb4z!}e7aYWnR>8x+Y5x);x z7h_I{u#}?JBDi`Lt?q$}1Km`pR9IKDE-LbV8t?M1gH!fSaJwh}BZqO6_{4OWl3iD= zY`w$G)QPS2mN4=XF6z-y*dK=x4LGBt&in|n>$U$x_tKih=%w*Bkdh=}O%8Cd7@jgtH0J}$;b7fq+dluqAHf&^raT}rD)dja4CN0qd;V~yn zBI_vm%bl{tEY5pWV9!*In!__yenL<~M0OGcW8jqOTi~2^5L=u0=_uZT;L3Z3Ov`p| zMTB1e*{)g(8W&@M!-1Ej<~}Wm04hjo1estOKojHunnF%R&$ng=3sm~A97%itK1B+J z@pA`V=_${tn3XWHyf>oBCpx|LKY~ZjyBmw>&ab25iFFe5SEEWIrU3OCcsz-;eGyxw z_K7uuE~VqioO;&9bOgr|v@2Z*DYf7SE|gI*D>T<##UD5nq3H6M{(HUn zMEI{QN|H+1L=OCyE6+ut5NyKd$`J+(qjGIGJD;UUBEK1Qd)nz5f9DE|FW`{FgV2az z#wu5Y*|mqntsI=fyEo<*41?MuwtI7 z(O84KB6L#!y2`q;U$boj2&P^nOpS9*OQvnXK0$pEMJgn2@y6ryp1_XYV?BziEz)RW zp!b+3g7}2J4O0*vPBEiH?6cipYn>xy{vX?t#3WNnc@dj8B!wv^9>Unh+G_T4+WNy7 z`0CUaShS{f9*xD)iovHSNV-cN-_PYy@a8i^qR3;8*oJcsoq(1yVbi^?=OrEC7I#xV z+~UBD6`&}Y(Wyn*M*N0+5VBHphDcXqeA7Q8DO$&Z=xr7-7v0ekIr&K_*@i1~ENmAF zAWP*a4p;?IkdPn}WKvY^OLXnbVD_`uPVuo?yB|PF`ztdV$yfgy)7j@=M^9(pEuhi? znXPngD%`s%xGn1S+XOq7q zel@c5i`Mk{QPp0O%bJAZz7i+2eM_OgvnF~gcmqD&(@?Jeghcu6| zb%-JvtFh)M=@p490;mWpXs=>vQ7UwY`4Ohd8fef%0D9E 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Ð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

    TdP`jHk=(z+{kHA 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

    _Q~* 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 z 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%0Dg>&UL@*C_8UYlD578~(vR7{iLD^y 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