From 817cd410d93688d7b4d7f34db51ce56972c4df1e Mon Sep 17 00:00:00 2001 From: Viu Long Kong Date: Mon, 9 Nov 2020 14:54:45 +0100 Subject: [PATCH] release 2.16.196 --- .../basic/plant_location_with_cpo_callback.py | 122 ++++ examples/cp/basic/trimloss.py | 129 ++++ examples/cp/jupyter/scheduling_tuto.ipynb | 580 ++++++++++++------ examples/mp/docplexcloud/diet_food.csv | 10 - .../mp/docplexcloud/diet_food_nutrients.csv | 10 - examples/mp/docplexcloud/diet_nutrients.csv | 8 - .../mp/docplexcloud/diet_on_docplexcloud.py | 50 -- examples/mp/docplexcloud/diet_pandas.py | 115 ---- examples/mp/jupyter/efficient.ipynb | 286 ++++++--- examples/mp/jupyter/lifegame.ipynb | 2 +- examples/mp/workflow/populate.py | 230 +++++++ 11 files changed, 1073 insertions(+), 469 deletions(-) create mode 100644 examples/cp/basic/plant_location_with_cpo_callback.py create mode 100644 examples/cp/basic/trimloss.py delete mode 100644 examples/mp/docplexcloud/diet_food.csv delete mode 100644 examples/mp/docplexcloud/diet_food_nutrients.csv delete mode 100644 examples/mp/docplexcloud/diet_nutrients.csv delete mode 100644 examples/mp/docplexcloud/diet_on_docplexcloud.py delete mode 100644 examples/mp/docplexcloud/diet_pandas.py create mode 100644 examples/mp/workflow/populate.py diff --git a/examples/cp/basic/plant_location_with_cpo_callback.py b/examples/cp/basic/plant_location_with_cpo_callback.py new file mode 100644 index 0000000..1e790c6 --- /dev/null +++ b/examples/cp/basic/plant_location_with_cpo_callback.py @@ -0,0 +1,122 @@ +# -------------------------------------------------------------------------- +# Source file provided under Apache License, Version 2.0, January 2004, +# http://www.apache.org/licenses/ +# (c) Copyright IBM Corp. 2015, 2016, 2018, 2020 +# -------------------------------------------------------------------------- + +""" +A ship-building company has a certain number of customers. Each customer is supplied +by exactly one plant. In turn, a plant can supply several customers. The problem is +to decide where to set up the plants in order to supply every customer while minimizing +the cost of building each plant and the transportation cost of supplying the customers. + +For each possible plant location there is a fixed cost and a production capacity. +Both take into account the country and the geographical conditions. + +For every customer, there is a demand and a transportation cost with respect to +each plant location. + +While a first solution of this problem can be found easily by CP Optimizer, it can take +quite some time to improve it to a very good one. We illustrate the warm start capabilities +of CP Optimizer by giving a good starting point solution that CP Optimizer will try to improve. +This solution could be one from an expert or the result of another optimization engine +applied to the problem. + +In the solution we only give a value to the variables that determine which plant delivers +a customer. This is sufficient to define a complete solution on all model variables. +CP Optimizer first extends the solution to all variables and then starts to improve it. + +The solve is enriched with a CPO callback, available from version of COS greater or equal to 12.10.0.0. +This callback displays various information generated during the solve, in particular intermediate +solutions that are found before the end of the solve. +""" + +from docplex.cp.model import CpoModel +import docplex.cp.solver.solver as solver +from docplex.cp.utils import compare_natural +from collections import deque +import os +from docplex.cp.solver.cpo_callback import CpoCallback + + +#----------------------------------------------------------------------------- +# Initialize the problem data +#----------------------------------------------------------------------------- + +# Read problem data from a file and convert it as a list of integers +filename = os.path.dirname(os.path.abspath(__file__)) + "/data/plant_location.data" +data = deque() +with open(filename, "r") as file: + for val in file.read().split(): + data.append(int(val)) + +# Read number of customers and locations +nbCustomer = data.popleft() +nbLocation = data.popleft() + +# Initialize cost. cost[c][p] = cost to deliver customer c from plant p +cost = list([list([data.popleft() for l in range(nbLocation)]) for c in range(nbCustomer)]) + +# Initialize demand of each customer +demand = list([data.popleft() for c in range(nbCustomer)]) + +# Initialize fixed cost of each location +fixedCost = list([data.popleft() for p in range(nbLocation)]) + +# Initialize capacity of each location +capacity = list([data.popleft() for p in range(nbLocation)]) + + +#----------------------------------------------------------------------------- +# Build the model +#----------------------------------------------------------------------------- + +mdl = CpoModel() + +# Create variables identifying which location serves each customer +cust = mdl.integer_var_list(nbCustomer, 0, nbLocation - 1, "CustomerLocation") + +# Create variables indicating which plant location is open +open = mdl.integer_var_list(nbLocation, 0, 1, "OpenLocation") + +# Create variables indicating load of each plant +load = [mdl.integer_var(0, capacity[p], "PlantLoad_" + str(p)) for p in range(nbLocation)] + +# Associate plant openness to its load +for p in range(nbLocation): + mdl.add(open[p] == (load[p] > 0)) + +# Add constraints +mdl.add(mdl.pack(load, cust, demand)) + +# Add objective +obj = mdl.scal_prod(fixedCost, open) +for c in range(nbCustomer): + obj += mdl.element(cust[c], cost[c]) +mdl.add(mdl.minimize(obj)) + + +#----------------------------------------------------------------------------- +# Solve the model, tracking objective with a callback +#----------------------------------------------------------------------------- + +class MyCallback(CpoCallback): + def invoke(self, solver, event, jsol): + # Get important elements + obj_val = jsol.get_objective_values() + obj_bnds = jsol.get_objective_bounds() + obj_gaps = jsol.get_objective_gaps() + solvests = jsol.get_solve_status() + srchsts = jsol.get_search_status() + #allvars = jsol.get_solution().get_all_var_solutions() if jsol.is_solution() else None + solve_time = jsol.get_info('SolveTime') + memory = jsol.get_info('MemoryUsage') + print("CALLBACK: {}: {}, {}, objective: {} bounds: {}, gaps: {}, time: {}, memory: {}".format(event, solvests, srchsts, obj_val, obj_bnds, obj_gaps, solve_time, memory)) + +if compare_natural(solver.get_solver_version(), '12.10') >= 0: + mdl.add_solver_callback(MyCallback()) + +# Solve the model +print("Solve the model") +msol = mdl.solve(TimeLimit=10) +msol.write() diff --git a/examples/cp/basic/trimloss.py b/examples/cp/basic/trimloss.py new file mode 100644 index 0000000..6569c17 --- /dev/null +++ b/examples/cp/basic/trimloss.py @@ -0,0 +1,129 @@ +# -------------------------------------------------------------------------- +# Source file provided under Apache License, Version 2.0, January 2004, +# http://www.apache.org/licenses/ +# (c) Copyright IBM Corp. 2020 +# -------------------------------------------------------------------------- + +""" +The trim loss problems arises in the paper industry. + +The problem is to cut wide papers rolls into sub rolls (orders). +The wide roll are cut into pieces with a cutting pattern. + +A cutting pattern defines the blades positions for cutting the roll. +A maximum number of orders is allowed in a cutting pattern (here it is 6). +When cutting a wide roll, we can have a loss of paper that is wasted. +This loss is contrained to be not more than a given value (here it is 100) + +An order is characterised by a demand, a roll width, and a maximum number of +time it can appear in a cutting pattern. + +The goal is to meet the demand while minimizing the roll used and the number +of different cutting patterns used for production. + +In this example we also use: +- extra constraints to avoid assigning orders to unused patterns, +- lexicographic constraints to break symmetries between cutting patterns +- strong constraints to have a better domain reduction by enumerating possible + patterns configurations +All this makes the proof of optimality rather fast. +""" + +from docplex.cp.model import * +from sys import stdout + +#----------------------------------------------------------------------------- +# Initialize the problem data +#----------------------------------------------------------------------------- + +# Data +ROLL_WIDTH = 2200 # Width of roll to be cutted into pieces +MAX_WASTE = 100 # Maximum waste per roll +MAX_ORDER_PER_CUT = 5 # Maximum number of order per cutting pattern + +# Orders demand, width and max occurence in a cutting pattern +ORDER_DEMAND = ( 8, 16, 12, 7, 14, 16) +ORDER_WIDTH = (330, 360, 380, 430, 490, 530) +ORDER_MAX_REPEAT = ( 2, 3, 3, 5, 3, 4) +# Number of different order types +NUM_ORDER_TYPE = len(ORDER_DEMAND) +# Maximum number of cutting pattern +NUM_PATTERN_TYPE = 6 +# Maximum of time a cutting pattern is used +MAX_PATTERN_USAGE = 16 +# Cost of using a pattern +PATTERN_COST = 0.1 +# Cost of a roll +ROLL_COST = 1 + +PATTERNS = range(NUM_PATTERN_TYPE) +ORDERS = range(NUM_ORDER_TYPE) + + +#----------------------------------------------------------------------------- +# Build the model +#----------------------------------------------------------------------------- + +model = CpoModel() + +# Decision variables : pattern usage +patternUsage = [model.integer_var(0, MAX_PATTERN_USAGE, "PatternUsage_"+str(p)) for p in PATTERNS] + +# Decision variables : order quantity per pattern +x = [[model.integer_var(0, max, "x["+str(o)+","+str(p)+"]") + for (o, max) in enumerate(ORDER_MAX_REPEAT)] + for p in PATTERNS] + +# Maximum number of orders per cutting pattern +for p in PATTERNS : + model.add(sum(x[p]) <= MAX_ORDER_PER_CUT) + +# Roll capacity +usage = [0] + [v for v in range(ROLL_WIDTH - MAX_WASTE, ROLL_WIDTH+1)] # usage is [0, 2100..2200] +rollUsage = [model.integer_var(domain = usage, name = "RollUsage_"+str(p)) for p in PATTERNS] + +for p in PATTERNS : + model.add(sum(ORDER_WIDTH[o] * x[p][o] for o in ORDERS) == rollUsage[p]) + +# Production requirement +for o in ORDERS : + model.add(model.sum(x[p][o] * patternUsage[p] for p in PATTERNS) >= ORDER_DEMAND[o]) + +# Objective +model.add(minimize(model.sum((patternUsage[p] > 0) * PATTERN_COST + patternUsage[p] * ROLL_COST + for p in PATTERNS))) + +# Extra constraint to avoid assigning orders to an unused pattern +for p in PATTERNS : + model.add((patternUsage[p] == 0) == (rollUsage[p] == 0)) + +# Extra lexicographic constraint to break symmetries +for p in range(NUM_PATTERN_TYPE - 1) : + model.add(model.lexicographic([patternUsage[p]] + x[p], [patternUsage[p+1]] + x[p+1])) + +# Strong constraints to improve the time to prove optimality +for p in PATTERNS : + model.add(model.strong(x[p])) + +# KPIs : Number of rolls, of pattern used and total loss of paper +model.add_kpi(model.sum([patternUsage[p] for p in PATTERNS]), "Rolls") +model.add_kpi(model.sum([(patternUsage[p] > 0) for p in PATTERNS]), "Patterns") +model.add_kpi(model.sum([patternUsage[p] * (ROLL_WIDTH - rollUsage[p]) for p in PATTERNS]), "Loss") + + +#----------------------------------------------------------------------------- +# Solve the model and display the result +#----------------------------------------------------------------------------- + +print("Solve the model...") +msol = model.solve(LogPeriod=1000000, TimeLimit=300) +if msol: + print("patternUsage = ") + for p in PATTERNS: + l = ROLL_WIDTH - msol[rollUsage[p]] + stdout.write("Pattern {} , usage = {}, roll usage = {}, loss = {}, orders =".format(p, msol[patternUsage[p]], msol[rollUsage[p]], l)) + for o in ORDERS: + stdout.write(" {}".format(msol[x[p][o]])) + stdout.write('\n') +else: + print("No solution found") diff --git a/examples/cp/jupyter/scheduling_tuto.ipynb b/examples/cp/jupyter/scheduling_tuto.ipynb index 2b205d8..9acc80a 100644 --- a/examples/cp/jupyter/scheduling_tuto.ipynb +++ b/examples/cp/jupyter/scheduling_tuto.ipynb @@ -83,10 +83,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 2, + "metadata": {}, "outputs": [], "source": [ "import sys\n", @@ -95,10 +93,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 3, + "metadata": {}, "outputs": [], "source": [ "mdl0 = CpoModel()" @@ -203,10 +199,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 4, + "metadata": {}, "outputs": [], "source": [ "masonry = mdl0.interval_var(size=35)\n", @@ -235,7 +229,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -272,9 +266,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Solving model....\n", + "done\n" + ] + } + ], "source": [ "# Solve the model\n", "print(\"\\nSolving model....\")\n", @@ -295,9 +299,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Masonry : 0..35\n", + "Carpentry : 35..50\n", + "Plumbing : 35..75\n", + "Ceiling : 35..50\n", + "Roofing : 50..55\n", + "Painting : 50..60\n", + "Windows : 55..60\n", + "Facade : 75..85\n", + "Moving : 85..90\n" + ] + } + ], "source": [ "if msol0:\n", " var_sol = msol0.get_var_solution(masonry)\n", @@ -342,7 +362,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -356,9 +376,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "if msol0:\n", " wt = msol0.get_var_solution(masonry) \n", @@ -557,10 +590,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 10, + "metadata": {}, "outputs": [], "source": [ "import sys\n", @@ -578,10 +609,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 11, + "metadata": {}, "outputs": [], "source": [ "masonry = mdl1.interval_var(size=35)\n", @@ -639,10 +668,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 12, + "metadata": {}, "outputs": [], "source": [ "mdl1.add( mdl1.end_before_start(masonry, carpentry) )\n", @@ -692,7 +719,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -721,9 +748,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Solving model....\n", + "done\n" + ] + } + ], "source": [ "# Solve the model\n", "print(\"\\nSolving model....\")\n", @@ -733,9 +770,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost will be 5000\n", + "Masonry : 20..55\n", + "Carpentry : 75..90\n", + "Plumbing : 55..95\n", + "Ceiling : 75..90\n", + "Roofing : 90..95\n", + "Painting : 90..100\n", + "Windows : 95..100\n", + "Facade : 95..105\n", + "Moving : 105..110\n" + ] + } + ], "source": [ "if msol1:\n", " print(\"Cost will be \" + str(msol1.get_objective_values()[0]))\n", @@ -771,10 +825,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 16, + "metadata": {}, "outputs": [], "source": [ "import docplex.cp.utils_visu as visu\n", @@ -787,9 +839,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "if msol1:\n", " wt = msol1.get_var_solution(masonry) \n", @@ -951,10 +1016,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 18, + "metadata": {}, "outputs": [], "source": [ "NbHouses = 5\n", @@ -1012,10 +1075,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 19, + "metadata": {}, "outputs": [], "source": [ "import sys\n", @@ -1026,10 +1087,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 20, + "metadata": {}, "outputs": [], "source": [ "houses = [mdl2.interval_var(start=(ReleaseDate[i], INTERVAL_MAX), name=\"house\"+str(i)) for i in Houses]" @@ -1053,7 +1112,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -1082,7 +1141,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -1118,10 +1177,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 23, + "metadata": {}, "outputs": [], "source": [ "for h in Houses:\n", @@ -1148,7 +1205,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -1186,7 +1243,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ @@ -1216,7 +1273,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ @@ -1249,7 +1306,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "metadata": {}, "outputs": [], "source": [ @@ -1279,11 +1336,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Solving model....\n", + "done\n" + ] + } + ], "source": [ "# Solve the model\n", "print(\"\\nSolving model....\")\n", @@ -1293,11 +1360,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "metadata": { "scrolled": false }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost will be 17065\n" + ] + } + ], "source": [ "if msol2:\n", " print(\"Cost will be \" + str(msol2.get_objective_values()[0]))\n", @@ -1307,9 +1382,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# Viewing the results of sequencing problems in a Gantt chart\n", "# (double click on the gantt to see details)\n", @@ -1443,10 +1531,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 31, + "metadata": {}, "outputs": [], "source": [ "import sys\n", @@ -1473,7 +1559,9 @@ " (\"roofing\",\"facade\"),(\"plumbing\",\"facade\"),\n", " (\"roofing\",\"garden\"),(\"plumbing\",\"garden\"),\n", " (\"windows\",\"moving\"),(\"facade\",\"moving\"), \n", - " (\"garden\",\"moving\"),(\"painting\",\"moving\") }" + " (\"garden\",\"moving\"),(\"painting\",\"moving\") }\n", + "\n", + "Houses = range(NbHouses)" ] }, { @@ -1502,10 +1590,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 32, + "metadata": {}, "outputs": [], "source": [ "Breaks ={\n", @@ -1543,7 +1629,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "metadata": {}, "outputs": [], "source": [ @@ -1553,7 +1639,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "metadata": {}, "outputs": [], "source": [ @@ -1587,7 +1673,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "metadata": {}, "outputs": [], "source": [ @@ -1615,7 +1701,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 36, "metadata": {}, "outputs": [], "source": [ @@ -1643,7 +1729,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 37, "metadata": {}, "outputs": [], "source": [ @@ -1677,7 +1763,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 38, "metadata": {}, "outputs": [], "source": [ @@ -1706,10 +1792,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 39, + "metadata": {}, "outputs": [], "source": [ "mdl3.add( mdl3.minimize(mdl3.max(mdl3.end_of(itvs[h,\"moving\"]) for h in Houses)))" @@ -1733,9 +1817,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 40, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Solving model....\n", + "done\n" + ] + } + ], "source": [ "# Solve the model\n", "print(\"\\nSolving model....\")\n", @@ -1745,9 +1839,29 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost will be 638\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "if msol3:\n", " print(\"Cost will be \" + str( msol3.get_objective_values()[0] )) # Allocate tasks to workers\n", @@ -1889,10 +2003,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 42, + "metadata": {}, "outputs": [], "source": [ "NbWorkers = 3\n", @@ -1904,22 +2016,22 @@ "\n", "Duration = [35, 15, 40, 15, 5, 10, 5, 10, 5, 5]\n", "\n", - "ReleaseDate = [31, 0, 90, 120, 90]" + "ReleaseDate = [31, 0, 90, 120, 90]\n", + "\n", + "Precedences = [(\"masonry\", \"carpentry\"), (\"masonry\", \"plumbing\"), (\"masonry\", \"ceiling\"),\n", + " (\"carpentry\", \"roofing\"), (\"ceiling\", \"painting\"), (\"roofing\", \"windows\"),\n", + " (\"roofing\", \"facade\"), (\"plumbing\", \"facade\"), (\"roofing\", \"garden\"),\n", + " (\"plumbing\", \"garden\"), (\"windows\", \"moving\"), (\"facade\", \"moving\"),\n", + " (\"garden\", \"moving\"), (\"painting\", \"moving\")]" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 43, + "metadata": {}, "outputs": [], "source": [ - "Precedences = [(\"masonry\", \"carpentry\"), (\"masonry\", \"plumbing\"), (\"masonry\", \"ceiling\"),\n", - " (\"carpentry\", \"roofing\"), (\"ceiling\", \"painting\"), (\"roofing\", \"windows\"),\n", - " (\"roofing\", \"facade\"), (\"plumbing\", \"facade\"), (\"roofing\", \"garden\"),\n", - " (\"plumbing\", \"garden\"), (\"windows\", \"moving\"), (\"facade\", \"moving\"),\n", - " (\"garden\", \"moving\"), (\"painting\", \"moving\")]" + "Houses = range(NbHouses)" ] }, { @@ -1933,10 +2045,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 44, + "metadata": {}, "outputs": [], "source": [ "import sys\n", @@ -1945,10 +2055,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 45, + "metadata": {}, "outputs": [], "source": [ "mdl4 = CpoModel()" @@ -1956,7 +2064,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 46, "metadata": {}, "outputs": [], "source": [ @@ -2022,7 +2130,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 47, "metadata": {}, "outputs": [], "source": [ @@ -2054,7 +2162,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 48, "metadata": {}, "outputs": [], "source": [ @@ -2085,10 +2193,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 49, + "metadata": {}, "outputs": [], "source": [ "for h in Houses:\n", @@ -2114,7 +2220,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 50, "metadata": {}, "outputs": [], "source": [ @@ -2139,10 +2245,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 51, + "metadata": {}, "outputs": [], "source": [ "mdl4.add( cash >= 0 )" @@ -2167,10 +2271,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 52, + "metadata": {}, "outputs": [], "source": [ "mdl4.add(\n", @@ -2198,9 +2300,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 53, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Solving model....\n", + "done\n" + ] + } + ], "source": [ "# Solve the model\n", "print(\"\\nSolving model....\")\n", @@ -2210,9 +2322,29 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost will be 285\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "if msol4:\n", " print(\"Cost will be \" + str( msol4.get_objective_values()[0] ))\n", @@ -2393,10 +2525,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 55, + "metadata": {}, "outputs": [], "source": [ "NbHouses = 5\n", @@ -2411,10 +2541,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 56, + "metadata": {}, "outputs": [], "source": [ "Skills = [(\"Joe\",\"masonry\",9),(\"Joe\",\"carpentry\",7),(\"Joe\",\"ceiling\",5),(\"Joe\",\"roofing\",6), \n", @@ -2426,10 +2554,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 57, + "metadata": {}, "outputs": [], "source": [ "Precedences = [(\"masonry\",\"carpentry\"),(\"masonry\",\"plumbing\"),(\"masonry\",\"ceiling\"),\n", @@ -2445,7 +2571,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 58, "metadata": { "scrolled": true }, @@ -2466,10 +2592,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 59, + "metadata": {}, "outputs": [], "source": [ "import sys\n", @@ -2478,10 +2602,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 60, + "metadata": {}, "outputs": [], "source": [ "mdl5 = CpoModel()" @@ -2489,7 +2611,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 61, "metadata": {}, "outputs": [], "source": [ @@ -2520,7 +2642,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 62, "metadata": {}, "outputs": [], "source": [ @@ -2551,7 +2673,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 63, "metadata": {}, "outputs": [], "source": [ @@ -2572,7 +2694,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 64, "metadata": {}, "outputs": [], "source": [ @@ -2607,7 +2729,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 65, "metadata": {}, "outputs": [], "source": [ @@ -2634,7 +2756,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 66, "metadata": {}, "outputs": [], "source": [ @@ -2661,9 +2783,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 67, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Solving model....\n", + "done\n" + ] + } + ], "source": [ "# Solve the model\n", "print(\"\\nSolving model....\")\n", @@ -2673,9 +2805,29 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost will be 360\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "if msol5:\n", " print(\"Cost will be \"+str( msol5.get_objective_values()[0] ))\n", @@ -2813,7 +2965,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 69, "metadata": {}, "outputs": [], "source": [ @@ -2838,10 +2990,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 70, + "metadata": {}, "outputs": [], "source": [ "Houses = range(NbHouses)" @@ -2858,10 +3008,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 71, + "metadata": {}, "outputs": [], "source": [ "import sys\n", @@ -2870,10 +3018,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 72, + "metadata": {}, "outputs": [], "source": [ "mdl6 = CpoModel()" @@ -2881,7 +3027,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 73, "metadata": {}, "outputs": [], "source": [ @@ -2912,7 +3058,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 74, "metadata": {}, "outputs": [], "source": [ @@ -2941,7 +3087,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 75, "metadata": {}, "outputs": [], "source": [ @@ -2950,10 +3096,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 76, + "metadata": {}, "outputs": [], "source": [ "ttvalues = [[0, 0], [0, 0]]\n", @@ -2986,7 +3130,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 77, "metadata": {}, "outputs": [], "source": [ @@ -3017,7 +3161,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 78, "metadata": {}, "outputs": [], "source": [ @@ -3051,7 +3195,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 79, "metadata": {}, "outputs": [], "source": [ @@ -3077,9 +3221,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 80, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Solving model....\n", + "done\n" + ] + } + ], "source": [ "# Solve the model\n", "print(\"\\nSolving model....\")\n", @@ -3089,9 +3243,29 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 81, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost will be 365\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "if msol6:\n", " print(\"Cost will be \" + str( msol6.get_objective_values()[0] ))\n", @@ -3162,21 +3336,21 @@ "metadata": { "anaconda-cloud": {}, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 2", "language": "python", - "name": "python3" + "name": "python2" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 3 + "version": 2 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.6.1" + "pygments_lexer": "ipython2", + "version": "2.7.15" } }, "nbformat": 4, diff --git a/examples/mp/docplexcloud/diet_food.csv b/examples/mp/docplexcloud/diet_food.csv deleted file mode 100644 index 7c2bcb6..0000000 --- a/examples/mp/docplexcloud/diet_food.csv +++ /dev/null @@ -1,10 +0,0 @@ -"name","unit_cost","qmin","qmax" -"Roasted Chicken", 0.84, 0, 10 -"Spaghetti W/ Sauce", 0.78, 0, 10 -"Tomato,Red,Ripe,Raw", 0.27, 0, 10 -"Apple,Raw,W/Skin", .24, 0, 10 -"Grapes", 0.32, 0, 10 -"Chocolate Chip Cookies", 0.03, 0, 10 -"Lowfat Milk", 0.23, 0, 10 -"Raisin Brn", 0.34, 0, 10 -"Hotdog", 0.31, 0, 10 \ No newline at end of file diff --git a/examples/mp/docplexcloud/diet_food_nutrients.csv b/examples/mp/docplexcloud/diet_food_nutrients.csv deleted file mode 100644 index 5d5629e..0000000 --- a/examples/mp/docplexcloud/diet_food_nutrients.csv +++ /dev/null @@ -1,10 +0,0 @@ -"Food","Calories","Calcium","Iron","Vit_A","Dietary_Fiber","Carbohydrates","Protein" -"Roasted Chicken", 277.4, 21.9, 1.8, 77.4, 0, 0, 42.2 -"Spaghetti W/ Sauce", 358.2, 80.2, 2.3, 3055.2, 11.6, 58.3, 8.2 -"Tomato,Red,Ripe,Raw", 25.8, 6.2, 0.6, 766.3, 1.4, 5.7, 1 -"Apple,Raw,W/Skin", 81.4, 9.7, 0.2, 73.1, 3.7, 21, 0.3 -"Grapes", 15.1, 3.4, 0.1, 24, 0.2, 4.1, 0.2 -"Chocolate Chip Cookies", 78.1, 6.2, 0.4, 101.8, 0, 9.3, 0.9 -"Lowfat Milk", 121.2, 296.7, 0.1, 500.2, 0, 11.7, 8.1 -"Raisin Brn", 115.1, 12.9, 16.8, 1250.2, 4, 27.9, 4 -"Hotdog", 242.1, 23.5, 2.3, 0, 0, 18, 10.4 \ No newline at end of file diff --git a/examples/mp/docplexcloud/diet_nutrients.csv b/examples/mp/docplexcloud/diet_nutrients.csv deleted file mode 100644 index bb52d1d..0000000 --- a/examples/mp/docplexcloud/diet_nutrients.csv +++ /dev/null @@ -1,8 +0,0 @@ -"name","qmin","qmax" -"Calories", 2000, 2500 -"Calcium", 800, 1600 -"Iron", 10, 30 -"Vit_A", 5000, 50000 -"Dietary_Fiber", 25, 100 -"Carbohydrates", 0, 300 -"Protein", 50, 100 \ No newline at end of file diff --git a/examples/mp/docplexcloud/diet_on_docplexcloud.py b/examples/mp/docplexcloud/diet_on_docplexcloud.py deleted file mode 100644 index 26acb96..0000000 --- a/examples/mp/docplexcloud/diet_on_docplexcloud.py +++ /dev/null @@ -1,50 +0,0 @@ -# -------------------------------------------------------------------------- -# Source file provided under Apache License, Version 2.0, January 2004, -# http://www.apache.org/licenses/ -# (c) Copyright IBM Corp. 2015, 2017 -# -------------------------------------------------------------------------- -''' -This example demonstrate how to run a python model on DOcplexcloud solve -service. - -@author: kong -''' -from docloud.job import JobClient -from docplex.mp.context import Context - - -if __name__ == '__main__': - '''DOcplexcloud credentials can be specified with url and api_key in the - code block below. - - Alternatively, Context.make_default_context() searches the PYTHONPATH for - the following files: - - * cplex_config.py - * cplex_config_.py - * docloud_config.py (must only contain context.solver.docloud configuration) - - These files contain the credentials and other properties. For example, - something similar to:: - - context.solver.docloud.url = 'https://docloud.service.com/job_manager/rest/v1' - context.solver.docloud.key = 'example api_key' - ''' - url = None - key = None - - if url is None or key is None: - # create a default context and use credentials defined in there. - context = Context.make_default_context() - url = context.solver.docloud.url - key = context.solver.docloud.key - - client = JobClient(url=url, api_key=key) - - resp = client.execute(input=['diet_pandas.py', - 'diet_food.csv', - 'diet_nutrients.csv', - 'diet_food_nutrients.csv'], - output='solution.json', - load_solution=True, - log='logs.txt') diff --git a/examples/mp/docplexcloud/diet_pandas.py b/examples/mp/docplexcloud/diet_pandas.py deleted file mode 100644 index c917a48..0000000 --- a/examples/mp/docplexcloud/diet_pandas.py +++ /dev/null @@ -1,115 +0,0 @@ -# -------------------------------------------------------------------------- -# Source file provided under Apache License, Version 2.0, January 2004, -# http://www.apache.org/licenses/ -# (c) Copyright IBM Corp. 2015, 2017 -# -------------------------------------------------------------------------- - -# The goal of the diet problem is to select a set of foods that satisfies -# a set of daily nutritional requirements at minimal cost. -# Source of data: http://www.neos-guide.org/content/diet-problem-solver - -from functools import partial, wraps -import os -from os.path import splitext -import threading -import pandas - -from six import iteritems - -from docplex.mp.model import Model -from docplex.util.environment import get_environment - - -def get_all_inputs(): - '''Utility method to read a list of files and return a tuple with all - read data frames. - - Returns: - a map { datasetname: data frame } - ''' - result = {} - env = get_environment() - for iname in [f for f in os.listdir('.') if splitext(f)[1] == '.csv']: - df = env.read_df(iname, index_col=None) - datasetname, _ = splitext(iname) - result[datasetname] = df - return result - - -def wait_and_save_all_cb(outputs): - get_environment().store_solution(outputs) - - -def mp_solution_to_df(solution): - solution_df = pandas.DataFrame(columns=['name', 'value']) - - for index, dvar in enumerate(solution.iter_variables()): - solution_df.loc[index, 'name'] = dvar.to_string() - solution_df.loc[index, 'value'] = dvar.solution_value - - return solution_df - - -def build_diet_model(inputs, **kwargs): - '''Constructs a diet model. - - Args: - inputs: map with inputs { 'datasetname': df } - **kwargs: kwargs passed to the docplex.mp.model.Model constructor. - ''' - food = inputs['diet_food'] - nutrients = inputs['diet_nutrients'] - food_nutrients = inputs['diet_food_nutrients'] - food_nutrients.set_index('Food', inplace=True) - - # Model - mdl = Model(name='diet', **kwargs) - - # Create decision variables, limited to be >= Food.qmin and <= Food.qmax - qty = food[['name', 'qmin', 'qmax']].copy() - qty['var'] = qty.apply(lambda x: mdl.continuous_var(lb=x['qmin'], - ub=x['qmax'], - name=x['name']), - axis=1) - # make the name the index - qty.set_index('name', inplace=True) - - # Limit range of nutrients, and mark them as KPIs - for n in nutrients.itertuples(): - amount = mdl.sum(qty.loc[f.name]['var'] * food_nutrients.loc[f.name][n.name] - for f in food.itertuples()) - mdl.add_range(n.qmin, amount, n.qmax) - mdl.add_kpi(amount, publish_name='Total %s' % n.name) - - # Minimize cost - mdl.minimize(mdl.sum(qty.loc[f.name]['var'] * f.unit_cost - for f in food.itertuples())) - - mdl.print_information() - return mdl - - -if __name__ == '__main__': - '''Build and solve the diet model. - - This sample was build to run on DOcplexcloud solve service. - ''' - inputs = get_all_inputs() - outputs = {} - - # The abort callbacks are called when the docplexcloud job is aborted - get_environment().abort_callbacks += [partial(wait_and_save_all_cb, outputs)] - - mdl = build_diet_model(inputs) - - mdl.float_precision = 3 - if not mdl.solve(): - print('*** Problem has no solution') - else: - print('* model solved as function:') - mdl.print_solution() - mdl.report_kpis() - # Save the CPLEX solution as 'solution.csv' program output - solution_df = mp_solution_to_df(mdl.solution) - outputs['solution'] = solution_df - get_environment().store_solution(outputs) diff --git a/examples/mp/jupyter/efficient.ipynb b/examples/mp/jupyter/efficient.ipynb index 7a99935..70feeea 100644 --- a/examples/mp/jupyter/efficient.ipynb +++ b/examples/mp/jupyter/efficient.ipynb @@ -27,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 30, "metadata": {}, "outputs": [ { @@ -36,7 +36,7 @@ "text": [ "--> begin fibonacci 30\n", "fibonacci(30) = 832040\n", - "<-- end fibonacci 30, time: 231 ms\n" + "<-- end fibonacci 30, time: 170 ms\n" ] } ], @@ -108,17 +108,25 @@ "source": [ "## A beginners's implementation of the model\n", "\n", - "In this section we show a Python/Docplex beginner's implementation of this model.\n" + "In this section we show a Python/Docplex beginner's implementation of this model." ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "# first import the `docplex.mp.model.Model` class\n", + "from docplex.mp.model import Model" + ] + }, + { + "cell_type": "code", + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ - "from docplex.mp.model import Model\n", - "\n", "def build_bench_model1(size=10):\n", " m = Model(name=\"bench1\")\n", " rsize = range(size)\n", @@ -143,7 +151,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 33, "metadata": {}, "outputs": [ { @@ -151,13 +159,14 @@ "output_type": "stream", "text": [ "--> begin bench1_size_1000\n", - "<-- end bench1_size_1000, time: 2724 ms\n", + "<-- end bench1_size_1000, time: 2640 ms\n", "Model: bench1\n", " - number of variables: 1000\n", " - binary=1000, integer=0, continuous=0\n", " - number of constraints: 1000\n", " - linear=1000\n", " - parameters: defaults\n", + " - objective: minimize\n", " - problem type is: MILP\n" ] } @@ -178,7 +187,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 34, "metadata": {}, "outputs": [ { @@ -186,7 +195,7 @@ "output_type": "stream", "text": [ "--> begin bench1 size=3000\n", - "<-- end bench1 size=3000, time: 23384 ms\n" + "<-- end bench1 size=3000, time: 25008 ms\n" ] } ], @@ -215,7 +224,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 35, "metadata": {}, "outputs": [ { @@ -223,9 +232,9 @@ "output_type": "stream", "text": [ "--> begin python_sum_too_slow_n=1000\n", - "<-- end python_sum_too_slow_n=1000, time: 4872 ms\n", + "<-- end python_sum_too_slow_n=1000, time: 5280 ms\n", "--> begin same_model_with_model_sum_n=1000\n", - "<-- end same_model_with_model_sum_n=1000, time: 2569 ms\n" + "<-- end same_model_with_model_sum_n=1000, time: 2793 ms\n" ] } ], @@ -259,6 +268,139 @@ "Building the Python sum model takes roughly twice as much time as the model with `Model.sum()'." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Pitfall #2 : create variables in batches, not one by one\n", + "\n", + "In the above code we used DOcplex `Model.binary_var_dict` method to create opur dictionary of variables. This method creates variables in _one_ call. One could wonder what if we had created the variables one by one? The answer kis: it works, but much slower.\n", + "\n", + "In the fnext cell, we define two functions to create large number of variables, either one by one or by batch, and compare times." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "# create N variables one by one\n", + "def create_variables_one_by_one(size_in_k=1):\n", + " with Model() as m:\n", + " for i in range(1000*size_in_k):\n", + " m.binary_var(name=\"x_{}\".format(i))\n", + " \n", + "# create N variables as one list\n", + "def create_variables_list(size_in_k=10):\n", + " with Model() as m:\n", + " size = 1000* size_in_k\n", + " m.binary_var_list(size, name='x')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then we sample these two functions for various sizes, measure time and plot the result" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--> begin create variables one by one: 10k variables\n", + "<-- end create variables one by one: 10k variables, time: 210 ms\n", + "--> begin create variables in batch: 10k variables\n", + "<-- end create variables in batch: 10k variables, time: 24 ms\n", + "--> begin create variables one by one: 30k variables\n", + "<-- end create variables one by one: 30k variables, time: 631 ms\n", + "--> begin create variables in batch: 30k variables\n", + "<-- end create variables in batch: 30k variables, time: 61 ms\n", + "--> begin create variables one by one: 60k variables\n", + "<-- end create variables one by one: 60k variables, time: 1130 ms\n", + "--> begin create variables in batch: 60k variables\n", + "<-- end create variables in batch: 60k variables, time: 154 ms\n", + "--> begin create variables one by one: 100k variables\n", + "<-- end create variables one by one: 100k variables, time: 1893 ms\n", + "--> begin create variables in batch: 100k variables\n", + "<-- end create variables in batch: 100k variables, time: 240 ms\n", + "--> begin create variables one by one: 300k variables\n", + "<-- end create variables one by one: 300k variables, time: 5682 ms\n", + "--> begin create variables in batch: 300k variables\n", + "<-- end create variables in batch: 300k variables, time: 823 ms\n" + ] + } + ], + "source": [ + "sizes = [10, 30, 60, 100, 300]\n", + "tt_ones = []\n", + "tt_batches = []\n", + "for sz in sizes:\n", + " with ContextTimer(\"create variables one by one: {0}k variables\".format(sz)) as tt1:\n", + " create_variables_one_by_one(size_in_k=sz)\n", + " tt_ones.append(tt1.msecs)\n", + " with ContextTimer(\"create variables in batch: {0}k variables\".format(sz)) as tt2:\n", + " create_variables_list(size_in_k=sz) \n", + " tt_batches.append(tt2.msecs)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "try:\n", + " import matplotlib.pyplot as plt\n", + " %matplotlib inline\n", + "except ImportError:\n", + " print(\"try install matplotlib: pip install matplotlib\")\n", + " raise" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(16,7))\n", + "plt.plot(sizes, tt_ones, label=\"one_by_one\")\n", + "plt.plot(sizes, tt_batches, label=\"var_list\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The conclusion is clear: for large number of variables (say, above 1000) prefer creating variables by batches (list or dict, ) using Docplex's prefedined routines (e.g. `Model.binary_var_list` or `Model.binary_var_dict`).\n", + "\n", + "\n", + "**Rule #2**: use Docplex's specia;ized routines to create large number of variables.\n" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -280,7 +422,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 40, "metadata": {}, "outputs": [ { @@ -288,7 +430,7 @@ "output_type": "stream", "text": [ "--> begin bench2 size=3000\n", - "<-- end bench2 size=3000, time: 15968 ms\n" + "<-- end bench2 size=3000, time: 16245 ms\n" ] } ], @@ -333,7 +475,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 41, "metadata": {}, "outputs": [ { @@ -341,7 +483,7 @@ "output_type": "stream", "text": [ "--> begin bench3 size=3000\n", - "<-- end bench3 size=3000, time: 9406 ms\n" + "<-- end bench3 size=3000, time: 9889 ms\n" ] } ], @@ -381,7 +523,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 42, "metadata": {}, "outputs": [ { @@ -389,7 +531,7 @@ "output_type": "stream", "text": [ "--> begin bench4 size=3000\n", - "<-- end bench4 size=3000, time: 10174 ms\n" + "<-- end bench4 size=3000, time: 9905 ms\n" ] } ], @@ -424,7 +566,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 43, "metadata": {}, "outputs": [ { @@ -432,7 +574,7 @@ "output_type": "stream", "text": [ "--> begin bench5 size=3000\n", - "<-- end bench5 size=3000, time: 10753 ms\n" + "<-- end bench5 size=3000, time: 12274 ms\n" ] } ], @@ -465,7 +607,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 44, "metadata": {}, "outputs": [ { @@ -473,7 +615,7 @@ "output_type": "stream", "text": [ "--> begin bench6 size=3000\n", - "<-- end bench6 size=3000, time: 7172 ms\n" + "<-- end bench6 size=3000, time: 6945 ms\n" ] } ], @@ -505,7 +647,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 45, "metadata": {}, "outputs": [ { @@ -513,7 +655,7 @@ "output_type": "stream", "text": [ "--> begin bench7 size=3000\n", - "<-- end bench7 size=3000, time: 6860 ms\n" + "<-- end bench7 size=3000, time: 7115 ms\n" ] } ], @@ -567,7 +709,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 46, "metadata": {}, "outputs": [ { @@ -577,89 +719,89 @@ "* start computing performance data\n", "* start computing results...\n", "--> begin [1/42] use build_bench_model1 with size=100\n", - "<-- end [1/42] use build_bench_model1 with size=100, time: 1116 ms\n", + "<-- end [1/42] use build_bench_model1 with size=100, time: 49 ms\n", "--> begin [2/42] use build_bench_model2 with size=100\n", - "<-- end [2/42] use build_bench_model2 with size=100, time: 39 ms\n", + "<-- end [2/42] use build_bench_model2 with size=100, time: 38 ms\n", "--> begin [3/42] use build_bench_model3 with size=100\n", - "<-- end [3/42] use build_bench_model3 with size=100, time: 27 ms\n", + "<-- end [3/42] use build_bench_model3 with size=100, time: 30 ms\n", "--> begin [4/42] use build_bench_model4 with size=100\n", - "<-- end [4/42] use build_bench_model4 with size=100, time: 23 ms\n", + "<-- end [4/42] use build_bench_model4 with size=100, time: 31 ms\n", "--> begin [5/42] use build_bench_model5 with size=100\n", - "<-- end [5/42] use build_bench_model5 with size=100, time: 23 ms\n", + "<-- end [5/42] use build_bench_model5 with size=100, time: 26 ms\n", "--> begin [6/42] use build_bench_model6 with size=100\n", - "<-- end [6/42] use build_bench_model6 with size=100, time: 21 ms\n", + "<-- end [6/42] use build_bench_model6 with size=100, time: 22 ms\n", "--> begin [7/42] use build_bench_model7 with size=100\n", - "<-- end [7/42] use build_bench_model7 with size=100, time: 19 ms\n", + "<-- end [7/42] use build_bench_model7 with size=100, time: 22 ms\n", "--> begin [8/42] use build_bench_model1 with size=300\n", - "<-- end [8/42] use build_bench_model1 with size=300, time: 245 ms\n", + "<-- end [8/42] use build_bench_model1 with size=300, time: 1519 ms\n", "--> begin [9/42] use build_bench_model2 with size=300\n", - "<-- end [9/42] use build_bench_model2 with size=300, time: 163 ms\n", + "<-- end [9/42] use build_bench_model2 with size=300, time: 174 ms\n", "--> begin [10/42] use build_bench_model3 with size=300\n", - "<-- end [10/42] use build_bench_model3 with size=300, time: 114 ms\n", + "<-- end [10/42] use build_bench_model3 with size=300, time: 136 ms\n", "--> begin [11/42] use build_bench_model4 with size=300\n", - "<-- end [11/42] use build_bench_model4 with size=300, time: 113 ms\n", + "<-- end [11/42] use build_bench_model4 with size=300, time: 120 ms\n", "--> begin [12/42] use build_bench_model5 with size=300\n", - "<-- end [12/42] use build_bench_model5 with size=300, time: 92 ms\n", + "<-- end [12/42] use build_bench_model5 with size=300, time: 112 ms\n", "--> begin [13/42] use build_bench_model6 with size=300\n", - "<-- end [13/42] use build_bench_model6 with size=300, time: 72 ms\n", + "<-- end [13/42] use build_bench_model6 with size=300, time: 81 ms\n", "--> begin [14/42] use build_bench_model7 with size=300\n", - "<-- end [14/42] use build_bench_model7 with size=300, time: 73 ms\n", + "<-- end [14/42] use build_bench_model7 with size=300, time: 82 ms\n", "--> begin [15/42] use build_bench_model1 with size=600\n", - "<-- end [15/42] use build_bench_model1 with size=600, time: 1057 ms\n", + "<-- end [15/42] use build_bench_model1 with size=600, time: 975 ms\n", "--> begin [16/42] use build_bench_model2 with size=600\n", - "<-- end [16/42] use build_bench_model2 with size=600, time: 681 ms\n", + "<-- end [16/42] use build_bench_model2 with size=600, time: 675 ms\n", "--> begin [17/42] use build_bench_model3 with size=600\n", - "<-- end [17/42] use build_bench_model3 with size=600, time: 425 ms\n", + "<-- end [17/42] use build_bench_model3 with size=600, time: 459 ms\n", "--> begin [18/42] use build_bench_model4 with size=600\n", - "<-- end [18/42] use build_bench_model4 with size=600, time: 389 ms\n", + "<-- end [18/42] use build_bench_model4 with size=600, time: 430 ms\n", "--> begin [19/42] use build_bench_model5 with size=600\n", - "<-- end [19/42] use build_bench_model5 with size=600, time: 393 ms\n", + "<-- end [19/42] use build_bench_model5 with size=600, time: 387 ms\n", "--> begin [20/42] use build_bench_model6 with size=600\n", - "<-- end [20/42] use build_bench_model6 with size=600, time: 247 ms\n", + "<-- end [20/42] use build_bench_model6 with size=600, time: 267 ms\n", "--> begin [21/42] use build_bench_model7 with size=600\n", - "<-- end [21/42] use build_bench_model7 with size=600, time: 253 ms\n", + "<-- end [21/42] use build_bench_model7 with size=600, time: 261 ms\n", "--> begin [22/42] use build_bench_model1 with size=1000\n", - "<-- end [22/42] use build_bench_model1 with size=1000, time: 2768 ms\n", + "<-- end [22/42] use build_bench_model1 with size=1000, time: 2647 ms\n", "--> begin [23/42] use build_bench_model2 with size=1000\n", - "<-- end [23/42] use build_bench_model2 with size=1000, time: 1825 ms\n", + "<-- end [23/42] use build_bench_model2 with size=1000, time: 1816 ms\n", "--> begin [24/42] use build_bench_model3 with size=1000\n", - "<-- end [24/42] use build_bench_model3 with size=1000, time: 1128 ms\n", + "<-- end [24/42] use build_bench_model3 with size=1000, time: 1089 ms\n", "--> begin [25/42] use build_bench_model4 with size=1000\n", - "<-- end [25/42] use build_bench_model4 with size=1000, time: 1048 ms\n", + "<-- end [25/42] use build_bench_model4 with size=1000, time: 1230 ms\n", "--> begin [26/42] use build_bench_model5 with size=1000\n", - "<-- end [26/42] use build_bench_model5 with size=1000, time: 1046 ms\n", + "<-- end [26/42] use build_bench_model5 with size=1000, time: 1106 ms\n", "--> begin [27/42] use build_bench_model6 with size=1000\n", - "<-- end [27/42] use build_bench_model6 with size=1000, time: 693 ms\n", + "<-- end [27/42] use build_bench_model6 with size=1000, time: 732 ms\n", "--> begin [28/42] use build_bench_model7 with size=1000\n", - "<-- end [28/42] use build_bench_model7 with size=1000, time: 714 ms\n", + "<-- end [28/42] use build_bench_model7 with size=1000, time: 748 ms\n", "--> begin [29/42] use build_bench_model1 with size=3000\n", - "<-- end [29/42] use build_bench_model1 with size=3000, time: 24263 ms\n", + "<-- end [29/42] use build_bench_model1 with size=3000, time: 24380 ms\n", "--> begin [30/42] use build_bench_model2 with size=3000\n", - "<-- end [30/42] use build_bench_model2 with size=3000, time: 16222 ms\n", + "<-- end [30/42] use build_bench_model2 with size=3000, time: 16630 ms\n", "--> begin [31/42] use build_bench_model3 with size=3000\n", - "<-- end [31/42] use build_bench_model3 with size=3000, time: 9826 ms\n", + "<-- end [31/42] use build_bench_model3 with size=3000, time: 9942 ms\n", "--> begin [32/42] use build_bench_model4 with size=3000\n", - "<-- end [32/42] use build_bench_model4 with size=3000, time: 9843 ms\n", + "<-- end [32/42] use build_bench_model4 with size=3000, time: 10362 ms\n", "--> begin [33/42] use build_bench_model5 with size=3000\n", - "<-- end [33/42] use build_bench_model5 with size=3000, time: 10558 ms\n", + "<-- end [33/42] use build_bench_model5 with size=3000, time: 12164 ms\n", "--> begin [34/42] use build_bench_model6 with size=3000\n", - "<-- end [34/42] use build_bench_model6 with size=3000, time: 9044 ms\n", + "<-- end [34/42] use build_bench_model6 with size=3000, time: 7352 ms\n", "--> begin [35/42] use build_bench_model7 with size=3000\n", - "<-- end [35/42] use build_bench_model7 with size=3000, time: 6884 ms\n", + "<-- end [35/42] use build_bench_model7 with size=3000, time: 7938 ms\n", "--> begin [36/42] use build_bench_model1 with size=5000\n", - "<-- end [36/42] use build_bench_model1 with size=5000, time: 70562 ms\n", + "<-- end [36/42] use build_bench_model1 with size=5000, time: 72734 ms\n", "--> begin [37/42] use build_bench_model2 with size=5000\n", - "<-- end [37/42] use build_bench_model2 with size=5000, time: 50955 ms\n", + "<-- end [37/42] use build_bench_model2 with size=5000, time: 49661 ms\n", "--> begin [38/42] use build_bench_model3 with size=5000\n", - "<-- end [38/42] use build_bench_model3 with size=5000, time: 28237 ms\n", + "<-- end [38/42] use build_bench_model3 with size=5000, time: 32211 ms\n", "--> begin [39/42] use build_bench_model4 with size=5000\n", - "<-- end [39/42] use build_bench_model4 with size=5000, time: 27734 ms\n", + "<-- end [39/42] use build_bench_model4 with size=5000, time: 31504 ms\n", "--> begin [40/42] use build_bench_model5 with size=5000\n", - "<-- end [40/42] use build_bench_model5 with size=5000, time: 28905 ms\n", + "<-- end [40/42] use build_bench_model5 with size=5000, time: 28823 ms\n", "--> begin [41/42] use build_bench_model6 with size=5000\n", - "<-- end [41/42] use build_bench_model6 with size=5000, time: 18852 ms\n", + "<-- end [41/42] use build_bench_model6 with size=5000, time: 21839 ms\n", "--> begin [42/42] use build_bench_model7 with size=5000\n", - "<-- end [42/42] use build_bench_model7 with size=5000, time: 19793 ms\n", + "<-- end [42/42] use build_bench_model7 with size=5000, time: 20010 ms\n", "* end computing results\n" ] } @@ -697,12 +839,12 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 47, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA54AAAGbCAYAAACs3U99AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdeVhWdeL+8fcBERARF9xXNDVEBBXcNR1LLfeVmcwys9LGvqWj2Z7tZaZOWZZNaZoVqGljVpbmvpSguEGSC24YIioCsj+f3x+Yv7FcUIHDcr+uq0uew1luHo9dz83nnPOxjDGIiIiIiIiIFBQnuwOIiIiIiIhIyabiKSIiIiIiIgVKxVNEREREREQKlIqniIiIiIiIFCgVTxERERERESlQZQrzYN7e3qZBgwaFeUgREREREREpJBEREaeMMVX/vLxQi2eDBg0IDw8vzEOKiIiIiIhIIbEs6/DllutSWxERERERESlQKp4iIiIiIiJSoFQ8RUREREREpEAV6j2el5OVlcWxY8dIT0+3O4rYzM3NjTp16uDi4mJ3FBERERERyUe2F89jx47h6elJgwYNsCzL7jhiE2MMiYmJHDt2DB8fH7vjiIiIiIhIPrL9Utv09HSqVKmi0lnKWZZFlSpVNPItIiIiIlIC2V48AZVOAXQeiIiIiIiUVEWieIqIiIiIiEjJpeIJdOjQ4ZrrjB49mqioKABee+21696+fPnyNxZORERERESkmLOMMYV2sKCgIBMeHn7JsujoaHx9fQstQ34oX748KSkpBb5NaVQczwcREREREcllWVaEMSboz8s14sn/H41cu3YtXbt2ZciQIdx6660MHz6cP4p5165dCQ8P58knnyQtLY3AwECGDx9+yfYpKSl0796dVq1a4e/vz9dff23PDyQiIiIiIlKE2D6dyv96cfleouLO5es+m9WqwAt9/fK8/o4dO9i7dy+1atWiY8eObNq0iU6dOl38/htvvMGsWbOIjIz8y7Zubm4sXbqUChUqcOrUKdq1a0e/fv300BwRERERESnVNOL5J23atKFOnTo4OTkRGBhIbGxsnrc1xvD000/TokULbr/9do4fP058fHzBhRURERERESkGitSI5/WMTBYUV1fXi187OzuTnZ2d520XLlxIQkICERERuLi40KBBA81LKSIiIiIipZ5GPG+Ai4sLWVlZf1melJREtWrVcHFxYc2aNRw+fNiGdCIiIiIiUtKcPZ9JTHyy3TFumIrnDXjooYdo0aLFxYcL/WH48OGEh4cTFBTEwoULufXWW21KKCIiIiIiJcW6mAR6zlzPIwu3k+MovFlJ8pOmU5EiReeDiIiIiEiutMwcXv8umvlbDtO4WnlmhATSvLaX3bGu6krTqRSpezxFREREREQEdh49y/jQSA6eSmVURx+e6NUUNxdnu2PdMBVPERERERGRIiI7x8F7aw7wzk+/Uc3TlYWj29LxFm+7Y900FU8REREREZEi4GBCCuPDdrLz6FkGBNbixf7N8XJ3sTtWvlDxFBERERERsZExhs9+PsKrK6JwLePMu/9oSd+AWnbHylcqniIiIiIiIjY5eS6dJ5bsYu2+BDo39uatIQHU8HKzO1a+U/EUERERERGxwbe7T/D00t2kZebwUn8/RrSrj2VZdscqECqeIiIiIiIihehcehZTvt7LVzuO06KOF9OHBXJLtfJ2xypQTnYHKO5iY2Np3rx5oR1v3rx5jBs3rtCOJyIiIiIi+WfLgUTunLmBr3fG8X/dG7NkbIcSXzpBI55FgjEGYwxOTvo9gIiIiIhISZSelcO0lfv4eNMhGlTxYPGY9rSsV8nuWIXmmsXTsqymQOj/LGoIPA/Mv7C8ARALDDPGnLmpNN89Cb/vvqld/EUNf7jzjSt+OzU1lWHDhnHs2DFycnJ47rnnaNiwIY899hipqam4urqyevVqEhMTGTFiBKmpqQDMmjWLDh06XPPw8+bNY+nSpWRkZHDo0CHuvvtuXnjhBWJjY7nzzjvp1q0bW7ZsYdmyZWzevJnXXnsNYwy9e/fmzTffBGDu3Lm8/vrr1KxZkyZNmuDq6po/742IiIiIiBS4vXFJjA+NJCY+hXva1ePpu3wpV7Z0jQFe86c1xuwDAgEsy3IGjgNLgSeB1caYNyzLevLC68kFmLVAfP/999SqVYsVK1YAkJSURMuWLQkNDSU4OJhz587h7u5OtWrV+PHHH3Fzc+O3337jH//4B+Hh4Xk6xi+//MKePXsoV64cwcHB9O7dG29vb/bt28fcuXN5//33iYuLY/LkyURERFCpUiV69OjBsmXLaNu2LS+88AIRERF4eXnRrVs3WrZsWZBviYiIiIiI5IMch2HO+oNM/3EfFcuVZe79wXRrWs3uWLa43prdHThgjDlsWVZ/oOuF5Z8Ca7nZ4nmVkcmC4u/vz8SJE5k8eTJ9+vShYsWK1KxZk+DgYAAqVKgA5I6Mjhs3jsjISJydnYmJicnzMe644w6qVKkCwKBBg9i4cSMDBgygfv36tGvXDoBt27bRtWtXqlatCsDw4cNZv349wCXLQ0JCruvYIiIiIiJS+I4knudfiyLZFnuGO5vX4NWB/lT2KGt3LNtcb/H8O/DFha+rG2NOABhjTliWddnqblnWQ8BDAPXq1bvRnAWmSZMmRERE8O233/LUU0/Ro0ePyz7CeMaMGVSvXp2dO3ficDhwc8v73Dp/3t8frz08PC4uM8bkeXsRERERESmajDEsCj/Gi8v34mRZTB8WwMCWtUv9Z/o8P83GsqyyQD9g0fUcwBgzxxgTZIwJ+mPUriiJi4ujXLly3HPPPUycOJGtW7cSFxfHtm3bAEhOTiY7O5ukpCRq1qyJk5MTCxYsICcnJ8/H+PHHHzl9+jRpaWksW7aMjh07/mWdtm3bsm7dOk6dOkVOTg5ffPEFt912G23btmXt2rUkJiaSlZXFokXX9faLiIiIiEghOZWSwUMLInhiyS7863jx3eOdGdSqTqkvnXB9I553AtuNMfEXXsdbllXzwmhnTeBk/screLt372bSpEk4OTnh4uLC7NmzMcbw6KOPkpaWhru7O6tWreKRRx5h8ODBLFq0iG7dul0yWnktnTp1YsSIEezfv5+7776boKAgYmNjL1mnZs2avP7663Tr1g1jDHfddRf9+/cHYMqUKbRv356aNWvSqlWr6yq9IiIiIiJS8FZFxfPkV7s4l5bNs719GdXRBycnFc4/WFe7xPOSFS3rS2ClMWbuhddvAYn/83ChysaYJ662j6CgIPPnB/JER0fj6+t7Q+GLg3nz5hEeHs6sWbPsjlIslPTzQURERERKlpSMbF75Joovtx3Ft2YFZoQEcGuNCnbHso1lWRHGmKA/L8/TiKdlWeWAO4CH/2fxG0CYZVkPAEeAofkRVEREREREpDgIjz3NhLCdHD1znjG3NWL8HY1xLeNsd6wiKU/F0xhzHqjyp2WJ5D7lVoCVK1cyefKlD/X18fFh6dKljBw50p5QIiIiIiKS7zKzHfx7dQyz1x6gVkV3Qh9qTxufynbHKtJK16ylBahnz5707NnT7hgiIiIiIlKAYuKTGR8ayd64cwwLqsNzfZrh6eZid6wiT8VTRERERETkGhwOw9zNsbz5/a94upZhzojW9PCrYXesYkPFU0RERERE5CrizqYxcdFONh9IpPut1XhjcAuqerraHatYUfEUERERERG5DGMMX0fG8dzXe8hxGN4Y5E9IcF3Ny3kDnOwOUNRMmTKFadOmXfH78+bNIy4u7uLrDRs24OfnR2BgIGlpaYURUURERERECtjZ85mM+2IHj4dG0qS6J9891pm/t6mn0nmDVDyv05+L58KFC5k4cSKRkZG4u7vbmExERERERPLDupgEesxYz8o9vzOpZ1PCHm5P/Soedscq1nSpLfDqq68yf/586tatS9WqVWndujWRkZGMGTOG8+fP06hRIz755BNWr15NeHg4w4cPx93dnQceeICwsDBWrlzJqlWrWLhwod0/ioiIiIiI3KC0zBxe/y6a+VsO07haeT4ZGUzz2l52xyoRilTxfPOXN/n19K/5us9bK9/K5DaTr/j9iIgIvvzyS3bs2EF2djatWrWidevW3Hvvvbz77rvcdtttPP/887z44ovMnDmTWbNmMW3aNIKCgi5u36dPH4YMGZKvuUVEREREpPDsPHqW8aGRHDyVyqiOPjzRqyluLs52xyoxilTxtMOGDRsYOHAg5cqVA6Bfv36kpqZy9uxZbrvtNgDuu+8+hg4damdMEREREREpANk5Dt5bc4B3fvqNap6uLBzdlo63eNsdq8QpUsXzaiOTBUk3CIuIiIiIlD4HE1IYH7aTnUfPMiCwFi/2b46Xu4vdsUqkUv9woS5durB06VLS0tJITk5m+fLleHh4UKlSJTZs2ADAggULLo5+enp6kpycbGdkERERERG5CcYYFmw9zF3vbCD2VCqz7m7JzL+3VOksQEVqxNMOrVq1IiQkhMDAQOrXr0/nzp0B+PTTTy8+XKhhw4bMnTsXgJEjRzJmzBjc3d3ZsmWLndFFREREROQ6nTyXzqTFu1gXk0Dnxt68NSSAGl5udscq8SxjTKEdLCgoyISHh1+yLDo6Gl9f30LLIEWbzgcRERERKSjf7j7B00t3k56Vw9N3+TKiXX3ddpfPLMuKMMYE/Xl5qR/xFBERERGRku1cehZTvt7LVzuOE1DHi+khgTSqWt7uWKWKiqeIiIiIiJRYWw4k8q+wSOKTM3ise2PG/e0WXJxL/aNuCp2Kp4iIiIiIlDjpWTlMW7mPjzcdokEVDxaPaU/LepXsjlVqqXiKiIiIiEiJsjcuifGhkcTEp3BPu3o8fZcv5cqq+thJ776IiIiIiJQIOQ7DnPUHmf7jPiqWK8vc+4Pp1rSa3bEEFU8RERERESkBjiSe51+LItkWe4Y7m9fg1YH+VPYoa3csuUDFU0REREREii1jDGHhR3lpeRROlsX0YQEMbFlb06QUMXqcExAbG0vz5s3zvP68efOIi4u75jrjxo27qVxr165l8+bNN7UPEREREZGS6lRKBg8tiGDykt341/Hiu8c7M6hVHZXOIkgjnjdg3rx5NG/enFq1ahXocdauXUv58uXp0KFDgR5HRERERKS4+TEqnqe+2sW5tGye7e3LqI4+ODmpcBZVRap4/v7aa2RE/5qv+3T1vZUaTz99zfWys7O577772LFjB02aNGH+/PlMmzaN5cuXk5aWRocOHfjwww9ZsmQJ4eHhDB8+HHd3d7Zs2cKePXt47LHHSE1NxdXVldWrVwMQFxdHr169OHDgAAMHDmTq1KlXPP7333/P008/TU5ODt7e3nz88cd88MEHODs789lnn/Huu+/y+++/8+KLL+Ls7IyXlxfr16/Pt/dJRERERKQ4SMnI5pVvovhy21F8a1Zg4ehAmtbwtDuWXEORKp522rdvHx9//DEdO3Zk1KhRvP/++4wbN47nn38egBEjRvDNN98wZMgQZs2axbRp0wgKCiIzM5OQkBBCQ0MJDg7m3LlzuLu7AxAZGcmOHTtwdXWladOmPProo9StW/cvx05ISODBBx9k/fr1+Pj4cPr0aSpXrsyYMWMoX748EydOBMDf35+VK1dSu3Ztzp49W3hvjoiIiIhIERAee5oJYTs5euY8Y25rxPg7GuNaxtnuWJIHRap45mVksqDUrVuXjh07AnDPPffwzjvv4OPjw9SpUzl//jynT5/Gz8+Pvn37XrLdvn37qFmzJsHBwQBUqFDh4ve6d++Ol5cXAM2aNePw4cOXLZ5bt26lS5cu+Pj4AFC5cuXLZuzYsSMjR45k2LBhDBo06OZ/aBERERGRYiAz28HMVTF8sO4AtSq6E/pQe9r4XP4zsxRNRap42unPNyBblsUjjzxCeHg4devWZcqUKaSnp/9lO2PMFW9ednV1vfi1s7Mz2dnZl13vavv4Xx988AE///wzK1asIDAwkMjISKpUqXLN7UREREREiquY+GQe/zKSqBPnGBZUh+f6NMPTzcXuWHKd9FTbC44cOcKWLVsA+OKLL+jUqRMA3t7epKSksHjx4ovrenp6kpycDMCtt95KXFwc27ZtAyA5OfmKBfNK2rdvz7p16zh06BAAp0+f/stxAA4cOEDbtm156aWX8Pb25ujRozf404qIiIiIFG0Oh+E/Gw7S592NxJ9LZ86I1kwdEqDSWUxpxPMCX19fPv30Ux5++GEaN27M2LFjOXPmDP7+/jRo0ODipbQAI0eOZMyYMRcfLhQaGsqjjz5KWloa7u7urFq16rqOXbVqVebMmcOgQYNwOBxUq1aNH3/8kb59+zJkyBC+/vpr3n33XWbMmMFvv/2GMYbu3bsTEBCQ32+DiIiIiIjtjp9NY9KinWw+kMjtvtV4fVALqnq6XntDKbIsY0yhHSwoKMiEh4dfsiw6OhpfX99CyyBFm84HERERkdLLGMOyyOM8//VechyG5/s0IyS4rublLEYsy4owxgT9eblGPEVERERExHZnz2fyzNI9rNh9gtb1KzF9WAD1q3jYHUvyiYpnIWvbti0ZGRmXLFuwYAH+/v42JRIRERERsde6mAQmLdrJ6dRMJvVsypjbGuHspFHOkkTFs5D9/PPPdkcQERERESkS0jJzeP27aOZvOUzjauX5ZGQwzWt72R1LCoCKp4iIiIiIFLqdR88yPjSSg6dSGdXRhyd6NcXNxdnuWFJAVDxFRERERKTQZOU4eG/Nft79aT/VPF1ZOLotHW/xtjuWFDAVTxERERERKRQHE1IYH7aTnUfPMiCwFi/2b46Xu+blLA1UPEVEREREpEAZY/js5yO8uiIK1zLOzLq7JX1a1LI7lhQiFU+gQ4cObN682e4YIiIiIiIlTvy5dJ5YvIt1MQl0buzNW0MCqOHlZncsKWQqnlDgpTM7O5syZfRWi4iIiEjp8u3uEzy9dDfpWTm81N+PEe3qY1maJqU0ylMbsiyrIvAfoDlggFHAPiAUaADEAsOMMWduJsyGsBhOHU25mV38hXfd8nQe1uSq65QvX56UlBQcDgfjxo1j3bp1+Pj44HA4GDVqFEOGDKFBgwbcd999LF++nKysLBYtWsStt97K6dOnGTVqFAcPHqRcuXLMmTOHFi1aMGXKFOLi4oiNjcXb25sFCxbw5JNPsnbtWjIyMvjnP//Jww8/fNk8a9euZcqUKXh7e7Nnzx5at27NZ599hmVZvPTSSyxfvpy0tDQ6dOjAhx9+iGVZdO3alZYtWxIREUFCQgLz58/n9ddfZ/fu3YSEhPDKK68A8Nlnn/HOO++QmZlJ27Ztef/99wF44IEHCA8Px7IsRo0axfjx4/P170FERERESo9z6VlM+XovX+04TkAdL6aHBNKoanm7Y4mNnPK43r+B740xtwIBQDTwJLDaGNMYWH3hdbH21VdfERsby+7du/nPf/7Dli1bLvm+t7c327dvZ+zYsUybNg2AF154gZYtW7Jr1y5ee+017r333ovrR0RE8PXXX/P555/z8ccf4+XlxbZt29i2bRsfffQRhw4dumKWHTt2MHPmTKKiojh48CCbNm0CYNy4cWzbto09e/aQlpbGN998c3GbsmXLsn79esaMGUP//v1577332LNnD/PmzSMxMZHo6GhCQ0PZtGkTkZGRODs7s3DhQiIjIzl+/Dh79uxh9+7d3H///fn5toqIiIhIKbL5wCl6zVjP1zvjeKx7YxaP7aDSKdce8bQsqwLQBRgJYIzJBDIty+oPdL2w2qfAWmDyzYS51shkQdu4cSNDhw7FycmJGjVq0K1bt0u+P2jQIABat27NV199dXGbJUuWAPC3v/2NxMREkpKSAOjXrx/u7u4A/PDDD+zatYvFixcDkJSUxG+//YaPj89ls7Rp04Y6deoAEBgYSGxsLJ06dWLNmjVMnTqV8+fPc/r0afz8/Ojbt+/F4wH4+/vj5+dHzZo1AWjYsCFHjx5l48aNREREEBwcDEBaWhrVqlWjb9++HDx4kEcffZTevXvTo0ePfHg3RURERKQ0Sc/KYdrKffxn4yF8vD1YPKY9LetVsjuWFBF5udS2IZAAzLUsKwCIAB4DqhtjTgAYY05YllXtchtblvUQ8BBAvXr18iV0QTHGXPX7rq6uADg7O5OdnX3Fbf64bt3Dw+OSfb/77rv07NkzT1n+ONb/Hi89PZ1HHnmE8PBw6taty5QpU0hPT//LNk5OTpds7+TkRHZ2NsYY7rvvPl5//fW/HG/nzp2sXLmS9957j7CwMD755JM85RQRERER2RuXxPjQSGLiU7inXT2evsuXcmX1jBP5//JyqW0ZoBUw2xjTEkjlOi6rNcbMMcYEGWOCqlateoMxC0enTp1YsmQJDoeD+Ph41q5de81tunTpwsKFC4HcezO9vb2pUKHCX9br2bMns2fPJisrC4CYmBhSU1OvK98fJdPb25uUlJSLo6d51b17dxYvXszJkycBOH36NIcPH+bUqVM4HA4GDx7Myy+/zPbt269rvyIiIiJSOuU4DO+v3c+A9zZx5nwWc+8P5pUB/iqd8hd5OSOOAceMMT9feL2Y3OIZb1lWzQujnTWBkwUVsrAMHjyY1atX07x5c5o0aULbtm3x8vK66jZTpkzh/vvvp0WLFpQrV45PP/30suuNHj2a2NhYWrVqhTGGqlWrsmzZsuvKV7FiRR588EH8/f1p0KDBxUtm86pZs2a88sor9OjRA4fDgYuLC++99x7u7u7cf//9OBwOgMuOiIqIiIiI/K8jieeZEBZJ+OEz3Nm8Bq8N9KeSR1m7Y0kRZV3r8lIAy7I2AKONMfssy5oC/HENaaIx5g3Lsp4EKhtjnrjafoKCgkx4ePgly6Kjo/H19b2h8AUhJSWF8uXLk5iYSJs2bdi0aRM1atSwO1apUdTOBxERERG5lDGGsPCjvLQ8CifL4sX+fgxsWVvTpAgAlmVFGGOC/rw8r2PgjwILLcsqCxwE7if3Mt0wy7IeAI4AQ/MrrJ369OnD2bNnyczM5LnnnlPpFBERERG54FRKBk8u2c2q6HjaNazM28MCqV3R3e5YUgzkqXgaYyKBv7RWoHv+xrFfXu7rzC+7d+9mxIgRlyxzdXXl559/vsIWIiIiIiL2+DEqnieX7CI5PZtne/syqqMPTk4a5ZS80V2/NvL39ycyMtLuGCIiIiIiV5SSkc0r30Tx5baj+NaswOcPBtK0hqfdsaSYUfEUEREREZHLCo89zfiwSI6dSWNs10Y8fntjXMs42x1LiiEVTxERERERuURmtoOZq2L4YN0BalV0J/Sh9rTxqWx3LCnGVDxFREREROSimPhkHv8ykqgT5wgJqstzfZtR3lW1QW6OziAREREREcHhMHyy6RBTV+7D07UMc0a0poefZniQ/OFkdwC5PrGxsTRv3rzI7Cev3nnnHXx9fRk+fDgZGRncfvvtBAYGEhoaWmgZREREROTyjp9NY/h/fuaVFdF0aezN9493UemUfFWkRjzXzJvDycMH83Wf1eo3pNvIh/J1n6VdTk4Ozs7Xd1P5+++/z3fffYePjw9bt24lKytLT/QVERERsZkxhmWRx3n+673kOAxvDPInJLgulqVpUiR/acST3NE/X19fHnzwQfz8/OjRowdpaWl89NFHBAcHExAQwODBgzl//jwAI0eOZOzYsXTr1o2GDRuybt06Ro0aha+vLyNHjry43x9++IH27dvTqlUrhg4dSkpKCgBPPvkkzZo1o0WLFkycOPGKueLj4xk4cCABAQEEBASwefNmILf4/TkrwIEDB+jVqxetW7emc+fO/Prrr1fdzx8OHjxIy5Yt2bZtGzk5OUyaNIng4GBatGjBhx9+COTOb9qtWzfuvvtu/P39r5h5+vTpNG/enObNmzNz5kwAxowZw8GDB+nXrx9vvvkm99xzD5GRkQQGBnLgwIHr+asSERERkXxyJjWTcZ/vYHzoTppU9+S7xzrz9zb1VDqlYBhjCu2/1q1bmz+Lior6y7LCdujQIePs7Gx27NhhjDFm6NChZsGCBebUqVMX13nmmWfMO++8Y4wx5r777jMhISHG4XCYZcuWGU9PT7Nr1y6Tk5NjWrVqZXbs2GESEhJM586dTUpKijHGmDfeeMO8+OKLJjEx0TRp0sQ4HA5jjDFnzpy5Yq5hw4aZGTNmGGOMyc7ONmfPnr1iVmOM+dvf/mZiYmKMMcZs3brVdOvW7ar78fPzM7/++qsJDAy8uL8PP/zQvPzyy8YYY9LT003r1q3NwYMHzZo1a0y5cuXMwYMHr5g3PDzcNG/e3KSkpJjk5GTTrFkzs337dmOMMfXr1zcJCQnGGGPWrFljevfufdl9FIXzQURERKSkW7vvpAl+5UfT6KkVZtZPv5nsHIfdkaSEAMLNZbpgkbrU1k4+Pj4EBgYC0Lp1a2JjY9mzZw/PPvssZ8+eJSUlhZ49e15cv2/fvliWhb+/P9WrV784Cujn50dsbCzHjh0jKiqKjh07ApCZmUn79u2pUKECbm5ujB49mt69e9OnT58rZvrpp5+YP38+AM7Oznh5eXHmzJnLZk1JSWHz5s0MHTr04vYZGRlX3U9CQgL9+/dnyZIl+Pn5AbmjtLt27WLx4sUAJCUl8dtvv1G2bFnatGmDj4/PFfNu3LiRgQMH4uHhAcCgQYPYsGEDLVu2zOtfg4iIiIgUoLTMHF7/Lpr5Ww7TuFp5PhkZTPPaXnbHklJAxfMCV1fXi187OzuTlpbGyJEjWbZsGQEBAcybN4+1a9f+ZX0nJ6dLtnVyciI7OxtnZ2fuuOMOvvjii78c65dffmH16tV8+eWXzJo1i59++ummszocDipWrHhd9016eXlRt25dNm3adLF4GmN49913LynZkHup7R+F8kpyf8EhIiIiIkVR5NGzTAiN5OCpVB7o5MOknk1xc7m+53aI3Cjd43kVycnJ1KxZk6ysLBYuXHhd27Zr145Nmzaxf/9+AM6fP09MTAwpKSkkJSVx1113MXPmzKsWxe7duzN79mwg977Oc+fOXXHdChUq4OPjw6JFi4DcErhz586r7qds2bIsW7aM+fPn8/nnnwPQs2dPZs+eTVZWFgAxMYQD1Q4AACAASURBVDGkpqbm6Wfu0qULy5Yt4/z586SmprJ06VI6d+6cp21FREREpGBk5TiYuSqGwbM3k5aVw8LRbXmuTzOVTilUGvG8ipdffpm2bdtSv359/P39SU5OzvO2VatWZd68efzjH/+4eMnrK6+8gqenJ/379yc9PR1jDDNmzLjiPv7973/z0EMP8fHHH+Ps7Mzs2bOpWbPmFddfuHAhY8eO5ZVXXiErK4u///3vBAQEXHU/Hh4efPPNN9xxxx14eHgwevRoYmNjadWqFcYYqlatyrJly/L0M7dq1YqRI0fSpk0bAEaPHq3LbEVERERsdDAhhfFhO9l59CwDW9ZmSj8/vNxd7I4lpZBVmJdHBgUFmfDw8EuWRUdH4+vrW2gZpGjT+SAiIiJy84wxfLb1MK9+G41rGWdeHdicPi1q2R1LSgHLsiKMMUF/Xq4RTxERERGREiT+XDqTFu9ifUwCnRt789aQAGp4udkdS0o5Fc8i4NVXX714b+Yfhg4dyjPPPGNToqtLTEyke/fuf1m+evVqqlSpYkMiEREREQFYsesEzyzbTXpWDi/192NEu/qal1OKBF1qK0WKzgcRERGR65eUlsWU/+5l6Y7jBNTxYnpIII2qlrc7lpRCutRWRERERKQE2nzgFBPDdhKfnMFj3Rsz7m+34OKsySukaFHxFBEREREphtKzcnhr5T4+3ngIH28PloztQGDdinbHErksFU8RERERkWJmz/EkJoRFEhOfwoh29XnqrlspV1Yf7aXo0tkpIiIiIlJM5DgMH64/wIwfY6hYrixz7w+mW9NqdscSuSYVz2IgJycHZ2dnu2OIiIiIiI2OJJ5nQlgk4YfPcJd/DV4d4E8lj7J2xxLJkyJVPM8uP0BmXGq+7rNsLQ8q9m10xe+npqYybNgwjh07Rk5ODs899xyTJ08mPDwcb29vwsPDmThxImvXrmXKlCkcOnSIEydOEBMTw/Tp09m6dSvfffcdtWvXZvny5bi4uPzlGN999x1z584lLCwMgLVr1/L222+zfPlyxo4dy7Zt20hLS2PIkCG8+OKLADRo0IBRo0bxww8/MG7cOE6ePMkHH3xAmTJlaNasGV9++WW+vk8iIiIiUjQZYwgLP8pLy6NwsixmhAQwILC2pkmRYqVIFU87fP/999SqVYsVK1YAkJSUxOTJk6+4/oEDB1izZg1RUVG0b9+eJUuWMHXqVAYOHMiKFSsYMGDAX7a54447ePjhh0lNTcXDw4PQ0FBCQkKA3Dk8K1euTE5ODt27d2fXrl20aNECADc3NzZu3AhArVq1OHToEK6urpw9eza/3wYRERERKYJOpWTw5JLdrIqOp13Dyrw9LJDaFd3tjiVy3YpU8bzayGRB8ff3Z+LEiUyePJk+ffrQuXPnq65/55134uLigr+/Pzk5OfTq1evifmJjYy+7TZkyZejVqxfLly9nyJAhrFixgqlTpwIQFhbGnDlzyM7O5sSJE0RFRV0snn+UU4AWLVowfPhwBgwYcNlyKyIiIiIly49R8Ty5ZBfJGdk829uXUR19cHLSKKcUT0WqeNqhSZMmRERE8O233/LUU0/Ro0cPypQpg8PhACA9Pf2S9V1dXQFwcnLCxcXl4iUOTk5OZGdnX/E4ISEhvPfee1SuXJng4GA8PT05dOgQ06ZNY9u2bVSqVImRI0decjwPD4+LX69YsYL169fz3//+l5dffpm9e/dSpkyp/+sTERERKXFSMrJ5eXkUoeFH8a1Zgc9DAmlaw9PuWCI3pdTPLBsXF0e5cuW45557mDhxItu3b6dBgwZEREQAsGTJknw5TteuXdm+fTsfffTRxZHMc+fO4eHhgZeXF/Hx8Xz33XeX3dbhcHD06FG6devG1KlTOXv2LCkpKfmSS0RERESKjvDY09z57/WERRxlbNdGLPtnB5VOKRFK/ZDZ7t27mTRp0sURzNmzZ5OWlsYDDzzAa6+9Rtu2bfPlOM7OzvTp04d58+bx6aefAhAQEEDLli3x8/OjYcOGdOzY8bLb5uTkcM8995CUlIQxhvHjx1OxoiYHFhERESkpMrMdzFgVw4frDlC7kjthD7cnuEFlu2OJ5BvLGFNoBwsKCjLh4eGXLIuOjsbX17fQMkjRpvNBRERESpuY+GQe/zKSqBPnCAmqy3N9m1HetdSPD0kxZVlWhDEm6M/LdUaLiIiIiNjA4TB8sukQU1fuw9O1DHNGtKaHXw27Y4kUCBXPfDZw4EAOHTp0ybI333yTnj172pRIRERERIqa42fTmBi2ky0HE7ndtxqvD2pBVU9Xu2OJFBgVz3y2dOlSuyOIiIiISBFljGFZ5HGeX7aXHGN4Y5A/IcF1L86UIFJSFYniaYzRPzahMO83FhERESlsZ1IzeXbZHlbsPkHr+pWYPiyA+lU8rr2hSAlge/F0c3MjMTGRKlWqqHyWYsYYEhMTcXNzszuKiIiISL5bu+8kTyzexenUTCb1bMqY2xrh7KTPvlJ62F4869Spw7Fjx0hISLA7itjMzc2NOnXq2B1DREREJN+kZebw2rfRLNh6mMbVyvPJyGCa1/ayO5ZIobO9eLq4uODj42N3DBERERGRfBV59CwTQiM5eCqVBzr5MKlnU9xcnO2OJWIL24uniIiIiEhJkpXjYNZP+5m1Zj/VPF35fHRbOtzibXcsEVupeIqIiIiI5JMDCSlMCI1k57EkBraszZR+fni5u9gdS8R2Kp4iIiIiIjfJGMNnWw/z6rfRuJZxZtbdLenTopbdsUSKjDwVT8uyYoFkIAfINsYEWZZVGQgFGgCxwDBjzJmCiSkiIiIiUjTFn0tn0uJdrI9JoHNjb6YNDaB6BT2pX+R/Xc+IZzdjzKn/ef0ksNoY84ZlWU9eeD05X9OJiIiIiBRhK3ad4Jllu0nPyuGl/n6MaFdfUwSKXMbNXGrbH+h64etPgbWoeIqIiIhIKZCUlsWU/+5l6Y7jBNTxYnpIII2qlrc7lkiRldfiaYAfLMsywIfGmDlAdWPMCQBjzAnLsqpdbkPLsh4CHgKoV69ePkQWEREREbHP5v2nmLhoJ/HJGTzWvTHj/nYLLs5OdseSku7IVkiJh2b97U5yQ/JaPDsaY+IulMsfLcv6Na8HuFBS5wAEBQWZG8goIiIiImK79Kwc3lq5j483HsLH24MlYzsQWLei3bGkJDMG9q+GDW/Dkc1Q9Vbw7QfF8HLuPBVPY0zchT9PWpa1FGgDxFuWVfPCaGdN4GQB5hQRERERsc2e40lMCIskJj6FEe3q89Rdt1KurCaIkALiyIHo/8KG6fD7LqhQG3q9Aa3uLZalE/JQPC3L8gCcjDHJF77uAbwE/Be4D3jjwp9fF2RQEREREZHCluMwfLDuADNXxVCxXFnm3R9M16aXvcNM5OZlZ8KuUNg0ExL3Q5VboN8saBECZcrane6m5OXXNNWBpReezlUG+NwY871lWduAMMuyHgCOAEMLLqaIiIiISOE6knieCWGRhB8+w13+NXh1gD+VPIr3h38pojJTYft82PwunDsONVrA0Hm5l9U6OdudLl9cs3gaYw4CAZdZngh0L4hQIiIiIiJ2McYQFn6Ul5ZH4WRZzAgJYEBgbU2TIvkv7Qz88hFsnQ1pp6F+R+j3DjTqXmwvqb0SXZguIiIiInJBQnIGT321i1XRJ2nfsArThgVQu6K73bGkpEn+Hba8B+GfQGYKNO4JnSdAvXZ2JyswKp4iIiIiIsCPUfE8uWQXyRnZPNvbl1EdfXByKlmjTmKz04dg8zuwYyE4ssBvIHQaDzX87U5W4FQ8RURERKRUS8nI5uXlUYSGH8W3ZgU+DwmkaQ1Pu2NJSRIfBRtnwJ4lufdsBvwDOj4GVRrZnazQqHiKiIiISKm1LfY0E8IiOXYmjbFdGzH+9iaULeNkdywpKY5ug43TYd+34OIB7cZC+39ChVp2Jyt0Kp4iIiIiUupkZjuYsSqGD9YdoE4ld8Iebk9wg8p2x5KSwBg4uCZ3Ds7YDeBWEbo+BW0egnKl9xxT8RQRERGRUmXf78mMD40k6sQ5QoLq8lzfZpR31cdiuUkOB/z6Te4IZ9wO8KwJPV6F1iPBtbzd6Wynf2EiIiIiUio4HIZPNh1i6sp9eLqW4aN7g7ijWXW7Y0lxl5MFuxfl3sN5KgYq+UDff+fex1nG1e50RYaKp4iIiIiUeMfPpjExbCdbDiZyu2913hjsj3d5lQK5CVlpsH1B7lNqk45C9eYw+GNoNgCcVbP+TO+IiIiIiJRYxhiWRR7n+WV7cRjDm4P9GRZUF8vSNClyg9KTYNt/YMv7cP4U1G0Hvd+Gxj1A59UVqXiKiIiISIl0JjWTZ5ftYcXuEwTVr8T0YYHUq1LO7lhSXKWchK3vw7aPIeMc3HI7dP4X1O9gd7JiQcVTREREREqctftO8sTiXZw5n8kTvZrycJdGODtpNEpuwNkjsPld2D4fsjOgWX/oNB5qBdqdrFhR8RQRERGREuN8Zjavf/srC7YepnG18nwyMpjmtb3sjiXFUcK+3AcG7V4EWBAQAh0fB+/GdicrllQ8RURERKREiDx6lgmhkRw8lcoDnXyY1LMpbi7OdseS4uZ4RO4cnL+ugDJuEPwgdBgHXnXsTlasqXiKiIiISLGWleNg1k/7mbVmP9U9Xfl8dFs63OJtdywpToyB2A2w4W04uBbcvKDLRGg7Bjx0LuUHFU8RERERKbYOJKQwITSSnceSGNiyNlP6+eHl7mJ3LCkuHA6I+S53hPN4OHhUgztegtb3g1sFu9OVKCqeIiIiIlLsGGP4bOthXv02Gtcyzsy6uyV9WtSyO5YUFznZsGdJ7j2cCdFQsR70ng6Bw8HFze50JZKKp4iIiIgUK/Hn0pm0eBfrYxLo0qQqbw1pQfUKKguSB1npEPkZbHoHzh6Gqr4w6CPwGwTOqkYFSe+uiIiIiBQbK3ad4Jllu0nPyuHl/n7c064+lqVpUuQa0s9B+Ce583CmxEPtIOj1BjTpBU5OdqcrFVQ8RURERKTIS0rLYsp/97J0x3EC6ngxPSSQRlXL2x1LirrUU/DzB/DLHEhPgobdYPB/oEFn0C8sCpWKp4iIiIgUaZv3n2Liop3EJ2fw+O2N+We3W3Bx1iiVXEXSMdg8CyLmQXYa+PaFTuOhdmu7k5VaKp4iIiIiUiSlZ+Xw1sp9fLzxED7eHiwZ24HAuhXtjiVF2an9sGkG7AwFDPgPg06PQ9Wmdicr9VQ8RURERKTI2XM8ifGhkfx2MoUR7erz1F23Uq6sPrrKFcRFwsbpEPVfKOMKQfdDh0dzn1YrRYL+9YqIiIhIkZHjMHyw7gAzV8VQqVxZ5t0fTNem1eyOJUWRMXB4M2x4Gw6sBtcKuZfTthsL5XXOFDUqniIiIiJSJBxJPM+EsEjCD5/hLv8avDrAn0oeZe2OJUWNMfDbD7mF8+jPUM4buj8PwaPBzcvudHIFKp4iIiIiYitjDGHhR3lpeRROlsWMkAAGBNbWNClyqZxsiFoGG2dA/B7wqgt3TYOW94CLu93p5BpUPEVERETENgnJGTz11S5WRZ+kfcMqTBsWQO2KKhHyP7IzIPJz2PRvOHMIvJvAgA/Afwg4u9idTvJIxVNEREREbPHD3t956qvdJGdk82xvX0Z19MHJSaOcckFGCkTMhS3vQfIJqNUSenwGTXuDk6bTKW5UPEVERESkUKVkZPPy8ihCw4/iW7MCn4cE0rSGp92xpKg4fxp+/hB++RDSzoBPFxgwGxp2BV1+XWypeIqIiIhIodkWe5oJYZEcP5PGI10b8fjtTShbRqNXApyLyx3dDJ8LWam5I5udJ0CdILuTST5Q8RQRERGRApeZ7WDGqhg+WHeAOpXcCX24PcENKtsdS4qCxAO592/u/AIcObn3bnZ8HKo3szuZ5CMVTxEREREpUPt+T+bx0EiiT5wjJKguz/VtRnlXfQwt9X7fnfuE2r1LwckFWo6Ajv8HlRrYnUwKgP7Fi4iIiEiBcDgMn2w6xNSV+/B0LcNH9wZxR7PqdscSux3ZChumw28roWx56PAotPsneOrcKMlUPEVEREQk3x0/m8bEsJ1sOZjI7b7VeWOwP97lXe2OJXYxBvavhg1vw5HNUK4KdHsW2owG90p2p5NCoOIpIiIiIvnGGMOyyOM8v2wvDmN4c7A/w4LqYulppKWTIwei/5s7wvn7LqhQG3q9Aa3uhbIedqeTQqTiKSIiIiL54kxqJs8s2823u38nqH4lpg8LpF6VcnbHEjtkZ8KuUNg0ExL3Q5VboN8saBECZcranU5soOIpIiIiIjdt7b6TPLF4F2fOZ/JEr6Y83KURzk4a5Sx1MlNh+3zY/C6cOw41WsDQeeDbD5yc7U4nNlLxFBEREZEbdj4zm9e//ZUFWw/TuFp5PhkZTPPaXnbHksKWdgZ++Qi2zoa001C/I/R7Bxp1B11mLah4ioiIiMgN2nHkDBPCdnLoVCqjO/kwsWdT3Fw0qlWqJP8OW96D8E8gMwUa94TOE6BeO7uTSRGT5+JpWZYzEA4cN8b0sSzLB/gSqAxsB0YYYzILJqaIiIiIFBVZOQ5m/bSfWWv2U93Tlc9Ht6XDLd52x5LCdPoQbH4HdiwERxb4DYRO46GGv93JpIi6nhHPx4BooMKF128CM4wxX1qW9QHwADA7n/OJiIiISBFyICGFCaGR7DyWxMCWtZnSzw8vdxe7Y0lhiY+CjTNgz5LcezYD74YO/wdVGtmdTIq4PBVPy7LqAL2BV4EJVu7zsP8G3H1hlU+BKah4ioiIiJRIxhgWbD3Ma99G4+bizHt3t6J3i5p2x5LCcnQbbJwO+74FFw9oNxbaj4MKOgckb/I64jkTeALwvPC6CnDWGJN94fUxoPblNrQs6yHgIYB69erdeFIRERERsUX8uXQmLd7F+pgEujSpyltDWlC9gpvdsaSgGQMH1+TOwRm7AdwqQtenoM1DUK6y3emkmLlm8bQsqw9w0hgTYVlW1z8WX2ZVc7ntjTFzgDkAQUFBl11HRERERIqmFbtO8PTS3WRk5/Byfz/uaVcfS08pLdkcDvj1m9wRzrgd4FkTerwKrUeCa3m700kxlZcRz45AP8uy7gLcyL3HcyZQ0bKsMhdGPesAcQUXU0REREQKU1JaFi98vYdlkXEE1PFiekggjaqqdJRoOVmwe1HuPZynYqCSD/T9NwT8A8q42p1OirlrFk9jzFPAUwAXRjwnGmOGW5a1CBhC7pNt7wO+LsCcIiIiIlJINu8/xb8W7eRkcgaP396Yf3a7BRdnJ7tjSUHJSoPtC3KfUpt0FKo3h8EfQ7MB4KzZFyV/3MyZNBn40rKsV4AdwMf5E0lERERE7JCelcNbK/fx8cZDNPT2YMnYDgTWrWh3LCko6Umw7T+w5X04fwrqtoPeb0PjHqDLqSWfXVfxNMasBdZe+Pog0Cb/I4mIiIhIYdtzPInxoZH8djKFe9vX56k7fXEv62x3LCkIKSdh6/uw7WPIOAe33A6d/wX1O9idTEowjZ2LiIiIlGI5DsMH6w4wc1UMlcqVZd79wXRtWs3uWFIQzh6Bze/C9vmQnQHN+kPnCVAzwO5kUgqoeIqIiIiUUkcSzzMhLJLww2fo7V+TVwY0p5JHWbtjSX5L2Jf7wKDdiwALAkKg4+Pg3djuZFKKqHiKiIiIlDLGGEK3HeWlb6JwdrKYGRJI/8BamialpDkekTsH568rwMU9d/7N9v8Erzp2J5NSSMVTREREpBRJSM7gqa92sSr6JO0bVmHasABqV3S3O5bkF2MgdgNseBsOrgU3L+gyCdqOAY8qdqeTUkzFU0RERKSU+GHv7zz11W6SM7J5trcvozr64OSkUc4SweGAmO9yRziPh4NHNbjjJWh9P7hVsDudiIqniIiISEmXkpHNS8v3EhZ+jGY1K/DF3wNpUt3T7liSH3KyYc+S3Hs4E6KhYn3oPR0Ch4OLm93pRC5S8RQREREpwbbFnmZCWCTHz6TxSNdGPH57E8qWcbI7ltysrHSI/Aw2vQNnD0NVXxj0EfgNAmd9xJeiR2eliIiISAmUme1gxqoYPlh3gLqVyhH2cHuCGlS2O5bcrPRzEP5J7jycKfFQOwh6vQFNeoGTfqEgRZeKp4iIiEgJs+/3ZB4PjST6xDn+HlyXZ/s0o7yrPvYVa6mn4OcP4Jc5kJ4EDbvB4P9Ag86gpxFLMaD/A4mIiIiUEA6H4ZNNh5j6/T483crw0b1B3NGsut2x5GYkHYPNsyBiHmSngW9f6DQBareyO5nIdVHxFBERESkBjp9NY2LYTrYcTOR23+q8Mdgf7/KudseSG3VqP2yaATtDAQP+w6DT41C1qd3JRG6IiqeIiIhIMWaMYemO47zw9V4cxjB1cAuGBtXB0uWXxVNcJGycDlH/hTKuEHQ/dHgUKtazO5nITVHxFBERESmmzqRm8syy3Xy7+3eC6ldi+rBA6lUpZ3csuV7GwOHNsOFtOLAaXCtAp/HQ7hEoX9XudCL5QsVTREREpBhau+8kTyzexZnzmTzRqykPd2mEs5NGOYsVY+C3H3IL59GfoZw3dH8egkeDm5fd6UTylYqniIiISDFyPjOb176N5rOtR2hSvTxz7w/Gr5ZKSrGSkw1Ry2DjDIjfA1514a5p0PIecHG3O51IgVDxFBERESkmdhw5w4SwnRw6lcroTj5M7NkUNxdnu2NJXmVnQOTnsOnfcOYQeDeBAR+A/xBwdrE7nUiBUvEUERERKeKychzM+mk/s9bsp7qnK58/2JYOjbztjiV5lZECEXNhy3uQfAJqtYQen0HT3uDkZHc6kUKh4ikiIiJShB1ISGF8aCS7jiUxqGVtXujnh5e7RseKhfOn4ecP4ZcPIe0M+HSBAbOhYVfQU4ellFHxFBERESmCjDEs2HqY176Nxs3FmffubkXvFjXtjiV5cS4ud3QzfC5kpeaObHaeAHWC7E4mYhsVTxEREZEiJv5cOpMW72J9TAJdmlTlrSEtqF7Bze5Yci2JB3Lv39z5BThycu/d7Pg4VG9mdzIR26l4ioiIiBQh3+yK45mle8jIzuHlAc25p209LF2WWbT9vjv3CbV7l4KTC7QcAR3/Dyo1sDuZSJGh4ikiIiJSBCSlZfHC13tYFhlHQB0vpocE0qhqebtjydUc2QobpsNvK6GsJ3R4FNr9Ezyr251MpMhR8RQRERGx2eb/x959h8d1lvn/f58pkqZJozojyZKsaltyt9xLJFlWKkl+lECAhQQCLBsISYClLPtjr60suyQsfEPvC7ubsJTly1JsSXbcYse9yUXFlqw2qjPSaKRp53z/OGM5BpI4tuVRuV/XlSvgGWvuidq5z/M8n7tlgI//9AR9o0GerC3l8eoSzEZJO52WNA1aGmDPl6BjP1jTofpzsOYxsKTGuzohpi1pPIUQQggh4mQiHOWLvzvP9/ZdpCjDxs8/vIFlec54lyX+FDUKZ3+lr3D2noTkXLjrC7DyPZBgi3d1Qkx70ngKIYQQQsTB6S4fTz1/nOY+P+9ZX8Bn7l6EJcEY77LEH4qE4OTzsO/LMNgC6SXwwHOw5CEwJcS7OiFmDGk8hRBCCCFuo6iq8Y0XW/ly/QVSrQn84NHVVC3IindZ4g+FxuDoj2D/V2GkC9xL4W0/hEVvAoPcIBDijZLGUwghhBDiNmkfHOPpF05wpH2Ye5dk8/cPLibVJqtm08r4MLz8bTjwdRgfgoKNcP9XoHgrSLqwEDdMGk8hhBBCiCmmaRrPH7rM3/66CaNB4ctvX84Dy3NkTMp0MtoLLz0Hh78HIT+U3QWbnob8tfGuTIhZQRpPIYQQQogp1D8a5DM/P0n92T7WF6Xzrw8tI9dpiXdZ4oqhi7D/K3DsJ6CGoeLNsOkpcC+Od2VCzCrSeAohhBBCTJHfn+nlsz8/xWgwwufuXcT7NhZiMMgq57TgaYK9z8Lpn+lnNpe/EzY8AenF8a5MiFlJGk8hhBBCiFvMH4zwt//3DC8c7qQ8O5n/fMdyylyOeJclAC4fgr3PwPnfgNkG6z4M6z8CydnxrkyIVxVRIxz1HGU0NMrWgq3xLueGSOMphBBCCHELHbo0xNMvHKdreJy/qCrmydoyEkyGeJc1t2katO3UZ3Be2gNJTqj6DKz5IFjT4l2dEH9SKBriQM8B6tvr2Xl5J96gl6KUImk8hRBCCCHmsmAkyrM7mvnm7lbyUq288KH1VM6XpiauVBXO/Vpf4ew+Bo5sqPsHWPUIJNrjXZ0QfyQQDrCnaw8N7Q3s7trNWHgMu9nOlnlbqC2oZWPOxniXeMOk8RRCCCGEuEnne0d58vnjnO0Z4R2r8/jcfeXYE+UyK26iYTj1U/0M58AFSC2EN/0bLHsYTInxrk6Ia3gnvOzq3EVDewP7u/cTUkOkJaVx1/y72Jq/lbXZa0kwJqBpGlGvF1Kt8S75hshPRCGEEEKIG6SqGt/bd5Ev/u48jiQT335PJdvKXfEua+4Kj8PRf9dTan2XwbUY3vJdKH8QjHLZK6aPvkAfjR2N1HfUc7j3MFEtitvm5qEFD7E1fysrslZgNBhRg0EC+w4w2NiIf+cuzHnzmP/jH8e7/Bsi34FCCCGEEDegyzvOx184zoG2IWoXufjCW5aQYZfVtLiY8MGh78BLX4PAAOStg3u/BKV1ILNSxTRxeeQy9R31NHQ0cKL/BADzk+fz6OJHqc2vpTy9HEVRiAwNMfrLX+Hf2Yh/3360QADFasW+cSOO2pl5vhOk8RRCCCGEeEM0TeMXx7r4/P+cQdU0vviWpbytch6KNDi3n78PDnwNDn0XgiNQUgubPw4FG+JdmRBomkazt5mG9gbqO+q5MHwBgEVpi/joio9Sm19LkbMITdMItbUx+Ivv4G/cyfjx46BpmNxuUh64H0dNDdY1azAkzuwbW9J4CiGEEEJcp+GxEH/1y1P85lQvlQWpPPPQcvLTPPRuqQAAIABJREFUZ+Z5qxnN2wH7vwpHfwSRIJQ/AJufhuxl8a5MzHGqpnJq4BQNHQ00tDfQMdqBgsKKrBV8svKTbC3YSq49Fy0SIXDkKJ7GFxjduZNwRwcASeXlZDz+OI6aahIXLZpVN7Sk8RRCCCGEuA67zvfxyf8+iTcQ4i/vWsCHthRjNMyei8IZof+8Hhh06qeAAsveDhufhIzSeFcm5rCIGuGI5wj17fU0djTSN96HSTGxNnst7614LzX5NWRYMoiOjjK2ew9djV/Gv2cPqs+HYjZjXb+O9Pc9ir2qCrPbHe+3M2Vet/FUFCUJ2A0kxp7/35qmfV5RlELgv4A04CjwZ5qmhaayWCGEEEKI2y0QivCPvznLjw90UOay84NHV1ORkxLvsuaWriP6DM5z/wtmiz5/c/3jkDIv3pWJOSoYDXKg+wD1HfXsurwLb9BLkjGJjbkb2Zq/lS3ztpCSmEKosxP/T39Lx66djL18CCIRjKmpOGpqsNdUY9+wAYPNFu+3c1tcz4pnEKjRNM2vKIoZ2Ksoym+Bp4FnNU37L0VRvgG8H/j6FNYqhBBCCHFbHesY5ukXTnBxYIzHNhXyiTsXkGQ2xrusuUHT4NIe2PMlaNsFSSmw5ZOw9s/Blh7v6sQcNBYeY0/nHuo76tnTuYdAJIDD7GBL3hZq82vZkLMBizGJiVOnGP3692lr3Enwgn6uM6G4mPRHH8FeXY1l2TIU49z7OfK6jaemaRrgj/1fc+wfDagB3hn78x8Cf4M0nkIIIYSYBcJRla82tvDczhZcjkT+4wNr2VCcEe+y5gZVhQu/1Vc4uw6DLQu2/S2sehSSkuNdnZhjhieG2XV5Fw0dDbzU/dLkjM17iu6hNr+WNe41GEMRxl46gO87/0Tnzl1EBwbAaMS6ahVZn/4UjupqEgoK4v1W4u66zngqimIEjgAlwHNAK+DVNC0Se0onkPsqf/eDwAcB8vPzb7ZeIYQQQogp1drv56nnj3Oy08ebV+Ty+fsrSLGY413W7BeNwOmf6Wc4+8+CswDufQaWvwvMSfGuTswhnjEPjZcbaWhv4LBHn7GZbcvmoQUPUVtQy/LM5WiDQ4zu2kVv48cY278fLRjEYLdj37IZe3UN9s2bMDqd8X4r08p1NZ6apkWB5YqiOIFfAIv+1NNe5e9+C/gWQGVl5Z98jhBCCCFEvGmaxo9eaueffnuWJLOR5965knuXZse7rNkvPAHHfwz7vgLedsgqhzd/GyreDEbJwRS3R8dIhz5js72BkwMnAShKKeJ9i99HbUEtC1MXEmpuxv+LnXQ0fpGJk/pzzLm5OB96CEd1FdbKSpSEhHi+jWntDX03a5rmVRRlF7AOcCqKYoqtes4DuqegPiGEEEKIKecZmeATPz3BnuYBtpRl8i9vXYorWVbZptTECBz+nj6H0++B3Eq46wtQdhcYDPGuTsxymqZxYfgCDR36jM3m4WYAytPLeWLFE2zN30qhdR6Bw4cZ/fovaGtsJNyttztJy5aS+eTHsFfXkFhWOqtGnkyl60m1zQTCsabTAtQC/wzsBN6Knmz7XuB/prJQIYQQQoip8OuT3fzVL04TjET5uwcX8+61+XIhOZXGBuDgN+Dlb8GED4qq4S3fgfmbQf67iymkaion+0/qMzY7Grg8ehkFhZWulfzl6r9ka/5WXBEr/j17GP3+V7mwZy+q34+SlIRt/XrSP/zn2O+4A3NWVrzfyox0PSue2cAPY+c8DcALmqb9WlGUJuC/FEX5e+AY8N0prFMIIYQQ4pbyjYf5/P+c5pfHu1k2L4Vn376cokx7vMuavXydsP//wJEfQGQCFt0Hm56G3JXxrkzMYmE1fM2Mzf7xfkwGfcbm+xa/j6q8KpL7xhht3In/nz7NhaNHIRrFmJFB8t13Ya+uwbZ+HQaLJa7vQ9M0hnsCTATC5JTMzLOj15NqexJY8Sf+vA1YMxVFCSGEEEJMpX0tA3zipyfoGw3yZG0pj1eXYDbK9s4pMdAC+56FE88DGix5CDY9CZkL4l2ZmKWC0SAvdb9EfXs9uzp34Qv6SDImsSl3E1sLtrI5eyPmsxfx/6oR385H6G9tBSCxrIz0DzyGo6aGpMWLUeK45VuNqvRf9tPT4qW72UtPi4+JsTDpuXbe8dczswWTE9tCCCGEmDMmwlG++LvzfG/fRYoybPz8wxtYljczVw+mve7jsPcZaPoVmBKh8lHY8FFwypQDcev5Q372dO2hvr2ePV17GI+M4zA7qMqrYmvBVtY5lxM9cAT/t3biefEfiQ4Pg8mEbc1qUt/xDuzV1STM+5NDOm6LSCiK5+II3S1eelq89LSNEAlGAUjOSGL+knSyS50zdrUTpPEUQgghxBxxusvHU88fp7nPz3vWF/CZuxdhSZh7Q9ynlKZB+37Y8yVobYDEZNj0FKz7C7Bnxrs6MctcmbFZ31HPS90vEVbDpCelc1/RfdTm17KCPCZ272X0R89z+cBTaOEwhpQU7Fu24KipxrZpE0aHIy61BwNhelp9sRVNH33tI6hRDRRIz7GxaJ17stG0ORPjUuOtJo2nEEIIIWa1qKrxjRdbeXbHBdJsCfzwfWu4o0yaoFtK06B5u95wXj4I1gzY+nlY/X5ISol3dWIW6R3rpaGjgcaORg57DqNqKrn2XB5e+DBb82pYMJBAYOeL+P/lS1xqagLAnJ9P6rvehb2mGuvKlSim298CjfmCk1tmu1u8DHb5QQODQSGzwMGyrXnklDhxF6eQZJudc4Ol8RRCCCHErNU+OMbTL5zgSPsw9y7J5u8fXEyqTebs3TLRCDT9EvY+C57TkJIH9/wrrHg3mOMbxiJmj/aRdurb62noaODUwCkAilOKeWzJY9S6tjCv2Yv/N7vw7/wEHb29oChYVqwg6xMf17fQFhXd1qRqTdPw9Y/rq5ktPnqavfj6xwEwJRhwF6Ww5r5CskucuAqTMc+RnRfSeAohhBBi1tE0jf86dJm/+3UTRoPCl9++nAeW58iYlFslEoTj/wH7/g2GL0LGAnjwG7DkrWCcnas14vbRNI3zw+f1GZvt9bR4WwCoSK/gYys/RrVjFenH2vF/rxH/vh/QGQigWK3YN27E/sQT2KvuwJSWdvvqVTUGu/10N8e2zrZ4CfhCACTaTGQXO6nYkktOiZOMfDvGORpkJo2nEEIIIWaV/tEgn/7ZSRrO9bGhOJ1/fdsycpyy+nZLBP1w5Pvw0nMw2gM5K6Dux7DgXohjAqiY+a7M2Kxvr6e+o54ufxcGxcDKrJV8evWnuCNaguXgaUb/Yyfjx56hR9MwuVykPHA/jupqrGvXYki8PWchoxGVvvbRySazt9VHMBABwJ6aSG5ZKjmlTrJLUkhz21AMcsMLpPEUQgghxCzy+zO9fPbnpxgNRvjr+8p5dMN8DHLRd/MCQ3Dwm/DyN2F8GAq3wINfh6IqkFVkcYPCapjDvYcnz2xembG5LnsdHyh/HxsG0jDsO8Los//OaHsHo0BSeTkZjz+OvbqKpPLy27KLITQRwdN2NXHWc3GESFgFwOmyUrwiM9ZoOnGkJ8nOilchjacQQgghZrzRiTB/9+smXjjcSXl2Mv/5juWUueKTVjmrjHTrq5uHvw/hMX1lc/PTMK8y3pWJGWoiMsH+7v00dDSw6/IuRkIjWEwWNuVuYlv6RlZeUoj8/gD+3c/g9flQzGas69eR/sgj2KuqMGdnT3mN4/7QZAhQT7OX/st+NFVDUSAjz0H55hy90Sx2Yk2WM+PXSxpPIYQQQsxoL18c4ukXjtPtHecvqop5sraMBJNs+7wpg636+c0T/wlqVD+7ufFJcJXHuzIxA/lDfnZ37qa+o569XXv1GZsJDqrzqqlLWM7Cs36CP9rD2Mt/w1AkgjE1FUd1NfaaamwbNmK026a0vtGhiVjirB4GNNwzBoDRZCBrvoOVdfnklDpxF6WQYJH26UbJfzkhhBBCzEjBSJRndzTzzd2t5KVaeeFD66mcf/sCRWal3lN6Qu2ZX4DBDCv+DDY+Aanz412ZmGGGJob0GZvt9RzoOUBYDZNhyeBN8++jbqKIgpN9BP7zRYIXfs4QkFBURPoj78VeU4Nl2TIU49QkvWqaxnBvYPJ8Zk+zj9GhCQDMSUayi1MoW+Mip9RJVoEDk3luJM7eDtJ4CiGEEGLGOd87ypPPH+dszwjvWJ3H5+4rx54olzU3rOMA7HkGmn8PCQ7Y8FFY9zg4XPGuTMwgV2Zs1rfXc7Tv6OSMzXcXPkRtfyYZRy7i/+oOov0DDBuNWFeuJOtTn8JRXUXC/PlTUpMaVRno9E/O0Oxp9TI+GgbA4jCTU+JkWa0+QzN9nl3OhE8h+QkthBBCiBlDVTW+u/ci//L78yRbTHz7PZVsK5fm6IZoGrQ0wJ4vQcd+sKZD9edgzWNgSY13dWKGuOS7RH1HPQ3tDZwePA1AibOEx/PeyeZ2K/b6s4y99DzaxASjNhu2LZtx1NRg37wZo9N5y+uJhKJ4Lo1MbpvtbfURDkYBSM5IIr8inZxSJzklTlKyLBIEdBtJ4ymEEEKIGaFzOMAnfnqCA21D1C5y8YW3LCHDfnvGJ8wqahTO/kpf4ew9Ccm5cNcXYOV7IGFqz9KJmU/TNM4NnaO+o57GjsbJGZtL0hfz2fR3UdmiYfrNcSZO/ACAYE4Ozre+FUdNNdbKSpSEWxvGExyP0NMSW81s8eJpH0GNaACk5dhYsNY9mThrT5WfF/EkjacQQgghpjVN0/j50S7+5ldnUDWNL75lKW+rnCcrFW9UJAQnn4d9X4bBFkgvgQeegyUPgUmSOcWrUzWVE/0nqG+vp6GjYXLG5ur0FTya+BCLz02g/ugg4a4fEgFMS5eS+eTHsFfXkFhWeku/V8d8wauJsy1eBjr9oIHBoJBZ4GBpdV4scTaFJJv5lr2uuHnSeAohhBBi2hoaC/FXvzjFb0/3snp+Kl9623Ly063xLmtmCY3B0R/B/q/CSBe4l8LbfgiL3gQGCU4Rf1pYDXOo55A+Y/NyIwPjA5gNZqpSKvlEaA1Fp4cI7zuI6j9IKDER24YNpP/5h7DfcQfmrKxbUoOmaYwMvDJx1ouvbxwAk9mAqyiF1ffMJ6fUiaswBXOifD1PZ9J4CiGEEGJa2nm+j7/875N4AyE+dddCPrilCKMEf1y/8WF4+dtw4OswPgQFG+H+r0DxVpDVYvEnjEfG9Rmb7Q3s6tzFaGgUi8nCveaV1A6uJftYJ8Gj+yEaJZKRQfLdd2Gvrsa2fj0Gi+WmX19TNYZ6xuhu9k7O0BzzhQBItJrILnFSvkmfoZmZ78BolLFJM4k0nkIIIYSYVgKhCP/wv2f5ycEOylx2fvDoaipyUuJd1swx2gsvPQeHvwchP5TdBZuehvy18a5MTEOjoVF2d+6moaNhcsZmisnB28JL2XQxkdRDzYTbXtSfXFZG+mOP4aipJmnJEhTDzTV+0YhKf8fo5IpmT6uPYCACgM2ZOHk2M6fUSVq2DUVuPM1o0ngKIYQQYto41jHM0y+c4NLgGI9tKuQTdy4gSeboXZ+hi7D/K3DsJ6CGoeLNsOkpcC+Od2VimhkcH2Tn5Z3Ud9RzsOcgETXCPEM6fz6yglXNKkkHz6AOvwgmEwlrVpP2joex11STMG/eTb1uOBil96JvstH0tI0QCasAOF1WilZkkhNrNB3pSXKOe5aRxlMIIYQQcReOqny1sYXndrbgciTyk8fWsqE4I95lzQyeJtj7LJz+mX5mc/k7YcMTkF4c78rENNLj79FnbHbUc6zvGKqmUhF189n+VSxqGsN0rAkttBtDcjL2LVtw1FRj27wZo8Nxw685MRbWz2Y266NNBjpGUVUNRYH0eXbKN+VMrmhakyXgaraTxlMIIYQQcdXS5+fpF45zstPHm1fk8vn7K0ixSBrl67p8CPY+A+d/A2YbrPswrP8IJGfHuzIxTbT52mjsaKS+vZ4zg2dA09gyns8/di2n6NQAnG8DOjHn5+N4+GHsNTVYV65AMd/Y959/eILuFi/dzfpok6HuMQAMJgXX/GSW1+WTU+LEXZxCokXakLlGPuNCCCGEuO1a+/1sP+NhR1Mvxy57SbGY+dq7VnLPEmmaXpOmQdtOfQbnpT1gSYWqz8CaD4I1Ld7ViTjTNI2zQ2cnx560+dowRTTu887nQx2LyT7WidZ3EZRLWJYvx/7xp3HU1JBQVPSGt7VqmobXE9BHm8TCgEYHJwAwJxnJLkqhtNJFTmkKWfOTMcmW+TlPGk8hhBBCTDlV1TjR6WV7k4ftZ3pp7ddXQpbkpvBUbRnvWJ1HVnJSnKucxlQVzv1aX+HsPgaObKj7B1j1CCTa412diKOoGtVnbHbU09DeQPdYNynjCm/uL+DTrSU4T7ZDoBXFYsG+aSP26hrsd2zBlJ7+hl5HVTUGO/1XE2dbvIyPhgGwOMxklzhZVqPP0EzPtWGQxFnxB6TxFEIIIcSUCEVUXmobZPuZXnY0eegbDWI0KKwrSuM96+dTW+4i13nzIxhmtWgYTv1UP8M5cAFSC+FN/wbLHgZTYryrE3ESjoZ5ufdl6jvqaexoZGh8kPxhEw958lh+IRfrucugtmDKysJ+//04amqwrl2LIfH6v2Yi4Sh9l16RONvmIzwRBcCRnkR+eTrZJSnklDpxuqwSBCRelzSeQgghhLhlRibC7Drfz44mD7vO9TEajGBNMHJHWSZ1FS6qF2ThtEqIyOsKj8PRf9dTan2XwbUY3vJdKH8QjHL5NheNR8bZ37Wf+o56Xrz8ImPBEZb2JPB4t5uFZzXMXf1AC4nli3B8+MPYa6pJKi+/7oYwNB6hp+0VibOXRlAjGgBpOTbK1rjJKUkhu8SJI012J4g3Tn5yCSGEEOKmeEYm2NHkYXuTh5daBwhHNdJtCdy7NJu6ChcbijNkJMr1mvDBoe/AS1+DwADkrYN7n4HSbSArSnPOSGiEFy+/SGNHI3u79qIExtnQYeFznWkUnAliGA2gmDuxrluH47EPY6+qwpx9feekAyOhVyTOehns9KNpoBgUMvMdLK2apyfOljhJskvYl7h50ngKIYQQ4g1r6fOzvamX7Wc8HL/sBaAg3cqjGwupK3exIj8Vowx7v37+PjjwNTj0XQiOQEktbP44FGyId2XiNhsYH2Dn5Z00tDdwsOcgTm+YqnY7/3LJQdb5cZSIH6PThH1rHfbqamwbN2K0217zY2qaxujglcRZLz0tPryeAAAmswFXUTKr7plPTokTV2EyCUnSIohbT76qhBBCCPG6VFXjeKeX7Wc8bG/qpS0WDrR0XgqfqCujrsJNaZZdznm9Ud4O2P9VOPojiASh/AHY/DRkL4t3ZeI26vZ36zM22+s57jlKYY9GTYeDR1utJHcMAT4SitJxPPII9upqLMuXoxhffReBpmoM9YxdM0NzzBsEINFqIrs4hUUbsskpdZKZ78BokiAgMfWk8RRCCCHEnxSMRNnfOsj2Mx7qz3roHw1iMiisL07nkQ3zqV3kIkfCgW5M/3k9MOjUTwEFlr0DNj4JGSXxrkzcJm3eNj2JtqOB5t4zLLmksbUjmacuJJDoDYBhBOuqVdjf8Rj26ioSCwtf9WNFoyr9HaP0NPv0xNlWL8GxCAC2lASyS/Uts9klTtJzbCiyG0HEgTSeQgghhJg0MhFm57k+tsfCgcZCUWwJRqoWZFFX4aJqQRYpFjnvdcO6jugzOM/9L5gt+vzN9Y9Dyrx4VyammKZpNA010dDeQH1HPUPdbaxs0Xi43UFJs4IxFMVgC2PbvAVHTTW2zZsxpab+yY8VDkXxtPnojs3Q9Fz0EQmpAKRkWShalqmfzyxNITnDIjsRxLQgjacQQggxx/X6JthxVp+veaBtkHBUI8OewP3Lc6grd7O+OF3CgW6GpsGlPbDnS9C2C5JSYMsnYe2fg+2NzVIUM0tUjXKs7xgNHQ00tNdjau9hdTN87JKF7I4oigbmHBv2t92HvaYa2+rVKAl/nPo8MRamp9VHTywIqL99FFXVQIGMeXYWbcyJrWimYEuRMTtiepLGUwghhJhjNE2LhQPpzeaJTh8AhRk23rexkLoKF8vzJBzopqkqXPitvsLZdRhsWbDtb2HVo5CUHO/qxBQJR8Mc7D1IfXs9L15qxN08yNoWA3/XZiJ5UJ+DmbSkEMcT1dhrakgsK/ujFUn/cFA/nxk7oznUrZ+pNhgVXPOTWb4tn+ySFLKLU0i0yg4EMTNI4ymEEELMAVFV4/jl4Vg4kIeLA/qF7LI8J5+8cwF3VrgozpRwoFsiGoHTP9PPcPafBWeBPhJl+bvALPMPZ6NAOMD+bn3G5uELuyg5P8q6FgMPXoTEcRUl0Yxt/TrsNdX6yJOsrMm/q2kaXk9AP5sZW9EcGZgAwJxoxF2cQmllFtklTlzzkzElyO6DuUpTVcb9o1iTU+Jdyg2RxlMIIYSYpSbCUfa3DrCjycOOpj4G/FfDgd63qZBti1y4U6QRumXCE3D8x7DvK+Bth6xyePO3oeLNYJRLrtnGF/Sxu3M39e31tJzey5LzE6xtNfJnHREMqoYx3Yn93mocNTXY1q/HYNGDuFRVo79jVG80W/TE2fGREABJdjM5JU6WVM0jp9RJxjw7BqMkzs5F+gicfnpbm+ltuUBvazOethYy8ufz8N9+Md7l3RD5KSiEEELMIr5AmJ3n+9je1Muu8/0EQlHsiSaqFmSyrVzCgabExAgc/p4+h9PvgdxKuOsLUHYXGKRpmE0Gxgdo7Gik8VI9Q0cOsrw5zAMtRrL79QTZhNIiHB/YiqO6iqSlS1EMBqJhld72EXpaPHQ3++ht9RKa0LfcOtKSyFuUOpk4m+q2yq6DOSow4sPT2qw3mq16oxnw6TOSDUYTmQWFLNpURe7C8jhXeuOk8RRCCCFmuB7fODuaPGw/4+FA2yARVSPTkciDK3KpK3exvjidRJNsz7vlxgbg4Dfg5W/BhA+KquEt34H5m0Gah1mjy99FQ3sDu5u3o718nFUtKu9vVbCPqWhGI7bVlTg+UIO9ppqEefMITUTobfXR/X8v0tPiw3NxhGhET5xNzbZRutoVS5x14kiTHQdzUWhiHE9bS6zJ1Fc0R/o9+oOKQnpuHoXLV+EqLsVdXEpmQREm88y/YSiNpxBCCDHDaJrGBY+fHU29bG/ycDIWDlSUaeOxzUV6ONA8JwYJB5oavk7Y/3/gyA8gMgGL7oNNT0PuynhXJm4BTdNo87VR317Py6d+R8qhC6xq0XiiHcwRDRw2kqur9C20mzYRJImeVi9N+310txxi4PIomgaKQSEzz87iqtzJxFmL/Y8Ta8XsFo2E6W+/NLldtrf1AkNdnWiafjMiOTMLd1Epy+vuwV1cSlZhCYlWa5yrnhqKpmm37cUqKyu1w4cP37bXE0IIIWaLqKpxtGOY7Wf0ZrN9MADAinwndeVutpW7KMmyx7nKWW6gBfY9CyeeBzRY8hBsehIyF8S7MnGTNE2jabCJ+vYdNB34DdnHu6hsVinu1R9XcrNJra3DVlVFtLCC3kv+yRmaXo/+vWg0G3AXJuurmSVOXEXJJCTJGs9coqpRhru76G1tpqflAp7WC/S3XyQa0bdiW5JTcMdWMd0lZbiLSrGmOONc9a2nKMoRTdMq//DP5btBCCGEmKYmwlH2tQyw/YyH+rMeBsdCmI0KG4oz+OCWImoXuXAly1a9Kdd9HPY+A02/AlMiVL4PNnwEnPnxrkzchKga5WjfUXa2bufy7t9RfGqQVS0adSOgKWBeuhjnw3VEl22kP5jMiRYfPb/y4h8+BECCxUR2SQqLNmSTXeIkK9+B0SxneucKTdMY6e97xZnMC3jaWglPjANgTrLgLiphxd334y4uI7ukDEdG5pw+w/u6jaeiKHnAjwA3oALf0jTt3xRFSQOeB+YDl4CHNE0bnrpShRBCiNnPFwjTeF4/r/nihavhQNULs6grd1G1IBNH0sw/6zPtaRq074c9X4LWBkhMhk1Pwbq/AHtmvKsTNygUDXGw5yB7zvwG764GFjX5qb2oYQmBmmgmaf1GtDV34Usv41J3mO4LXoLHeoFerMkJ5JQ6Y+czU0jLsct29jkk4PNeE/zT29rM+Ih+zMFo0sN/Ku6owV1chru4lNScXAwGOVv/Sq+71VZRlGwgW9O0o4qiOIAjwIPAI8CQpmlfUBTl00Cqpmmfeq2PJVtthRBCiD/W5R1nx5ledpz1cKBtiKiqkeVIZFu5i7oKN+uK0iQc6HbRNGjerjeclw+CLVNvNle/H5Jm5uy8uS4QDrC3ay8vv/xLortfYsm5CRZ0gUGDYEYG2sYHCOSvYiCYTG+7n0hQT5xNzrSQU+okpySF7BInKZmWOb1aNZeExgN42lpi22Wb6W1rZqS/T38wFv7jLi7Tt8sWl5KRP39WhP/cKje81VbTtB6gJ/a/RxVFOQvkAg8AVbGn/RDYBbxm4ymEEEIIfYvWec8o28942N7Uy+muEQBKsux8aEsRdRVuluamyGrK7RSNQNMvYe+z4DkNKXlwz7/CineD2RLv6sQb5Av6eLG9kTM7f07CS8dZfj7CW4YhbLIwuKCK7rV34DXnMtAfQfVpcFojPSfKovXZZJekkFPqxJaSGO+3IW6DSDhMf3vbNfMyh7o79ZtQQEqWC3fJApbfeR/ZxWVkFRWTkHT7fyZE/SHCvWMQ1UhakHbbX/9WeENnPBVFmQ+sAA4CrlhTiqZpPYqiZL3K3/kg8EGA/Hw5CyGEEGJuiqoaR9qvhgN1DAVQFFiR5+TTdy9kW7mL4kwJB7rtIkE4/h+w799g+CJkLIAHvwFL3gpGWcGYSfoD/bx4/rdc3P4LUg5dYHmLSr6awlDacnzlq+lJWYAvoH9ODV6FrAIry2v11czs4hQSrfL5nu1UNcpQ5+WrY0xaL9Dffgk1qof/WFOcuItLWbhhC+7iUlzFpVhsSVmoAAAgAElEQVSTb+9OBzUYIewJEO4dI9IbIOwZI9wbQB0LA2B222Zs43ndqbaKotiBF4F/0DTt54qieDVNc77i8WFN01Jf62PIVlshhBBzyUQ4yp7mAbaf6aXhXB9DYyESjAY2lKRTV+6mdlEWWRIOFB9BPxz5Prz0HIz2QM5K2Pw0LLgXDBIQM1NcHr3M3sO/wLP9f3Edu0xxXwajySUMZZQxklnOhKbfzDElGskuupo4m1WYjDlBtq/PZpqm4evzTJ7J9LQ242lrIRycACDBYok1l2WTSbOO9NsX/qNFVML940Q8Y4R79eYy3DtG1BucfI5iNmBy2zC7rJhdNsxuK2a3DaNjeo/lualUW0VRzMDPgJ9omvbz2B97FEXJjq12ZgN9t65cIYQQYmYaHgvReK6P7U297L4wwHg4iiPJRM3CLOrK3dyxIBN7ooTKx01gCA5+E17+JowPQ+EWePDrUFQFcn5v2tM0jZahZl7e9R/4GnaS05xAulqMKWUbw/NKOTTfAUCSzRQLAdLDgDLz7BiMckNhNhvzDv9R+M/EqH6MwWg2k1VQxOLqbZMrmWnZuSi34SaTpmpEhyYmVy6v/DsyMA5qbAHQoGDKtJBQkIx5jd5cml1WjKlJKLPoyMX1pNoqwHeBs5qmPfOKh34FvBf4Quzf/zMlFQohhBDTXOdwgB1NehLty5f0cCB3chJvXTWPugoXawvTSTDJRW9cjXTrq5uHvw/hMX1lc/PTMO+PbsqLaUbTNE53HeX4//6E4EudpA24MVpKMKR8kq5iKwA2h5HCRRmTK5qpbuusumAX1woGxvC0tVxzLnN0sB8ARTGQnpdPSeXa2EpmGRn5BRhNU7uVWtM01NGwvnr5iiYz4gmghdXJ5xnTkjC7rFgq0vWVTLcNU4YFZQ78jrieVNtNwB7gFPo4FYDPop/zfAHIBzqAt2maNvRaH0u22gohhJgNNE3jbM8o25t62X7GQ1OPfle9zGXXk2jL3SyRcKDpYbBVP7954j9BjepnNzc+Ca7yeFcmXkNEjXDk5C7O/s9O1GYVc7QAv30+qlHfYmi3hslb7Ca3wkV2SQrJ6RIANVtFQiH6LrXFtsteoKe1meHuzsnHna5sXLGtsu7iUlyFJZiTpvYIgzoe+YMVTL3BVAORyecY7ObJlUuz24Yptl3WkDj7t3jfTKrtXuDVfnNuvdnChBBCiJkgElU53D48mUTbOTyOosCq/FQ+e89CtpW7KcywxbtMcUXvKT2h9swvwGCGFX8GG5+A1Pnxrky8Cu+wn32/3U7vy+2o3lRCibmgbAWbimIcprjERNHmheQuzMAyzc+4iRujRqMMdnZcs2V2oOMSalQfcWNzpuIuKaN8U9XkllmLI3nK6tHCUcJ947FVzMDkecyoLzT5HCXRqK9gLs7A7LJOnsk02uVr9A/JIRMhhBDiVYyHouxp7md7k4eGsx6GA2ESTAY2lWTwkeoSti5ykemQkQvTSscB2PMMNP8eEhyw4aOw7nFwuOJdmfgDI4PjXDrTw+ndRxnp1IiSDjgxqDYsXCbN2Ub5HSspql5OokUSZ2cbTdPweXpjDWYsAOhiK5GgHq6TaLXhKiqh8r7/LzYvswx7WvqUhP9oqkZkcHwy4CfiiTWaA+NwZXOoUcGcZSWxMEVvLq80mM5Eme96naTxFEIIIV5haCxEw1kP25s87GnuZyKsknwlHKjCzZYyCQeadjQNWhpgz5egYz9Y06H6c7DmMbC8ZuC+uE00TWO4J0B3i5f20910nusnEtK3QxojFpJHWjEmnSBjaRZr3v4gjrw741yxuNX8w0NXt8u2XMDT1sKEfxQAkzmBzMIiltTU4S7Wm8xUd/YtD//RNI2oL6SfvYw1mWHPGOG+AERiHaYCprQkTG4bliUZeoPptmFKT0KRgKqbIr85hRBCzHmXhwJsb/Kw/Uwvhy4NoWqQnZLE2yvzqKtws6YwDbNccEw/ahTO/kpf4ew9Ccm5cNc/w8o/gwTZ9hxPalSl/7KfnhYv3c1eui4MEhrXL+zNoRHSvC0kjrei5YWYd+dqlt79KGa7I85Vi1tlYsyPp7XlFQmzF/APDQKgGAxk5BVQumY97uIyXMWlZOQVYDTd2rZEDYQnt8hOjivxjKFNRCefY0hOwOy2YS92To4rMWVZMcionSkhjacQQog5R9M0mnpGYuc1PZyNhQMtcDl4vLqEunI3i3OTZfvUdBUJwcnnYd+XYbAF0kvggedgyUNgknNV8RAJRfFcHKG7xUtPi5eeVh+RkJ5JmRAaIG2wGaevlbCpncgKF4XveRuLNj+FwSgX+DNdOBSk72IbnleMMRnu6Zp83OnOZt6ixbGVzFKyCoswJ9668B81FCXSd21zGe4NoI6+4hxmkhGz24Z1edY1MzENVtnCfTtJ4ymEEGJOiERVXr40NDn2pMurhwNVFqTyV/csYlu5i/kSDjS9hcbg6I9g/1dhpAvcS+FtP4RFbwKDNDC3UzAQpqfVF1vR9NHXPoIa1QCNRAZJ62sis78Z+2grnnkR1I2VFNz/forLN8gNnRlMjUYZuNx+zazMgY5LaKp+k8GemoaruIyKO7bqSbNFpSTZ7bfktbWoSmRg/I9WMKNDE1fPYZoMmF1Wkkqdk2cwTW4bxuQE+bqbBqTxFEIIMWsFQhF2Xxhge1Mvjef68MbCgbaUZvCxraXULMoiwy7hQNPe+DC8/G048HUYH4KCjXD/V6B4K8jF5G0x5gvS3eylp8VHd4uXwS4/aKAYwG4ZI23sFFmtx0kfbiFkHOdSRRr+d2+m5P7/n8rsBfEuX9wATdPw9nZfMyuz71IbkVAs/Mdmw11cxpoH3jo5zsSRlnFLXjc6HLx2FmZvgHB/AKKvOIeZYSEhx455RdbkuBJTukXmt05j0ngKIYSYVQb9QRrO9bH9jB4OFIyopFjMbF2YRV2Fi82lmdgkHGhmGO2Fl56Dw9+DkB/K7oJNT0P+2nhXNqtpmoavf1xfzWzx0dPsxdc/DoApwUBmlpG8lFYSz+0m98IJjGoYj1Oha3kOga1vZ82d76Uy2R3ndyHeqNGhgVj4T3Ms/KeZ4NgYAKaERLIKi1lae9fkvEynO+emVxGj/tC1zWUsTVYLXj2HaUxJxOy2krgg9epczEwrilnO3c808ptXCCHEjNcxGGB7Uy/bmzwcjoUD5aQk8fCafOrKXayWcKCZZegi7P8KHPsJqGGoeDNsegrci+Nd2aykqRqD3X66m2NbZ1u8BGJzChNtJrILkynKHSd8oR7Lge04hsZQgdZ5Bg7fX4z7zvtZt/6tVCU54/tGxHUb94/iiW2VvZI06x8eAmLhP/nzWbBu8+RKZkZewU2dx1WDEX08yeQZTL3BVP3hyecYrCZMLhvWlVmTSbJmlxVDkrQrs4V8JoUQQsw4mqZxpnuE7Wf0ZvNcrx7Jv9Dt4CM1pdSVu6jIkXCgGcfTBHufhdM/089sLn8nbHgC0ovjXdmsEo2o9LWPTjaZva0+goEIAPbURHLLUnHnJpDkOYFvz3+T+O3TmINRJszQVGRm/P7lFN39ELXld2I1W+P8bsTrCQcn6LvYdk3CrLe3Z/Lx1Oxc8iqW6iuZJWVkzi/CnHBjRxC0SOwc5jVBP2NEh4OTz1HMBkwuK0kL0yZDfsxuGwa7WX5mz3LSeAohhJgRwlGVQxeHJseedPsmMChQOT+Nz927iLpyN/npchE844QnoPMQHPganP8NmG2w7sOw/iOQnB3v6maF0EQET9vVxFnPxREiYT0MxumyUrwyi5ySFNITRxk/uIO+3/waY9MlohqE7HB0SRLKpo2U172dhwo2YzZKEuh0FY1EGLjcfnW7bOsFBjo7rob/pGfgLiplcdW22CiTEpJsbzz8R1M1osMTenN5ZRamJ0CkfxzU2DlMg4Ip00JCngPzavdkk2lMTZJzmHOUNJ5CCCGmrbFghN0X+tnR5KHhXB++8TCJJgObSzN5clsZWxdmkS7hQDOHqurjT7oOQ9cR6DwMntOgRsCSClWfgTUfBGtavCud0cb9ockQoJ5mL/2X/WiqhqJARp6Dis25ZJem4J5vR2ltwvP7/8L7vXrUbn3OoscF5+9IxlK1hdV3PMRjrpUYJTV42tFUleEr4T+tF+htuUD/pYtEwvo26SSbHXdJGcWVa3HFRpnYU9/Y95amaaij4atBP7EmM+IJoMVuXgAY05Iwu6xYFqVPrmCaMiwoJjniIK6SxlMIIcS0MuAP0nBWH3myp2WAUETFaTVTu8gVCwfKwJogv75mhFHPtU1m9zEI6jNTSXBA7grY8FHIXQVF1ZB4a8YuzDWjQxOxxFk9DGi4Rw+EMZoMZM13sPLOfHJKnLiLUjBGJxjbuw/Pj/4vrXv2YfZPEDHAuQKFSw9kkr71TjauepC708pl2+M0omkao4MDsXOZ+pZZT1sLwUAs/CcxEVdhMcvq7omF/5SR4nK/oc+hOhGZPHt5ZatsxDOGGtuGDWCwmzG7bdjW6CuYJrdVP4cpgW3iOshXiRBCiLi7NDCmz9ds6uVw+zCaBrlOC+9am09duZvV81MxSTjQ9Bb0Q8+JVzSaR2CkU39MMYKrApa8VW8ycysho1Rmb94ATdPwegJ0N3tjK5o+RocmADAnGckuTmHBWhfZJU6yChyYzEbC3d2MNv6O1n/+NeqRkxiiKqNJcLREwbMin7ytb6Jq4T087CyK87sTV4yPjujbZa80ma3NjHmHATAYjXr4z4bNuEvKcBeXkZ6bd93hP1pYJdwfmGwyI7EmM+p7xTnMRKO+grk4A5PLOhn0Y7QnTMn7FXODNJ5CCCFuO03TON01oifRnvFw3qOHAy3KTuaJmlLqKlyUZ0s40LQVjUD/Ob3B7DoMXUehrwm02NY7Z4E+8iT3L/QmM3spmC3xrXmGUqMqA53+yRmaPa1exkf1JFCLw0xOiZNltXnklDhJn2fHYFDQVJWJM00Mfa2B/h2/xdDSDkBXGhypNDCyehEL73iA+wu3kWPPiefbE0B4YgLPxZar8zLbmvF5eicfT8uZR8GS5biKy8guKSOzoBBTwus3gJqqERkcJ+IJXLOSGRkYh9gxTIwK5kwriYXJmK6MKnHbMDoT5eevuOWk8RRCCHFbhKMqB9uG2N7Uy44mDz2xcKA1hWn89X3l1JW7yEuTcKBpR9PA13ltk9l9HML6Fj+SnPoq5sJ7Y6uZq8B280Pk56pIOErfpZHYiqaP3lYf4dhMw+SMJPIr0skpdZJT4iQlyzLZHKgTE4ztfpGRhga8jfUYBr2oCpybB8e2mohsWMGq1W/i/XnVZFjk8xMv0UiYgY72qwmzLRcY7LyMFrtp40jPxF1SytKt+rxMV1EJiVbba35MTdOIjoQmVy6vBP2EPQGIxG4GKWBKS8LksmFZkjG5gmnKsKDIbhJxm0jjKYQQYsr4Y+FA28/00niuj5GJCElmA1tKM/l43QJqFmaRZpOtW9PKhE9vLruOXP3H79EfMyaAeymseDfMq9SbzLQikJWRGxYcj9Db6ps8o+lpH0GN6MtRaTk2Fqx1k1PqJLvEiT312iCtyMAA/hdfxNdQz9j+/SgTISYS4FiRwomNiVg2b2RTxd385bwtJCckx+PtzWmaqjLU3XX1TGZrM33tbUTD+op1kiMZd3EpJWs2xM5llmJzpr7mx1QD4WvGlOirmAG0iVecw0xOwOyyYl+XHZuHacWUZcWQIFvbRXxJ4ymEEOKW6h+NhQM1edgbCwdKtZqpq3BTV+5ic2kmFrkAmh4iIT1VtutIrNk8DAMXrj6eXqqH/syrhNyV4FoCJrlRcDPGfMGribMtXgY7/WgaGAwKmQUOllbn6Y1mcQpJtmvHlmiaRqilhdHGnfgaGwiePIWiaQwmKxwqh6ZFdrI2VlNTfCcP527AYpLtzbeLHv7Tf3W7bCz8JzQeAMCcmISrqITld95HdomeMJuc6XrV7axqKEqkL/BHTaY6Epp8jpJkxOy2YV12ZQXThsllxWiTcTdiepLGUwghxE27ODDG9jO9bG/ycLRDDweal2rh3WsLqKtwUVkg4UBxp2kwfFEP/bmybbbnJERjgSK2TP085pKHYN4qyFmhjzgRN0zTNEYGXpk468XXNw6AyWzAVZRC5T3zySl14ipMwZz4xzdktHCYwJEjjDY2MtLYQLSzG4DWbIXDmxSaK5wsWHMntQXb+Ih7tczYvE0CI75YwuzVlNmAzwuAwWgis6CQRZuqJlcy0+blYfgTYVpaVD+HqafIXg37iQxNXD2HaVIwZ1lJKnFOzsI0uW0YkxPkHKaYUaTxFEII8YapqsapLt9kOFBznx+AipxkntxaRl2Fi4Vuh1wUxdPYIHQf1ceYXNkyOz6kP2ay6I3lmg/o22XnVUJKnmyZvUmaqjHUM/aKxFkvYz59hSrRaiK7xEn5phxySp1k5jswvsrNmOjICP7de/Dv3Mnoi7vQ/GNETAon58Ohuwx0LXWzesmd3J9fy7LMZTJjc4qFJsbxtMXCf2IrmiP9se3nikJazjwKl6/CFWsyMwuKMJn/eLU6MjxxNeDnynnM/gBEYx2mAqYMC+YcO9YVWZiuNJnpFhSDfG+KmU8aTyGEENclFFE50DbIjiYPO5o89I5MYDQorJmfxjvX5rOt3MW8VAkHiovwOPSeujovs+uIvroJgAJZi66G/8yrhMxFYJRLgJsVjaj0d4xOrmj2tPoIxmYe2pyJeghQ7HxmWrbtNZuH0OXLeqPZuJPAoUMQjTJmN3GwKMrhUgP+ZcVsKd3Gh/JrWZi2UG7qTJFoJEx/+6XJ7bK9rRcY7Lqs7xgAkjOzcBeVsjw2LzOrsIRE67U/96L+EBMdXr25fEWirBYLiQIwpiRidltJXJCqJ8m6bJizrChm2RkiZi/5rSOEEOJVjU6EefFCP9vPeNh5ro/RYASL2cgdZZlsK3dRszCLVAkHur1UFQabr20yPadBjYWLJOfq5zFXPaI3mjnLIdER15Jni3AwSu/FVwQBtY0QCeupoU6XlaIVmZOJs470pNdsDjVVZfzECfw7dzHa2EiopQUAjyuB/WtUDpcYSVxSztbCbfx1fg1FKTJj81ZT1SjD3V30XDmT2XqB/vaLRCP695IlOQV3cSll6zbq8zKLSrGmOK/+/WCUsGeMMU/vNeNKVH948jkGqwmTy4Z1ZdZkkqzZbcOQJJfgYu6Rr3ohhBDX6BudoL6pj+1NvexvGSQUVUmzJXD3Ejd15W42lWaQZJatfbfNqCc2xiTWaHYfg+CI/liCA3JXwIaP6uczc1dBcnZ8651FJsbC+tnM2GiTgY5RVFVDUSB9nn1y22x2iRNr8uvfgFEDAcZeeonRxkb8u14kOjiIalBomZ/I/q0GjpUZyVmwgtr8Wh7N30q2XT6Xt4qmaYz0973iTOYFPG2thCf0M7fmJAvuohJW3H0/7ti8TEdGJoqioEVUIgPjhC+O4fNcmmwyo0MTkx9fMRswuawkLUjD7LZOhv0YHGZZnRYiRtE07fWfdYtUVlZqhw8fvm2vJ4QQ4vq09vvZ0eRh+5lejl32ommQn2alrtxFXYWbVQWpGOWM0dQL+qHn+NUzmZ1HYKRTf8xgAldFbFZmrMnMKAODbM27VfzDE3S3eOlu9tHT4mWoW59VajApuOYnk12ib511F6WQaLm+e/dhTx/+XbvwNzYyduAAWjBIyGLmZImRfYUhTpeYWVK0ntr8Wqryqki3pE/lW5wzAj7vNcE/va3NjI/4ADCa9PAfd0kZ7mI9YTY1JxcFA9HhiWtnYfaOEekfBzV2vWwAU4ZVby5dtslxJcbUpP/H3psFx3WmaXrPWXNfkUAmkCC4UyIpUQtZVVJVSVUlSmx3T3d1R8y4uyfC0zPtnmlP2BPjaNsTbl84fOmJ8JXD9s2EY8IxN17HY7fHHW2qWqyta5VUkkokJe4UACIzseR+MvNsvy/OQS4AtJEgCZL/U5GVmTgHwAEpAnjz/b73lXuYEkmIoijvCCHObH27dDwlEonkCcT3Be8vNTgfis3rq8Ev2M+WM/wnrx/j3MkSx4pJ+Ur9/cRzYfWjMTfzHVi9DGGRPNn9sPA1KP+HgdCcPQWGrMfYLYQQNKpWUG0ShgG11wMHy4hqzB7KcPRMkbmjWWYOpNC/oMsvhGDw8ceBq/nWBfoffghAuxDnZ8/DTw6p3D4Y4eWFV/idhbP8N/OvkjLlKPS9MLCsMPznSpA0e+MqrdVacFBRmCrv49ALXwmF5lGm9u1HHRAmyVo4P+uyWv01brWLsP3hx9VyEYxigtjxqaGLqRdiKLp8sUciuRuk4ymRSCRPCLbr89Mb65y/WOHNS1Vq7QGaqvDSoTznTpR4/USRclYKm/uCENBcGtWYLL8bjMw6QccfsVzoZI7dEoWHe82PGb4vWF/qjBJnrzXotYNdvFjKCNzM0NGcKidQv0T9j2/bWL/4JZ233qJ94QLuygpCUagdyPDDAxY/PezRnEvxnYXXOLtwlpfnXpYdm3eJ6zis3r4xFv5zlY07S8Pwn8xMkWLoYs4ePkZhbj9KUwzrStzNPcwwBApATRrD3UujmEAvxTGKcdSI9GckkrtBOp4SiUTyBNLuO3z/41XOX6ry/TAcKG4G4UDnThb5zlMzZOMyHGjX6TUCYbkpMpffgU5Yv6CZUDoFL/7RSGTmD8kqk13GdTxqt9rDWpOVG02cfpAqmpqKsnBiitkjGeaOZskW41/a3Xfrdbo//CHtty7Q/fGP8btdfNPg1tMZvveiwS8P++hTEc4u/Bb/5f6zfKX0FQxVdmx+GXzfY2NpcWJkdvX2LXwvEI3xTJbS4aM8/fVXKR04wlRmH1pHDatKujgXLdYa7w0/nmJqGKU4sZOFUFyGY7JJ+T1QInkQSOEpkUgkjxnVVn9YefKT62s4nmAqYfK3Ts3yxoki3zgiw4F2FdcOUmU39zKX34G1K6PjU0fh0HeCGpPyi1B8FnT5i+5uY/dcVm40WQkdzeqtFr4buGD5uQTHvlpi7kiG2SNZUvnoXX2Owc2bdN66QOfCBax33wXfx84lufxcgr+aH/DBgs9MLsHZhe/y3+1/nVOFU7Jj8wsihKBZqw4FZvX6Vao3ruEMgvFnMxajeOgop//W7zFbOkI+Notu6YGDebuL+26Pln81+GCagjEdxzyQHiXJFhNo2Yjcw5RIHiJy1FYikUgeA67VOpy/VOH8xSrvLTYA2D8V5zdOljh3osgLCzIcaFcQIujHXHpnNDa78gF4g+B4YjrYx5wPncy5F4IxWsmuY7XsIHE2TJ1dX+ogBCiqwvRCaigy545kiSbvzmkUrkvvvfdoX7hA560L2DeDbtTO/mneParyl/Nr3CzB4dxRzi6c5fX9r/NU7im5G/0F6DbqE8E/letX6beDtGbNMJhZOER5/3FKhcNkzGnMnhGE/VQtcMM9TAW0fHToXG6KTL0QQ/kSo9ISiWR3+bRRWyk8JRKJ5BHE9wXvLTU4f7HK+UsVboThQKfmM8Mk2qMzMhzonumujzmZYQhQrx4cM+Iw+3zgYs6HKbOZfXJk9j4ghKC93h+Ozd651qRRDfZjdUOleCg9FJnFg2nMe+hI9Dpduj/+MZ0LF+j84Ad4jQboOusnZvmbgzZ/VV5jLaPwzNQznN1/lrMLZzmYObhbX+pjycDqUr1xjZVrYfjP9au011cBUBSV4r7DLJRPMp3ZT1rLo3c1nFoP0Rvbw0yZY0myYdDPTBzVlI6yRLLXkDueEolE8ogzcD1+cn2d8xerfO9yldX2AF1VeOnQFP/g6wd4/XiRORkOdPc4Paj8OujK3BSa9VvhQQVmjsPTvx0IzPkzMH0cNPlj9H4gfMHGSjd0NIPU2W4jcJUjcZ3ZwxmOf32WuaNZphdSaPeYMurcuRO4mhe+j/XznyMcB5FOsvxske/t07kwV2cQrXK6eJp/uPCPOLtwllKitBtf6mOHa9vUbt2Y2Mus3wkqgTRFZ654jJP7XqVwfI6ESKO2Ffy2AxWgAiI6gGKC+KnCyMEsJtAScj9WInnUkT8xJRKJZA/T6jtc+KjG+UtVfvDxKp2BS8LU+PZTM5w7WeTbT82QiclfyL40vg/rV8Mak1BoVj8EP3RY0uVAYJ7+43Bk9nmIyMqL+4Xn+ax+0mblajNwNa83GHSDv4tExmT26ChxNj+buOc9PeH79C9eonPhAu0LFxhcvhxcx3yRa2eP8P/OVfnFdBNNv8NLsy/x5/uDjs18NH/PX+vjhO95rC99MhKZ166ytngL4fkkjTzF7H5OFr5Ovlgi6sVR2uGUXRPoKhgzEYwjQRemHrqYWtqUkxoSyWOKFJ4SiUSyx6g0+7x5OejX/NmNdRxPUEia/M5zs5w7UeLlw1MyHOjL0q5Misw7v4JBsE+GmYLyC/D1fzpKmU3PPtzrfUxxbI9GxaJe6VIfu2/UrGEQUGYmxqHnpoPR2aNZ0oXorggRfzDA+tnPaIfhQG6tBqrK4MRBLv6dZ/g/ip9wLb1OTLd4pfwK//XCWV6Zf0V2bIYIIWhWK6xcv0J1MwDo5nVM1yRjTjOVKPNM9mXSx34H046gbNZhDkBPxTDmA+fSKAWjsno+hqJJgSmRPEnIHU+JRCJ5yAghwnCgQGy+v9QE4GAhEe5rFnl+nwwH+sIMOrDy3pjQfBdawagfqg7Fk6HADPcyC8dAlUEku0mvY1Nf2SIwVyzaG/3hOYoC6UKM3GyCXDHOzIE0s0cyJDKRXbsOd32dzvd/QPvCW3T/5ieIXg8lHqf9wmHePqrwv09dZ9UckDbTfHvft3l94XVennuZqH53qbePE536RuBkXrtC5foV6jeXiDhRsuY02UiRqVSZpJJF80cvgmkZM3AvN/cwiwmMmRiKfKFMInmikDueEolEsofwfcGvFuthOFCVm2tBONBz+7L8s994it84WeTwtAwH+jNeq/4AACAASURBVFw8F1Y/GgX/LL0Dq5dBhHZL7gAsfA3K/1EgMmdPgSH3YHcD4QvaG/0J53JTYPa7zvA83VDJluKUDmc4/o1ZcqUEuVKc7EwczdhdwS+EwL5+PXA133qL3vvvgxCopRnWv3OKHx7o8X+mPqavXqYQK3B24fc4u3CWM6UzT3THZr/boXr9GpXrV6hdu0b39gZmzyBjTpMxp3kh+gqRwujfjRLTQucyMQr7KSZQY/LXSolE8unI7xASiUTygOg7Hj+9vs75SxXevFRjrROEA718eIp//5sHeeN4kVJGOi2fihDQXJoUmSvvgROkmxLLBeLy+G+HbuaLkCg83Gt+DPAcn0bN2iYwGxUL1/GH50WTBrlSnEMvTJMrxYcCM5WP3tfuROE4WO+8S+fCW7TfuoCzuAiAdvwYd/7gFc7P1/kr4yN8NphPzvOH+/8eZxfOcmr6FKry5Dndjj2gdvMG1atXqF9ZYrDURLc0MsY0GbNA2XgFkgQ3DfRiHHM2NZYom0BNGfJFMYlE8qWRwlMikUjuI03L4cLHNc5fqvCDj1fp2h7JiM63nprm3AkZDvSZ9BrBLuZyOC679DZ0a8ExzYTSKXjxj0Z7mflDssrkHhhYzoRruSkyW2s9xrdyUlNRcqUE5WO5QGDOBgIzljQf2LV6rRadH/2IzlsX6PzoR/itFoppopx5jmu/+RR/UbzDz9wrwA2OZI/wp/v/A15feJ1juWNPlGDyPY/VT26xevEarasVnEoXw9JJGwWmjDwzSh5MEKaAjEaknCZazgxFpnafXzSQSCRPFlJ4SiQSyS6z0uzx5qUq5y9W+dmNdVxfMJ2K8LsvlDl3osjLh6eI6HLnaQLXDlJlh52Z78DaldHxqaNw5OxIZBafAf3BCZ3HBSEE3cYgEJbVSYFptezheaqukJ2JU9iX4uhXiuRmAwczW4xjPKTeRHtxMUihfesC1ttvg+ui5fP4r5zh/adM/nX2Oh/1fgXAqewp/mz/n3F24Sz70/sfyvU+aHzfp3FjkbVf36R7cxVvdYA5iJDS82TVOFkOgQJOzkHNm8T350kcLAT7mNMxlHuspJFIJJLPQwpPiUQiuUeEEFytdTh/scL5S1U+CMOBDhUS/MNXDgXhQPNZVOkcBAgBGzcCF3NzbHblA/CCnkYS08Go7KnfD6tMXoRY9uFe8yOG5/m0Vns7Ckxn4A3PM2M6uVKchWemyBVH7mV6KoqqPVwhInyf/gcfDFNoB1evBtd8+DDOH/wmPz/s86/1D1ju/RBVUTmTOcN/8ewf8trCa499x6bfd2levUP90iL9xTqi7hJ14kTUGHE04pSwGeBmXcSMjnm4QObYXLCHGZW/+kkkkoeDTLWVSCSSu8DzBe9+Ug+dzQq31oM9w+f3ZTl3ssi5EyWOzCQf8lXuEbrrY05mKDR79eCYEYfZ54N9zPkwZTazT47MfkHsvkujalFf2dy9DARms9bD90c/3xPZyGgsdkxgxvdYZ6JvWXR/+lPaFy7Q+f4P8NbWQNOInX6R9TOH+f7+Dv9P/5es99cxVIOX517m9YWgYzMXzT3sy991hOvj1Cys2+u0rqwwuNNGbUPEH+2CO76NpbTx02DOpcgcm2PqmQMYGRmiJZFIHg53nWqrKMq/BH4bqAkhngnflgf+V+AAcAv4fSFEfTcvWCKRSPYafcfjb66tcf5ile9drrLetTE0ha8fLvCPXj3E68eLFNNPeDiQ0wvcy3GRWb8VHFNUmD4OT//2SGROHwdNOjCfhRACq2UP+y83KhaN0L3s1AfD81RVITMTI1uMc/D5yYAfcw+6XP5ggLN8B2dpEfvWbbo/+Qndn/4UMRigJpPEXvkGS6dKnJ9d43z9J7TtXxHrxHh1/lVeX3idb5a/SdJ8PF7cEb7A3ejjVrr0l1t0b67iVi20noZC8MKAEB4Dp0VP60JOJ7YvS+7EAuWTRzCjT/j3HYlE8kjwRX4S/U/Afw/8q7G3/Tnw10KIf64oyp+Hz//z3b88iUQiebg0LYe3Pg72NX9wZRUrDAf6ztMzYTjQNKnoExoO5PuwfjXsygyFZvUi+G5wPF0OxOXpPw6E5uzzEHk8hML9wPcFrbUejYrFRigsNwXmwHKH5xkRjVwpztyxLLlSgnwpQbYUJzMdQ9tDe3rC93FXV3GWlrAXF3GWlnEWF7GXl3AWl3Cr1YnzjXKZ+N/5Pa6ezPCXqVv8sPo39L0+mUaG1/a9xuv7X+el2Zce6Y5NIQR+28apWDiVLvZKh/5iA3/DRvGV4Tkdt0HTXqWnd9EKURIHChROHuTI0TNEE/LfkEQieTT5QqO2iqIcAP7tmOP5MfBtIcSKoiizwPeFEE993seRo7YSieRRYLnR482LFd68XOVnNzbwfMFMKsIbJ4qcO1nipUP5JzMcqF0Ja0xCoXnnVzBoBcciaZh7YRT+Uz4N6dmHe717FNf2qFetkcBcsWhUuzSqPTx3VE8SS5vkS3GyoWu5KTCTucieGY/1Op1ATC4FYtJZWsJeCkXm0hLCHgUWoSjoxSLGfBlzfh9KuUSnkGA1p7KUsnnL+hU/r/wC13eZic3w2kIgNk8XT6Ore8+x/Tx8y8GpBQJzXGgyGP0d97wOTXuVpr2GpbQwZpOkD5eYOXaU0uGjJHP5h/gVSCQSyd3xaaO2dys8G0KI7NjxuhBix+UKRVH+FPhTgIWFhdO3b9++qy9AIpFI7hdCCD6utjl/scr5SxU+XA7E1JGZJOdCsXmqnHmywoEGnaAjc+hmvgOt5eCYqkPxZNiVeTpwM6eOgrp33La9QL/jsBH2XY4LzNZ6H8IfvYoCqUJsUmDOBumx0cTDd9KF4+CsrIwcy6VJkek1GhPnq6kUxr55zPI86vwc1nSKjZzOStbnVsxieVBlubPMcmeZ9f76xPvuS+3j9YXXObv/LM8Wnn1kOjaF4+HUeoHArI5Epj+WEuzi0LRXqferNO1VOjSJzKUpHNlP6fAxSoePkSmW9swLChKJRHIvPDThOY50PCUSyV7B8wXv3K4Pk2g/2bBQFHhhX5ZzJ0u8caLI4eknZKTNc2H18pib+W7wXITOTO5A6GKGQnP2FBgyuASC3bx2vR+OxW4KzC6NqkWv7QzP0wyVbDG+TWBmZmLoxsNzz4UQeBsboWsZCsuxsVinUglGqjcxDIy5Wcz5fWjlOfrFDM2pKJWM4JNkn9usc6dzh6XOEqvWKoLR7xi6olNKlCinypSTwW0uOcd8cp655BzTsek9LbyEJ3DXe0Nx6Va6OFULd703fCFBKAJL7VC3VljvLtOw12h7GyTKU5QOHw1E5pFjTJX3oWpP4NSERCJ5IrjrcKFPoaooyuzYqG3t3i5PIpFI7j99x+NHV9d481KF712usdG1MTWVrx+Z4h9/6zCvH59h5nEPBxICmkuj4J+ldwJn0wlSeYnlAnF5/HdCsfkiJAoP95r3AJ7j01i1JmpJ6pVAYLr2SJhFEjr5UoKDpwrkQucyP5sgmY8+NMfctyyc5WXs8VHY4eMlRK83cb42XcAszxN98QW0Yp5mIcpqTmUxZXPTaLLcW2G5vUjVehtPeDAAaqCuqhTjRcrJMi/NvjQUlJsicyY+g6bufbElhMBr2jiVLu6Yg+msWuBuWtXgRlw6osmavUh14xZNZ5WOUyc3V6Z0+Cizh1/ghcNHmTlwCN2UnbMSiURyt8LzL4C/D/zz8P7/3rUrkkgkkl2k3rV566Ma5y9V+OGVNXqORyqq89rTM5w7UeJbT02TjDx6+2NfmF4D7rw7EpnL70A3fK1QiwTu5Yt/FLqZL0L+0BNdZTLouYGw3CIwW2t9xFg9SSofJVeKUz6aIzcbHybIxlIPXmAIz8OtVEaO5eYo7OIi9vJyUEkyhhKPY87PY+ybR/3q87QLcdayOssZl5uxDp84Ve507nCn+xHuZlBUM7jNxGaYS87xQvEF5hJzzKdG4rKUKGGoD388+MvgdZ1QYFoTY7JirOuUhIodtWnG16jVb7Fc/ZiWvYYnXFJT05SOHOXgqy9TOnyU4qEjROKJh/cFSSQSyR7mc0dtFUX5n4FvAwWgCvxXwP8F/G/AAvAJ8O8KITY+75PJUVuJRPIgWKpbYb9mlV/cCsKBiukI506UOHeyyNcOTmHuofTPXcO1ofrhaCdz6e0gdXaTqaOjGpPyaSg+A/qT58QIIeg2bOrV7QLTao728lRNIVuMT/Re5kqBi2lEHpxzJ4TAbzYDx3J5S0Ls0hLOygo4o7FeVBVjdhZj3zxidobudJKNnE4lI7iZ7HFTWWO5e4c7nTsMvMHE58pH88MR2E2ncvP5XHKOiBZ5YF/3buLbXiAuw/HYQGR28cfGoZWYjpLT6OkW9X6VlbVrfLL4a/p2B4BoKh2Oy4Yjs4ePksg+ft2hEolEcq/c047nbiGFp0QiuR8IIfioMgoHungnCAc6OpPk3Mki506UePZxCwcSAjZuBPuYm2OzKx/AppBIzIQi88XAzZx7AWLZz/6Yjxm+59Nc7Q1FZXAfVJTY/ZGjZUa1QFhuEZjpQhRVezAvUEx0Wk4kxAbOpd/pTJyvZbMY+4Jk2N50isZUhGpa8Ena5rrZYLG/wnJ7Gcu1Jt4vbaYnxGQ5WQ5cy0QgLONG/IF8vfcL4fm4a73ReGwoMr2NsUAnQ0WfiUNWpUuL9e4yS5WPWbr1IXY4dmxEohQPHaEYCs3ZI8dITxf39A6qRCKR7BWk8JRIJI8Vrufz9u36UGwu1XsoCpxeyPHGiSJvnChy6HEKB+quj7oyNx3NXj04ZsSDjsz506MQoMz8EzMy6wy8CddyU2A2axa+N/oZl8iYOwrMeMa874Liy3ZaKpEIRrmMVp5lUMzRnIqymlNYTNpcj3e47dVY6izRttsT7xfX4xPhPVsDfFJm6r5+nQ8K4Qu8xmAkLjf3MVd7sPl3roJeiGGUEpDVaHt1ao3bLC9fpnLjKlYzSORVNZ3p/QfH3Myj5Of3oT4C+6gSiUSyF9ntcCGJRCJ54PRsjx9dXeX8pSp/fblK3XIwdZVvHinwT75zhLPHi0ynHs1RwAmcXuBejgvN+q3gmKLC9HF4+rdHY7PTx0F7vL+dCyHotZ3tAnOlS6c+GhdVVIXMdIxcKR4E/ITiMleKY8bu75/R3XRa6uU5/DPPYhW+xnpOZyntcCthcVVZ405vhY3+zyc+R7QfZU4P3MlT06cmBGY5WSYTyTx2rpzXsYddmOPjssIeudZaNoJRShB9Oo+S02m661TWblC5cYXKT67SWg2FvaKQn5vn4POnh27m9P5D6MajtZsqkUgkjyLS8ZRIJHuaetfmrz+qcf5ihR9eXaXv+KSiOmefnuHcyRKvHnvEw4F8H9aujFzM5behehE2Q13S88G47KbInH0eIo+Rk7sF3xe01/ujgJ+xPcyB5Q7P0011KCjH7zMzMbT7tL97V52W82XcUgFrJslGzmAl43Mr2eNqpMEn/RVWe6sT76OrOnOJuZFTGY7BbrqYU9Gpx05YbuIP3JF7OTYq63dHe5hqQscoJjBKCfRSHHUqQnNQo7p4ncr1q1SuX2F9eTEYRQfS0zOUDh2ldCTYyZw5eIRI/NEeJ5ZIJJK9jhy1lUgkjwyLGxbnL1U5f7HCL29t4AuYzUR540Swr/m1Q3mMB7R7t+u0K2FXZigy77wHg2AnlUg62MUsnx4JzVTp4V7vfcK1PRo1a+ha1qtBVUmjZuE5o3qSWMrYLjBnEySzEZRd3tm9q07L2VnE3Ey4ZxmlmoVPkn2uxFvc8KvUrBq+GL2PpmiUEqVt4T2bQnMmPoOqPKL/bX8KQgjEwMNr2XjNQXDfsvFawWN/7O2bKKaKUUygF+MYpQRGKY42E6XVWmXl2hUq169SvX6F1ds38dzgBYlYOrMt/CeeebL2miUSiWQvIIWnRCLZswghuLTSCvc1q1xeCYTYU8XUMBzomXL60XN6Bp2gI3NpbC+ztRwcU/UgVXZcZE4dBfXxEh39rjMmLMfqSdZHYS8okJ6KTu5fhvfRxO6OQH7pTstCAWWuyKCYDfYssypLGYfr0Q4f66us9Kq4YuTEKijMxGe2BfiUk2XKqTLFeBFdfYQd+i0Ix8drj0Sk17Tx2qPHfjsQlWLsxYRNlKiOljHR0iZaykSfjg3dTDVj0l5fHbqYletXqN64jtMPw3+iMUrD8J9AZKanZx697xESiUTyGCKFp0Qi2VO4ns8vbm0Ma0+WG0E40Jn9Oc6dKPHGiSIHCo9QH57nwurlUY3J8rvB8023K3cg7MoMhWbpWTBiD/WSdwshBJ36YEJYbt73xuoqNF0N6klmxytKEmRnYujm7gS5fPlOyxhaeQ67mKNTiLOW07mTdrmZsPgossFtu4Lt2xPvMxWdCkZfE4GYHBeXs4lZTO3Rr6gRvsDvOCNBOeZQBi5l6FaOjT8P0dVATA5vkeA+Y6Klgsdq2kQN/859z6PbqLN6+2YgMkNHs9cOXoDS9DD858ixocjMzZVl+I9EIpHsUaTwlEgkDx3LdvnhlTXOX6rw1kc1GmE40KtHC7xxosjZ40UKyUcgHEgIaC5OisyV98AJqytiuVG67GZnZmLq4V7zLuC5Ps1ab3vAT9XCHYyCXiJxPRiLnY2TK4b3pQSpqeg9V9rs2Gk5Xj2yQ6elVirizhawppNs5A0q6WDP8kqsyRVRoef1Jz5HNpLdcRS2nCwzm5wlpj+6LxgIIRA9N3QpxxzK5khc+i0br2PDVpNSATW1RUxuFZdpEyUMcbJ7PbqNDbqNenCr1+k261iNOp36BlajTrfZwGo1hzuZKApT5X1DgVk6cozCwgEZ/iORSCSPEDLVViKRPBTWO4MwHKjKj66uMnB9MjEjDAcq8srRaRJ7PRyo14A774ZCMxyZ7daCY1oEZk/Bi38/dDNPQ+7gI11lYvfcbc5lvWLRXO0h/NGLlcl8hFwpwYkjsxN7mLGUcU8jjzt3WoZ7lzt0WqrZDP7sDL2D0zTPzFPJwGJqwNVYi4/0VRr+KjAK8UkayXAM9iB/O/nNiQCfucQcSfPRDG8SjrejO7l1n3KnsVc1rgeiMhPBKCbGRmAjw8dq0sT3PaxWA6vRoFkPRKV1u06nEQjKQGRu0G00cO3B9s+j6SSyORLZLKnpGWaPPk08myORzTE1v4/iwcOYMRn+I5FIJI8je/y3PYlE8ijyybrF+UsVzl+q8nYYDjSXifJ3v7rAuRNFvnJwD4cDuTZUPxztZC69DetXR8cLx+DI2ZGTWXwG9EdvtFIIgdW0J2pJNvcwu83RaKmqKWRm4uTnEhx+cXooMLPFOGb07n6EfGqn5VLgXO7UaUlpmkExS+vV46xmVRbTDtfjbS6b61SUFnBzeH5Mj4XCch+/mXxp275l2ny09oWFJ/C79oQruZPAFL3tY6+KoQ5HW8351I5upZoycNxB6Epu0G2s0G006F4fcyvDW6/dGrmTY0QTyaGAnD36dCAuc/ngPpMjkQuORRNJlMdsj1kikUgkXww5aiuRSO4ZIQQX77Q4fzEQmx9VglL7p0spzp0sce5EkZNze/CXfSFg48akyKx8AF4ovBIzYfDPi8HY7NwLEHu0UjJ9z6e11t8uMCsW9phQMaLamGs5SpBNT8fQ7uJFgk/ttFxcwlle3tZpqUxPBXuW0wnW8zp3Ui43khYfmRvcNOqIsf92TNUcisitI7FzyTny0fze+29tB4Zjr+MismkHY7DNwXAc1m/boyCmTVTQUiZqOoKWMkcO5ZioJK7RG7Sxmo0xJ7IeiMr6xnDstVuv4zr2tusbupOhaBwXkPFsjmQ2EJbxTBbdfPRefJFIJBLJ/UHueEokkl3F8Xx+eXNjWHtyp9lHVeDMgTznwtqThak9NjLXXQv2MZfHUmZ79eCYEQ+rTF4c7WZm5h+ZkVln4NGoWtsEZqNm4buj7/PxjDlZTxLuYSay5pcSa5/Zabm4iNdsTr5DMoE3W8AqJNmYMqhkBLcSPT6ONfjY3MAZM091RaeUKA2TYDfHYOeT88wl5yjECnu+csS3vWBX8lNGXjdvuDuPvWrpCOoOO5Rq2sQzXCw7FJQ77Ex2wxHYzXCerUSTqeG4ayKbHzqVyVBQbrqV0UTykRDwEolEItlbSOEpkUjumSAcaJXzF6v89Uc1mj2HiK7yytFpzp0scvbpGab2SjiQ04OVD0Z9mcvvQP1WcExRYfp4sI+5GQI0/TRoe3/7oNceH48dCc32xiggR1EgPR3bQWDGicS/WEjLRKfleJDPp3Va6jp+cYp+MUMjb1LNKnySGnAt1uJyZINWdHSuqqgTlSPjbuV8cp7p+PSerRwRnsDrjHVPtjdHYMcf24j+p4y9ZkYCciKQJ6ExED16bger2wiCeCZ2JgOn0mrs7E5quj50IeNjojIxFJKhU5nJyaAeiUQikdxXpPCUSCR3xVpnwF9frvLmpSo/urrGwPXJxg3OPl3kjRNFXj1WIG4+ZJHg+7B2ZVJkVi+CH/7yn54PnMzNvszZ5yGydwNkhC9ob/TZCOtJGsOQH4t+d5TYqhsq2VBY5mfjZMME2ex0HM34fEdwstNy61js9k5Lkc8Ge5aFGKsZhaW0w/V4h4+iG1QTLmIssXY6Nr1jj2U5UaaUKGFoe0v8CCHwLXeiKmSnfUq/4+ww9qoE466bO5PpIKRHSxl4pmAgLHpuh243SHWd2Jusb9BtNuh/mjuZSpPIZLfsTGZHj7M5Etk8kURCupMSiUQi2RNI4SmRSL4wt9a6Qb/mpQpv364jBJSzMc6dDEZov3Igh/4ww4HalbDGZFNo/grsYK+USDoYmZ0fqzJJlR7etX4GruPRrPUmBOZGxaJRtfDGkkdjKSPsv0yQLyVCsRknlYuifEY9ybZOy/Egnx06LUUsilPM0SmEe5abfZbRBkupAbYx+lz5aH6UBBs6leN7lxFtjzjfBGOvXnOU6vppAT14238eqgljYtxVTZuoSQ1bdRiILpbbweo16DQ2sJqTtSHdRh1vvNolRDOMMdE4Eo+j3cngPp7JSndSIpFIJI8csk5FIpF8KkIIPlxuBUm0F6t8XA1E3PHZNP/0taOcO1nkxOxDCgcadODOr0Y7mcvvQGs5OKbqQarsqd8fCc2po7DHUjP7XYdG1domMNtrvVFAqALpqSjZYoL5p3NDgZkvJYgmdxYfQgi8RuNLdVq60zmsmST1kzlWMhluJ4I+y1upPu2YA0pQPZIyU6GYPMw3dxiJjRsPf39XeD5e2xl1T46PvrZHYT1irGN0E8XUgkCelEnkQAY1ZeBHwVUH9IWFZbfo9Ot02+HO5NLIpex32jteTyyVHorH+dm5iX3JRGY08hqJS3dSIpFIJE8e0vGUSJ5QHM/n5zc2OH+pwpuXqqyE4UBfOZAfJtHuyz9gceG5sHp5zM18B1Y/AhG6f7mDIxdz/gyUngUj9mCv8VMQQtCpD2hULDYqkwKz1xrt5Gm6SrYYG47FbgrMbDGOYWrbPu6X7bT00wl6MxmaUxGqWVhM2VyNtbiZsFhPg6cFgmezcmQ+OT8R4LMpLNNm+v7+gX0Gwhf4ljN0JLeH9ITuZXeHsVdtcuxVSRp4hout2gz8Ll2nRae/QacddE1u7k9ajTqeu30vM3An88GOZGZyX3LCqcxk0HTpTkokEolEIh1PiURCd+DygyurnL9Y4a2ParT6LlFD5dWj0/yn557itadnyCceUC2CENBcHNWYLL8LK++BYwXHY7kg9Of4dwOROfciJKYezLV9Bp7n06z1RgE/lS6NcP/SGXPWInGdXCnO/memyJVGAjNdiKGOjccOOy1/fYXuF+i0FKbBYCYT7FmemWI5neF6vMONeIdaFnqRAVAjokXC0df9HEiW+UZyciQ2G8k+FNfNH4T1IaEr6W+tEGkFj3cce00aYe+kiToTwTM8bLVP37fo2k3a/Trt1ipWq073euBU9rudHa4CYunMUDzm5+a3jb7GszmSuTxmLC7dSYlEIpFIdgHpeEokjzmr7SAc6PylKj++tobt+uTiBmePFzl3osgrR6eJ7eC07Tq9Btx5F5bGRma7teCYFoHZU6Mak/nTgbv5EH/ht/vuUFgO60kqFq3VHr4/+r6ZzEUmei+DBNkEsZQxFCxfptNSKAruVJpOIc56TudO2uNmwuJaok0tA41kcI6u6swl5rb1WG66llPRqQcqmITrD3snx93JrW7ljmOvES0UlAYiCq7uMlD6gUNpN2n3Nmh1Vuk01kOXso7vbXcndcMkkct9brprPJ1F0+XrrhKJRCKR3A+k4ymRPEHcXOty/mKF85eqvPtJEA40n4vx731tP+dOFjmz/z6HA7k2VH8duJibY7PrV0fHC8fgyOthZ+bpYE9Tf/AF9EIIrJY90Xu5KTC7jcHwPFVVyMzEyM8mOPzCdCAwZxNki3HMqD7WaXkb571lOv92kY3P6LT0ElGs6RT1vEHlwBS3kn2ux9tUMoLVDLh6F1XpUYqXKKf2U06WObslwGc6No2m3v8XDIZjr1tcya2C0u9uD9FBU4ZVIX4avLyKrdj0vA6W3aTV26DZrtFurmEt1nd2JxWFWCo9DNzJl/eN7UxOprtKd1IikUgkkr2LdDwlkscA3xf8erk5DAe6Wgt+gT85l+bciRLnThZ5upS6P7+UCwEbN0Yu5tLbUPkAvNDFS8xMJsyWX4RoZvev4zPwfUFrrbdNYDaqFgNr5JwZEW1L72VwnypEodn4wp2WQtfoF1I0piLUsvBJ0uZ6vMNKxqeWhW5MQUFhOj49ISbHw3uKiSKGev92BoUQiIG3s0O5JaQHf8vPCSVIeyWu4kcEru4woE/f69C1G7SsdZrtGo1mFavR2NmdNCOjvcnNnclMbktNSI5YOiPdSYlEIpFIHiFknYpE8phhuz4/v7nO+YtBx2al1UdTFb56IM+5k0HH5nzuPoQDWCJJsAAAG2NJREFUddcmRebyO9BvBMeMeFBlUn5xNDabmX9gI7OO7dGohuOxK9ZoB7Nm4buj73XxtLlNYGayCmZnNRCTX6DT0s4maE/FWM2pLKUcbiS6LGc8ahnYSIFQFaaiUxNicrPHspwqM5uYxdTuj8srXH+HypDt/ZTC9re9rxJRIa7iRQSu5jCgR99r0xk0aVtrNFpV6s0K/e4Oya6KQnxsd3LbzuRw/DWHGYtJd1IikUgkkscQOWorkTwGtPtOGA5U5cLHNdp9l5ih8eqxAv/sRBAOlNvNcCCnBysfhF2ZodBs3A6OKSrMnIAT3w2dzDMw/TRo9//bSq9jh8KyO7GH2d7oD1NOFQXShRi52QT7T06RLcZIGz3ig3XU1dCxfDdwLHvLy3S2dFp6UYNOIcFGTmf5dJRbCZ+llEM1p7CaAdsYkIlEKSdLYTpsma+NBfjMJmeJ6bubuCt8gd8N016HruQWt7I9wO9udxjRFIgpeBE/EJTZHj23TWfQoNVdp9GuUG+s4Lj9be+qRyJD0ZjaN0Px2acm011DpzKezqBqD2BfWCKRSCQSySOHFJ4SyR6n1u7zvUs1zl+q8JNr69ieTz5h8pvPlDh3osQ3jxaIGrvwy77vw9qV0M0MhWb1IvihiEnPB6E/X/mTQGTOPgeR5L1/3k9B+IL2Rn8y4Ce873dG+4S6oZItxSkdTPPUCzlSWpeEvUa0sYS/vIjz9qjTsu04bPp0QlXo5RNsTJlUDwluPRtlKWVTzSpUc9CO+SRNKCeLw1HYN8bdy2SZpLk7X78QAtH3tjmUkyOwg3Dsdcs7KyCiCp7h4Wg2A6NHL9mmO2jQ7K7RbFdpdmrY/hZBuelOhqOt0wuHOZA7s6NbacYefmenRCKRSCSSRxspPCWSPciN1Q7nL1U5f7HCrxYbCAEL+Th/9PJ+zp0scXp/Dk29xzHF1sqkyFz+FdihLIukg5HZb/zHo93MVOnev7Ad8ByfRs3aJjAbFQvXGamsaMIgW4yx/1CUlOaRsNeIN5cwKtdx3p7stLTCm52K0shHqOUVFhd0PkkFo7DVrMJ6GsyIwlxiethj+XJqct8ybabveRxUOH4gIDd3JncSlC0b4WwfexUGeKaHo9oMhIVltun067S6azTaVSy7Sd/rIsbKLI1IdORE7sszn32Op3aoCYml0tKdlEgkEolE8sCQwlMi2QP4vuD9pQZvXgpqT66F4UDPlNP82evHOHeyyFPFewgHGnTgzq/GhOa70FoOjql6kCr73B+MRObUUVB3N/V2YDkjcbliDQN+Wms9xlfNk1mDTFJwZK5Hwl4n3loiWr2Kcvn6tk5Ly9BoF2KsZlWWT/rcTqrUslDLKNSy4MYUysnpoZh8ZksybD6av+s/U+EL/I4zJiIH2/spWza+tX3sVagicChVm77oYok2HadOs7tKp7eO5Xboex08EbyvoqjEM5lwTzJHfH+ew9nDYzUho3RXM7q7470SiUQikUgku4EUnhLJQ8J2fX56Y53zFyu8ealKrT1AUxVeOpTn7720n9dPFCln70JEeC7ULk2KzNWPQISOWu4gLLw8SpotnQIjuitfkxCCbmOwRWAG91Zr1FWpapBKCNKaxWxinVhrmVjlKuYnH6L2u6OPp4CVjbGS11mZ87h9TKWagVpOoZaBdkqjmJxiPjlPOVXmYGKOb6ZG6bCFWAFV+XICWgiB6LmfOvK6+dhv27Alm00QCEpbGTDwLbpuk24vEJSW26bnduh5bRw/qGoxojGSuRzxTI7EfI5sboFy5rlwfzI/luyaRn0A1SkSiUQikUgk9wspPCWSB0i77/D9j1c5f6nK9z+q0R64xE2Nbx2b5tzJIt95aoZs/EuEAwkBzcVRuuzyO3DnPXDDBNZYPhCXx78bCM25FyExdc9fh+f5tFZ7kwKzEtSUOH1veJ6h+6T0HlPOOvu6y0QrV4mt3SDaX0cNhbAdM6hPmXySEXzy3IBKVqWWgVpWYS2jMJWZmqgaeW5sFHYmPoOufvFvY8LxxlzJwWj0tT0K6/E/ZezVU11sdUDf72LZLdr9DTr9Oj2vMxSUA88Kdiez2VFNyIEcM9njO6S7ZqU7KZFIJBKJ5IlBCk+J5D5TbfV581JQefKT62s4nmAqYfJbz85y7mSRbxz5EuFAvQbceReW3hkJzW4tOKZFgsCf0/8gdDNfDNzNe9hRtPtuWE8S9l+GQrNZs8ZrK4mqfZLOBqXWMrG1myS6d4hbVUy7ha+ptPImtazC5WmbyhFBNQu1jEYtC/F8YWKv8htjybClRAlD+/wuS+EJ/M5O7uT4COwAMSaKN/EVH1vp0/O6WE6Tdm+DntsOBWV473XQo+ZwtDU+E4y8zmYXSGyOv0p3UiKRSCQSieRTkcJTItkF+o7HnUaPO40+yw2L5XqPpUaPa7UOHyw1Adg/FeePv3GQcyeKvLDwBcKBXBuqvx4TmW/D+rXR8cIxOPJ6IDDnz8DMSdC/fJWKEIJe2wmFZSAuN5bb1Fc6dNsjoabgE3caxNvL7GvfIW5VSFgV4laNQcJnLauylHZZOeBRyypUswq1jIYo5JhLzw97LE+FPZblZNBlGdU/fcxXCIHXdfDb9qhCZEJcDnCbA0TX3XHs1aZP3+/SsRtYdjN0JkeCsu9bmOlY4ELm88HIa3aGqdxTEzUhiUwWI7o748gSiUQikUgkTyJSeEokn4MQglbPZalhBcKybrHc6IW3Psv1HmudwcT7KAoUU1EW8nH+s3PHOHeyxNGZ5KcH2QgBGzdGXZnL70DlA/DCvcjETCAun/u7YQDQixDNfKmvw/cF7fUe9RWLjTsdNm6ts7Hcpll3sd3RHqTmDYhbFZLdKkWrQtyqEHFXsaINKmmbTzIe1WKwY1nNKfSnU0zn5oeO5aHkHK+OBfjEjZ2rOHzbw2vYDFqNbQ6l2+jjNvqIjru9PgSwxYC+16FrN+l5o93JTWHpGh56JkYimxmJx+w8M1tqQmKpNMouhyhJJBKJRCKRSLYjhafkicf3BbX2IHAqQyG56VoGDmaPzmAymdTUVcrZGOVsjLNPz1DOxZgLn8/nYhTTUUz9MwRNd200KrspNPuN4JgRD6pMvvaPA5E5fwbS5S88MuvaHvWqxcaNVdau1qjfadOou7R7Bj6jazLtFnGrwnS3SqxXQShrtCMVqol1rmUVauWgdqRViJKemWc+dWIoJl9IBq7lXHKOtJme+PzC8/E6Dl5zgL9s0QmFpdvs49StwKHsuCjO1isHVzj0vA6W0xruTva9DpbbZiAsiKto6QjxfGYoHtPZg8wOa0JyxDNZjIh0JyUSiUQikUj2ElJ4Sh57+o7HSrMfCslgBHZTXN5p9Flp9nC8yTnNTMygnI2xLx/n5cNTlLOhsMwF4rKQNL94DYfTg5X3J0Vm43ZwTFFh5gSc+C6Uw5TZ6adB+/x/mtZGh9UPF1m/VmVjuUVzw6XVM7BEfCRShU+sv0HcqlC0azhqlaaxwnqiSjXbo7YA9akIkbkypUyZ+eRzzCXn+MZYmE82kkVRFIQQ+JY7CuGp2XjNOmv1ZZwNKxCaXQ9lIFCY/LPxhUfP6+64O+nqLmpCQ0tHiGRTJPNBymsuO8v8eLJrMiXdSYlEIpFIJJJHFCk8JY88zZ4TCslAWC6HwnIpfL7a3nkMtpyL8dy+LL/17CzlXIz5MXGZjHzOPw0hYNAOnEtrPbxfG7tfD+5bK7B6GfzQMU3Pw/xp+MqfBEJz9jmIJHf+FL6PU63R+HiRtasV6sttGhsOLUunTQpHH72f6pnEeg10r0aUFdpmhfVEjTvZGmt5UOdmKRT2UU7OU05+jVOhczmfmicfzYMtRjUhLRvnZp/BWhurfo12c4CwPNS+giK2i+2+1x3tToaisu9biBgocQ0tGyGSSwYJr9k8hTCQJxEmuxpm5Mv9hUskEolEIpFIHjmk8NwjeL7g+mqHjyptTE0hEdFJRHRS4X0iopOM6J8fSPOY4fuC1c6ApXFhWR+JyzuNHu3PGIN97amZCafyU8dghQhGXbtVqK5tEZJbhWX43JsUtEP0KMQLQW1JqgTHzoVu5ovB8zG8TgfnxmV6nyxRv1plY7lJY92haWl0SGPFZvC1CJAAEmhuF9Wp4Cg36Kg11uMVVnI1+vMGqbl9zKXKlFNHOJT8Fq8ky8zF5phyM4hO4FTa6136H7dw6z3cVotO90OsAaj+9hRWxx+MdifDsVdHsxFRUJIGeiaCOZUYCspi9giJbJa4dCclEolEIpFIJFuQwvMhIIRgpdnn/cUG7y01eH+xwa+XmnTt7VUPW4kZWiBIozqJiEbC3Hy8XaiOHmujc8bON7SHLwwGrsdKuEc57lJuistPG4OdGxuDnctGKWfjQ3E5lTBR8cHaCMViJbhfX4PF9S1CMnQmrfWRK7kVMxWIyPgUpGah9GzwOFEIBWZhJDTjBTATw1FX4Tg4KyvYi4s47/8Q6/Yy60stNtb6tC0dS5+iGy/SjxUQyhwwByoo0Q0cpULHvMZGvEpnpod/MEJhZpq51BzziWeY12aZ9adJ2wmcWofBWhtnsYfXssHyUActPM+ituXL8YRHf+hQBu6kZ3iBQ5nUMTIxjKkE8aksiVyRbObp4birbn751FyJRCKRSCQSiUQRQnz+WbvEmTNnxNtvv/3APt9eodlz+CAUmO8tNnl/qTEc/zQ0hROzaZ7bl+W5+Swn5tIIAV3bpdN36QxcuoPgfvKxFzzePGfs/IG7QwzoDpi6uoNQHRO2pj4mcncQsxFjeH5EV3fceWz2nEmXcmwUdvkzxmDnslHKuXjgXOZizKdU9kX7zOodEm7js8dbu2vQq7OtX2OTaHaLaNwqIoPnwsjgeSb+wMVrt/HbHfxOG6/TGT522x0GTYtep8ug3cPuOTg9F8cWuK6C5xtYsRmseIluvIgdyQ4vQwgXV1mlY1Tophs4JZ/IfJTZQpYFY46SPUWmbRLtaHiNAX7LgZ6POlDQPQOVyRcOhBD0vS79cOTVVgZ4hgdxJXAos1EihSSxQjYQkrlATEYTSelOSiQSiUQikUh2BUVR3hFCnNn6dul47jID1+PSnRbvLzZ4f6nJ+4sNbqx1h8cPTSd45UghEJr7shyfTRHRd7ds3vH8oUDtDjw6A2e7UB24dEKx2g2FbGfgsNaxub1u0Q7Psb6ACwuBgB53VIXgM8dgD2RUvnrQ52DcYz7SpaR3KSgt0n4TrTfmSq6GgnLQ3PkTKyrE8iPhOHMcEZtC6Fk8UvhKDN+P4nkmjq0w6NtYrRa9RpvBSo9BZ4BjOXj9Gu6gimcrCE/F93R8xcTTIrhaDE+P4GlRXC2Cp0dxtTielsPTIsE1AJjhbUvLiUePvrmGk14hOlWlEDcp6FHyIka8lyHSy6P0QKuo6Msm+sQ/Sw/w8Hybgdum73dxNAff9CCmoqbGBOVMlmT+EMUw4VU3jC/0dyeRSCQSiUQikdxvpPC8B3xfcGOtG4rMwNG8tNIajoZOpyI8vy/L3z49z3PzWZ6dz5CJ3X8xYGgq2bhJNn7vY5GeL+jagQjtDlza/VDM9h2sXhfbamFbbZx+G7+3jjfoIAYdYl6HcrnLjNZhKhSUMaeB3l9HsdZh2drx8wkM+voUXT1LT03SZ56+OExfizCwTWxbxx3ouLaGN1DxbRXhKAhXRXgGwjdAGHhaFE/XcTUNT1PDxxE8LY+vLUx+Uh1IhjdAFQJV8VCxUemjqjaq6qJqHprqYWoWut5D00BXVXQUDEVFV1R0oaKjoqOhCRVNqJi+ienNYbpRqG758xVuUBlCD1dz8EwfJa6ipAzMXAxzKkmsmCUzs5/ZTXfyi6bpSiQSiUQikUgkewQpPL8E1Vaf9xYbQ6H5wWJz6OglTI1T81n+5JuHeH5fhuf2ZSmlo3tHJLgDsLtgd2DQGT0e3oePtxzT7A5pu0va7iAGbRzbYuB0GTgWA3xsoTDwVRxfwRbBveMr2K7GwIlyy0tx1c/geQmEV8R394MfBddE8UzwTRQ/AgQ3oUZwtSieHsVRIwjNQOg6qgIqHprioxHcVMNHM31UBBoCXQEND1URaIpAU0BTFDRVRVPc4H0VG03R0BQVDQ0NHU3RUNHQlODxiBjb7MtxvPC2+VS4eL6Lh4svPHw8PMVnoHWxoh2UhIqaMjFyMSKFFLFSllQxTzmbl+6kRCKRSCQSieSx5p6Ep6Io/w7w3wIa8D8KIf75rlzVHqDdd/j1UnMY/vP+YpNKqw+Ario8PZviu8/P8fy+LM/vy3JoOrl7ibOes6MQ9ActBoMWdr9Jv9/A7jYZdFsMul36vT52b4A9cHD6Ho7t4TrgueC6Kp6n4fs6vghcQV8Y+J4GwkDxDcBAQUdBBww0ckAheJuioqChKhooWvhcRVFUUMN7lPCxAoqCqihoioIJxBTQNFB1BS2qoKEGglBRx27a2E0f3u5WuPvCxxcuHl5wr/j4eAhFIFQfofi4mo+j2gQKFdAVFENF0VUUQ0U1NBRTQzV1VFNDixioUQM9YqDFTLSoiR6PoEcj6PEIRiSCZhqo6u6OTkskEolEIpFIJI86dy08FUXRgP8BeANYAn6pKMpfCCEu7dbFPUh+8W/+DUs//hDH8XFcH98XqAKyKJxVFH5DDYSUhoqqKNBS4CNAKFwFrgoFBQWEAoSPhzcCoTb2NiV8G4oyPGP4ViU4V1E0lInnCoqiopJDUfKh+As+sqYoxFFIhueqioKCimoEYkoNxeLw7YoaCMkHhCdcPOHh4+Lj4yvBTagCVIFQBa7m4moeaA6KroChoOgqqqmhGBqqoaGaGmrEQIvoaBETNaajRSPoMXMkAGORQBhq0tCXSCQSiUQikUj2Avfym/lXgWtCiBsAiqL8L8DvAo+k8Fz9/hW+Gvs2PISJRyEEm/9DCHx8hPCH9wKBL3wEPr4QCPzwNv7/Pj7gKgKhhGmuKqAGghVNQdFUlM17XQucPU1B0RTU8LmqqYHzp4bOn6ai6iqKpqFqCoqho6qhI6hpwXM9FIV6KBB1Hc3QMOIxtLiJZhooT1j/qEQikUgkEolEIhlxL8KzDCyOPV8Cvrb1JEVR/hT4U4CFhYWth/cMB373JS7/5AMikVBI6TqKoaNpOqphoJlmcNNNdNNANXV000Q3THTDCMYwDR3V0ND0UIRpKooaijhNRVEDYRc8V1DU4BxVVllIJBKJRCKRSCSSx5h7EZ47WVjbihOFEP8C+BcQ9Hjew+e7r5x87VucfO1bD/syJBKJRCKRSCQSieSx416stiVg39jzeeDOvV2ORCKRSCQSiUQikUgeN+5FeP4SOKooykFFUUzgD4G/2J3LkkgkEolEIpFIJBLJ48Jdj9oKIVxFUf4J8P8RlFH8SyHExV27MolEIpFIJBKJRCKRPBbcU9+EEOIvgb/cpWuRSCQSiUQikUj+//buL0Szuo7j+PvT+qeoaP2PuJKCe+F24RqhC3tjW+hWkl0obIQtseCNgUKQ2o1UXthNRlBBlLRFtS2mJBLV4h+8yn9puesmjqW1rDTKrlYEyuq3i/MbeZhmw5U5c84c3y8YznO+z5mZ8wwfnt/zPX9+I2mCnE5VkiRJktQrG09JkiRJUq9sPCVJkiRJvbLxlCRJkiT1ysZTkiRJktQrG09JkiRJUq9sPCVJkiRJvbLxlCRJkiT1ysZTkiRJktQrG09JkiRJUq9sPCVJkiRJvUpVrdwvS14Enu/xV5wKvNTjz5eOlZnUGJlLjZG51NiYSY3RasjlB6vqtMXFFW08+5bk0ar6yND7IS0wkxojc6kxMpcaGzOpMVrNufRSW0mSJElSr2w8JUmSJEm9mlrj+f2hd0BaxExqjMylxshcamzMpMZo1eZyUvd4SpIkSZLGZ2pnPCVJkiRJI2PjKUmSJEnq1SQazyRbkzydZC7JjUPvj6Ytye1J5pPsnamdnGRPkmfa8qRWT5Jvt2z+KcmHZ75ne9v+mSTbh3gtmoYkZye5P8n+JPuSXNfq5lKDSfLuJA8n+WPL5Vdb/dwkD7WM/SLJCa1+Ylufa8+fM/Ozbmr1p5NcNswr0lQkWZPk8ST3tHUzqUEleS7Jk0meSPJoq01uDF/1jWeSNcB3gE8AG4DPJtkw7F5p4n4EbF1UuxG4t6rWA/e2dehyub59XQN8D7o3E+Bm4GLgIuDmhTcU6W04Anypqs4HNgHXtvdBc6khvQpsqaoLgI3A1iSbgG8At7VcHgZ2tO13AIer6jzgtrYdLcvbgA/Rvfd+t4390tt1HbB/Zt1Magw+WlUbZ/5H5+TG8FXfeNL9Yeeq6i9V9RqwC7hi4H3ShFXVg8ChReUrgJ3t8U7gMzP1H1fn98DaJGcClwF7qupQVR0G9vC/zaz0llTVC1X1h/b4X3QfqM7CXGpALV//bqvHt68CtgB3tPriXC7k9Q7gY0nS6ruq6tWq+iswRzf2S8csyTrgU8AP2nowkxqnyY3hU2g8zwL+PrN+oNWklXRGVb0AXRMAnN7qR8unuVUv2qVgFwIPYS41sHZJ4xPAPN2HoGeBl6vqSNtkNmNv5q89/wpwCuZSy+tbwJeBN9r6KZhJDa+A3yV5LMk1rTa5Mfy4oXdgGWSJmv8jRmNxtHyaWy27JO8DfglcX1X/7A7ML73pEjVzqWVXVa8DG5OsBe4Czl9qs7Y0l+pVksuB+ap6LMklC+UlNjWTWmmbq+pgktOBPUn+/H+2XbW5nMIZzwPA2TPr64CDA+2L3rn+0S5zoC3nW/1o+TS3WlZJjqdrOn9aVXe2srnUKFTVy8ADdPcgr02ycOB7NmNv5q89/wG62xrMpZbLZuDTSZ6juzVrC90ZUDOpQVXVwbacpztIdxETHMOn0Hg+AqxvM5KdQHez990D75Peee4GFmYP2w78aqb++TYD2SbglXa5xG+BS5Oc1G78vrTVpGPW7jn6IbC/qr4585S51GCSnNbOdJLkPcDH6e4/vh+4sm22OJcLeb0SuK+qqtW3tRlGz6WbUOPhlXkVmpKquqmq1lXVOXSfF++rqs9hJjWgJO9N8v6Fx3Rj714mOIav+kttq+pIki/S/WHXALdX1b6Bd0sTluTnwCXAqUkO0M0gdiuwO8kO4G/AVW3zXwOfpJt44D/AFwCq6lCSr9MdOAH4WlUtnrBIeqs2A1cDT7b76QC+grnUsM4EdrbZPt8F7K6qe5I8BexKcgvwON1BE9ryJ0nm6M4qbQOoqn1JdgNP0c3gfG27hFdaLjdgJjWcM4C72u0xxwE/q6rfJHmEiY3h6Q7cSJIkSZLUjylcaitJkiRJGjEbT0mSJElSr2w8JUmSJEm9svGUJEmSJPXKxlOSJEmS1CsbT0mSJElSr2w8JUmSJEm9+i+nwpGNVzcU7QAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -743,14 +885,14 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 48, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "* geometric mean of time improvement is 3.9\n" + "* geometric mean of time improvement is 3.5\n" ] } ], diff --git a/examples/mp/jupyter/lifegame.ipynb b/examples/mp/jupyter/lifegame.ipynb index f1f937f..9b7a5fc 100644 --- a/examples/mp/jupyter/lifegame.ipynb +++ b/examples/mp/jupyter/lifegame.ipynb @@ -372,7 +372,7 @@ }, "outputs": [], "source": [ - "assert ini_s.check(), 'error in initial solution'" + "assert ini_s.is_valid_solution(), 'error in initial solution'" ] }, { diff --git a/examples/mp/workflow/populate.py b/examples/mp/workflow/populate.py new file mode 100644 index 0000000..23480ae --- /dev/null +++ b/examples/mp/workflow/populate.py @@ -0,0 +1,230 @@ +#!/usr/bin/python +# --------------------------------------------------------------------------- +# --------------------------------------------------------------------------- +# Licensed Materials - Property of IBM +# 5725-A06 5725-A29 5724-Y48 5724-Y49 5724-Y54 5724-Y55 5655-Y21 +# Copyright IBM Corporation 2009, 2019. All Rights Reserved. +# +# US Government Users Restricted Rights - Use, duplication or +# disclosure restricted by GSA ADP Schedule Contract with +# IBM Corp. +# --------------------------------------------------------------------------- +""" +Reading a MIP problem and generating multiple solutions. + +This sample can be used to run populate either on a model file (LP or SAV) +or a DOcplex model instance. + +""" + +from docplex.mp.model_reader import ModelReader + + +def populate_from_file(filename, gap=0.1, + pool_intensity=4, + pool_capacity=None, + eps_diff=1e-7, + verbose=False): + """ Runs populate on a model file. + + :param filename: the model file. + :param gap: MIP gap to use for the populate phase (default is 10%) + :param pool_intensity: the value for the paramater mip.pool.intensity (defaut is 4) + :param pool_capacity: the pool capacity (if any) + :param eps_diff: precision to use for testing variable difference + :param verbose: optional flag to print results. + + :return: the solution pool as returned by `docplex.mp.Model.populate()` + """ + m = ModelReader.read(filename) + assert m + return populate_from_model(m, gap, + pool_intensity, pool_capacity, eps_diff, verbose) + + +def populate_from_model(mdl, + gap=0.1, + pool_intensity=4, + pool_capacity=None, + eps_diff=1e-7, + verbose=False): + """ Runs populate on a model instance. + + :param mdl: a model instance. + :param gap: MIP gap to use for the populate phase (default is 10%) + :param pool_intensity: the value for the paramater mip.pool.intensity (defaut is 4) + :param pool_capacity: the pool capacity (if any) + :param eps_diff: precision to use for testing variable difference + :param verbose: optional flag to print results. + + :return: the solution pool as returned by `docplex.mp.Model.populate()` + """ + print(f"* running populate on model: '{mdl.name}', gap={gap}, intensity={pool_intensity}, capacity={pool_capacity}") + # set the solution pool relative gap parameter to obtain solutions + # of objective value within 10% of the optimal + mdl.parameters.mip.pool.relgap = gap + if pool_intensity is not None: + assert 0 <= pool_intensity <= 4, f"Pool intensity must be in [0..4], {pool_intensity} was passed" + mdl.parameters.mip.pool.intensity = pool_intensity + if pool_capacity is not None: + assert pool_capacity >= 1 + mdl.parameters.mip.pool.capacity = pool_capacity + + try: + solnpool = mdl.populate_solution_pool(log_output=verbose) + except Exception as ex: + print("Exception raised during populate: {0}".format(str(ex))) + return + + if not solnpool: + print("! Model {0} fails to solve, no pool generated".format(mdl.name)) + + print() + print("* Solve status = '{0}'".format(mdl.solve_details.status)) + # Print information about the incumbent + print() + print("-- Objective value of the incumbent = {0}".format(mdl.objective_value)) + sol = mdl.solution + assert sol is not None + + # Print information about other solutions + print() + nb_pool_sols = solnpool.size + print("-- The solution pool contains {0} solutions.".format(nb_pool_sols)) + + numsolreplaced = solnpool.num_replaced + print("-- %d solutions were removed due to the solution pool " + "relative gap parameter." % numsolreplaced) + + print("* Pool objective statistics") + solnpool.describe_objectives() + + print() + print("#solution objective #var diff.") + numcols = mdl.number_of_variables + for s, sol_i in enumerate(solnpool, start=1): + objval_i = sol_i.objective_value + + # compute the number of variables that differ in solution i and in the incumbent + numdiff = 0 + for dv in mdl.iter_variables(): + dvv_i = sol_i[dv] + dvv = sol[dv] + if abs(dvv_i - dvv) >= eps_diff: + numdiff += 1 + print("%-15s %-10g %02d / %d" % + (s, objval_i, numdiff, numcols)) + return solnpool + + +if __name__ == "__main__": + from examples.delivery.modeling.sport_scheduling import build_sports + nm = build_sports() + populate_from_model(nm, gap=0.2, pool_capacity=13, pool_intensity=3, verbose=True) + + +# * building sport scheduling model instance +# 37 games, 21 intradivisional, 16 interdivisional +# * running populate on model: 'sportSchedCPLEX', gap=0.2, intensity=3, capacity=13 +# Version identifier: 20.1.0.0 | 2020-09-28 | 1fa7d7e06 +# CPXPARAM_Read_DataCheck 1 +# CPXPARAM_MIP_Pool_Capacity 13 +# CPXPARAM_MIP_Pool_Intensity 3 +# CPXPARAM_MIP_Pool_RelGap 0.20000000000000001 +# +# Populate: phase I +# Tried aggregator 1 time. +# Reduced MIP has 5048 rows, 4440 columns, and 23976 nonzeros. +# Reduced MIP has 4440 binaries, 0 generals, 0 SOSs, and 0 indicators. +# Presolve time = 0.02 sec. (13.62 ticks) +# Probing time = 0.00 sec. (3.09 ticks) +# Tried aggregator 1 time. +# Reduced MIP has 5048 rows, 4440 columns, and 23976 nonzeros. +# Reduced MIP has 4440 binaries, 0 generals, 0 SOSs, and 0 indicators. +# Presolve time = 0.02 sec. (13.19 ticks) +# Probing time = 0.02 sec. (3.09 ticks) +# Clique table members: 4912. +# MIP emphasis: balance optimality and feasibility. +# MIP search method: dynamic search. +# Parallel mode: deterministic, using up to 12 threads. +# Root relaxation solution time = 0.22 sec. (160.99 ticks) +# +# Nodes Cuts/ +# Node Left Objective IInf Best Integer Best Bound ItCnt Gap +# +# * 0+ 0 65154.0000 984200.0000 --- +# * 0+ 0 66386.0000 984200.0000 --- +# 0 0 95032.0000 690 66386.0000 95032.0000 10 43.15% +# * 0+ 0 95032.0000 95032.0000 0.00% +# +# Root node processing (before b&c): +# Real time = 1.27 sec. (1267.92 ticks) +# Parallel b&c, 12 threads: +# Real time = 0.00 sec. (0.00 ticks) +# Sync time (average) = 0.00 sec. +# Wait time (average) = 0.00 sec. +# ------------ +# Total (root+branch&cut) = 1.27 sec. (1267.92 ticks) +# +# Populate: phase II +# MIP emphasis: balance optimality and feasibility. +# MIP search method: dynamic search. +# Parallel mode: deterministic, using up to 12 threads. +# +# Nodes Cuts/ +# Node Left Objective IInf Best Integer Best Bound ItCnt Gap +# +# 0 2 95032.0000 1 95032.0000 95032.0000 10 0.00% +# Elapsed time = 1.38 sec. (1330.87 ticks, tree = 0.02 MB, solutions = 1) +# 13 11 95032.0000 1 95032.0000 95032.0000 1356 0.00% +# 14 13 95032.0000 177 95032.0000 95032.0000 682 0.00% +# 19 4 94942.0000 128 95032.0000 95032.0000 1596 0.00% +# 24 20 95032.0000 53 95032.0000 95032.0000 6009 0.00% +# 34 30 94942.0000 140 95032.0000 95032.0000 16312 0.00% +# 43 27 95032.0000 24 95032.0000 95032.0000 15340 0.00% +# * 55 48 integral 0 95032.0000 95032.0000 25086 0.00% +# 66 44 95032.0000 99 95032.0000 95032.0000 24510 0.00% +# 93 45 95032.0000 233 95032.0000 95032.0000 24470 0.00% +# 305 223 95032.0000 183 95032.0000 95032.0000 36558 0.00% +# Elapsed time = 10.47 sec. (4704.46 ticks, tree = 4.12 MB, solutions = 13) +# 469 362 94966.0000 360 95032.0000 95032.0000 47180 0.00% +# +# Root node processing (before b&c): +# Real time = 0.06 sec. (60.42 ticks) +# Parallel b&c, 12 threads: +# Real time = 11.98 sec. (4799.58 ticks) +# Sync time (average) = 1.07 sec. +# Wait time (average) = 0.00 sec. +# ------------ +# Total (root+branch&cut) = 12.05 sec. (4860.00 ticks) +# +# * Solve status = 'populate solution limit exceeded' +# +# -- Objective value of the incumbent = 95032.00000000003 +# +# -- The solution pool contains 13 solutions. +# -- 11 solutions were removed due to the solution pool relative gap parameter. +# * Pool objective statistics +# count = 13 +# mean = 95003.38461538461 +# std = 42.955322897675096 +# min = 94936.0 +# med = 95032.0 +# max = 95032.00000000003 +# +# #solution objective #var diff. +# 1 95032 00 / 4440 +# 2 94936 122 / 4440 +# 3 95032 262 / 4440 +# 4 94942 258 / 4440 +# 5 95032 250 / 4440 +# 6 95032 182 / 4440 +# 7 95032 182 / 4440 +# 8 95032 268 / 4440 +# 9 94936 282 / 4440 +# 10 95032 262 / 4440 +# 11 94942 214 / 4440 +# 12 95032 80 / 4440 +# 13 95032 234 / 4440 +# +# Process finished with exit code 0