{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "
\n", " \n", " \"QuantEcon\"\n", " \n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Job Search II: Search and Separation\n", "\n", "\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Contents\n", "\n", "- [Job Search II: Search and Separation](#Job-Search-II:-Search-and-Separation) \n", " - [Overview](#Overview) \n", " - [The Model](#The-Model) \n", " - [Solving the Model using Dynamic Programming](#Solving-the-Model-using-Dynamic-Programming) \n", " - [Implementation](#Implementation) \n", " - [The Reservation Wage](#The-Reservation-Wage) \n", " - [Exercises](#Exercises) \n", " - [Solutions](#Solutions) " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Overview\n", "\n", "Previously [we looked](https://lectures.quantecon.org/mccall_model.html) at the McCall job search model [[McC70]](https://lectures.quantecon.org/zreferences.html#mccall1970) as a way of understanding unemployment and worker decisions\n", "\n", "One unrealistic feature of the model is that every job is permanent\n", "\n", "In this lecture we extend the McCall model by introducing job separation\n", "\n", "Once separation enters the picture, the agent comes to view\n", "\n", "- the loss of a job as a capital loss, and \n", "- a spell of unemployment as an *investment* in searching for an acceptable job " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Setup" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "hide-output": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\u001b[32m\u001b[1mActivated\u001b[0m /home/qebuild/repos/lecture-source-jl/_build/website/jupyter/Project.toml\u001b[39m\n", "\u001b[36m\u001b[1mInfo\u001b[0m quantecon-notebooks-julia 0.1.0 activated, 0.2.0 requested\u001b[39m\n" ] } ], "source": [ "using InstantiateFromURL\n", "github_project(\"QuantEcon/quantecon-notebooks-julia\", version = \"0.2.0\")" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "hide-output": true }, "outputs": [], "source": [ "using LinearAlgebra, Statistics\n", "using Distributions, Expectations, Parameters, NLsolve, Plots" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## The Model\n", "\n", "The model concerns the life of an infinitely lived worker and\n", "\n", "- the opportunities he or she (let’s say he to save one character) has to work at different wages \n", "- exogenous events that destroy his current job \n", "- his decision making process while unemployed \n", "\n", "\n", "The worker can be in one of two states: employed or unemployed\n", "\n", "He wants to maximize\n", "\n", "\n", "\n", "$$\n", "{\\mathbb E} \\sum_{t=0}^\\infty \\beta^t u(Y_t) \\tag{1}\n", "$$\n", "\n", "The only difference from the [baseline model](https://lectures.quantecon.org/mccall_model.html) is that\n", "we’ve added some flexibility over preferences by introducing a utility function $ u $\n", "\n", "It satisfies $ u'> 0 $ and $ u'' < 0 $" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Timing and Decisions\n", "\n", "Here’s what happens at the start of a given period in our model with search and separation\n", "\n", "If currently *employed*, the worker consumes his wage $ w $, receiving utility $ u(w) $\n", "\n", "If currently *unemployed*, he\n", "\n", "- receives and consumes unemployment compensation $ c $ \n", "- receives an offer to start work *next period* at a wage $ w' $ drawn from a known distribution $ p_1, \\ldots, p_n $ \n", "\n", "\n", "He can either accept or reject the offer\n", "\n", "If he accepts the offer, he enters next period employed with wage $ w' $\n", "\n", "If he rejects the offer, he enters next period unemployed\n", "\n", "When employed, the agent faces a constant probability $ \\alpha $ of becoming unemployed at the end of the period\n", "\n", "(Note: we do not allow for job search while employed—this topic is taken\n", "up in a [later lecture](https://lectures.quantecon.org/jv.html))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Solving the Model using Dynamic Programming\n", "\n", "Let\n", "\n", "- $ V(w) $ be the total lifetime value accruing to a worker who enters the current period *employed* with wage $ w $ \n", "- $ U $ be the total lifetime value accruing to a worker who is *unemployed* this period \n", "\n", "\n", "Here *value* means the value of the objective function [(1)](#equation-objective) when the worker makes optimal decisions at all future points in time\n", "\n", "Suppose for now that the worker can calculate the function $ V $ and the constant $ U $ and use them in his decision making\n", "\n", "Then $ V $ and $ U $ should satisfy\n", "\n", "\n", "\n", "$$\n", "V(w) = u(w) + \\beta [(1-\\alpha)V(w) + \\alpha U ] \\tag{2}\n", "$$\n", "\n", "and\n", "\n", "\n", "\n", "$$\n", "U = u(c) + \\beta \\sum_i \\max \\left\\{ U, V(w_i) \\right\\} p_i \\tag{3}\n", "$$\n", "\n", "Let’s interpret these two equations in light of the fact that today’s tomorrow is tomorrow’s today\n", "\n", "- The left hand sides of equations [(2)](#equation-bell1-mccall) and [(3)](#equation-bell2-mccall) are the values of a worker in a particular situation *today* \n", "- The right hand sides of the equations are the discounted (by $ \\beta $) expected values of the possible situations that worker can be in *tomorrow* \n", "- But *tomorrow* the worker can be in only one of the situations whose values *today* are on the left sides of our two equations \n", "\n", "\n", "Equation [(3)](#equation-bell2-mccall) incorporates the fact that a currently unemployed worker will maximize his own welfare\n", "\n", "In particular, if his next period wage offer is $ w' $, he will choose to remain unemployed unless $ U < V(w') $\n", "\n", "Equations [(2)](#equation-bell1-mccall) and [(3)](#equation-bell2-mccall) are the Bellman equations\n", "for this model\n", "\n", "Equations [(2)](#equation-bell1-mccall) and [(3)](#equation-bell2-mccall) provide enough information to solve out for both $ V $ and $ U $\n", "\n", "Before discussing this, however, let’s make a small extension to the model" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Stochastic Offers\n", "\n", "Let’s suppose now that unemployed workers don’t always receive job offers\n", "\n", "Instead, let’s suppose that unemployed workers only receive an offer with probability $ \\gamma $\n", "\n", "If our worker does receive an offer, the wage offer is drawn from $ p $ as before\n", "\n", "He either accepts or rejects the offer\n", "\n", "Otherwise the model is the same\n", "\n", "With some thought, you will be able to convince yourself that $ V $ and $ U $ should now satisfy\n", "\n", "\n", "\n", "$$\n", "V(w) = u(w) + \\beta [(1-\\alpha)V(w) + \\alpha U ] \\tag{4}\n", "$$\n", "\n", "and\n", "\n", "\n", "\n", "$$\n", "U = u(c) +\n", " \\beta (1 - \\gamma) U +\n", " \\beta \\gamma \\sum_i \\max \\left\\{ U, V(w_i) \\right\\} p_i \\tag{5}\n", "$$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Solving the Bellman Equations\n", "\n", "We’ll use the same iterative approach to solving the Bellman equations that we\n", "adopted in the [first job search lecture](https://lectures.quantecon.org/mccall_model.html)\n", "\n", "Here this amounts to\n", "\n", "1. make guesses for $ U $ and $ V $ \n", "1. plug these guesses into the right hand sides of [(4)](#equation-bell01-mccall) and [(5)](#equation-bell02-mccall) \n", "1. update the left hand sides from this rule and then repeat \n", "\n", "\n", "In other words, we are iterating using the rules\n", "\n", "\n", "\n", "$$\n", "V_{n+1} (w_i) = u(w_i) + \\beta [(1-\\alpha)V_n (w_i) + \\alpha U_n ] \\tag{6}\n", "$$\n", "\n", "and\n", "\n", "\n", "\n", "$$\n", "U_{n+1} = u(c) +\n", " \\beta (1 - \\gamma) U_n +\n", " \\beta \\gamma \\sum_i \\max \\{ U_n, V_n(w_i) \\} p_i \\tag{7}\n", "$$\n", "\n", "starting from some initial conditions $ U_0, V_0 $\n", "\n", "Formally, we can define a “Bellman operator” T which maps:\n", "\n", "\n", "\n", "$$\n", "TV(\\cdot) = u(\\cdot) + \\beta (1-\\alpha)V(\\cdot) + \\alpha U \\tag{8}\n", "$$\n", "\n", "In which case we are searching for a fixed point\n", "\n", "\n", "\n", "$$\n", "TV^{*} = V^* \\tag{9}\n", "$$\n", "\n", "As before, the system always converges to the true solutions—in this case,\n", "the $ V $ and $ U $ that solve [(4)](#equation-bell01-mccall) and [(5)](#equation-bell02-mccall)\n", "\n", "A proof can be obtained via the Banach contraction mapping theorem" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Implementation\n", "\n", "Let’s implement this iterative process" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "hide-output": false }, "outputs": [ { "data": { "text/plain": [ "solve_mccall_model (generic function with 1 method)" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "using Distributions, LinearAlgebra, Expectations, Parameters, NLsolve, Plots\n", "\n", "function solve_mccall_model(mcm; U_iv = 1.0, V_iv = ones(length(mcm.w)), tol = 1e-5,\n", " iter = 2_000)\n", " # α, β, σ, c, γ, w = mcm.α, mcm.β, mcm.σ, mcm.c, mcm.γ, mcm.w\n", " @unpack α, β, σ, c, γ, w, dist, u = mcm\n", "\n", " # parameter validation\n", " @assert c > 0.0\n", " @assert minimum(w) > 0.0 # perhaps not strictly necessary, but useful here\n", "\n", " # necessary objects\n", " u_w = u.(w, σ)\n", " u_c = u(c, σ)\n", " E = expectation(dist) # expectation operator for wage distribution\n", "\n", " # Bellman operator T. Fixed point is x* s.t. T(x*) = x*\n", " function T(x)\n", " V = x[1:end-1]\n", " U = x[end]\n", " [u_w + β * ((1 - α) * V .+ α * U); u_c + β * (1 - γ) * U + β * γ * E * max.(U, V)]\n", " end\n", "\n", " # value function iteration\n", " x_iv = [V_iv; U_iv] # initial x val\n", " xstar = fixedpoint(T, x_iv, iterations = iter, xtol = tol).zero\n", " V = xstar[1:end-1]\n", " U = xstar[end]\n", "\n", " # compute the reservation wage\n", " wbarindex = searchsortedfirst(V .- U, 0.0)\n", " if wbarindex >= length(w) # if this is true, you never want to accept\n", " w̄ = Inf\n", " else\n", " w̄ = w[wbarindex] # otherwise, return the number\n", " end\n", "\n", " # return a NamedTuple, so we can select values by name\n", " return (V = V, U = U, w̄ = w̄)\n", "end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The approach is to iterate until successive iterates are closer together than some small tolerance level\n", "\n", "We then return the current iterate as an approximate solution\n", "\n", "Let’s plot the approximate solutions $ U $ and $ V $ to see what they look like\n", "\n", "We’ll use the default parameterizations found in the code above" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "hide-output": false }, "outputs": [ { "data": { "text/plain": [ "#5 (generic function with 2 methods)" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# a default utility function\n", "u(c, σ) = (c^(1 - σ) - 1) / (1 - σ)\n", "\n", "# model constructor\n", "McCallModel = @with_kw (α = 0.2,\n", " β = 0.98, # discount rate\n", " γ = 0.7,\n", " c = 6.0, # unemployment compensation\n", " σ = 2.0,\n", " u = u, # utility function\n", " w = range(10, 20, length = 60), # wage values\n", " dist = BetaBinomial(59, 600, 400)) # distribution over wage values" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "hide-output": false }, "outputs": [ { "data": { "image/png": "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" }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# plots setting\n", "gr(fmt=:png);\n", "\n", "mcm = McCallModel()\n", "@unpack V, U = solve_mccall_model(mcm)\n", "U_vec = fill(U, length(mcm.w))\n", "\n", "plot(mcm.w, [V U_vec], lw = 2, α = 0.7, label = [\"V\" \"U\"])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The value $ V $ is increasing because higher $ w $ generates a higher wage flow conditional on staying employed\n", "\n", "At this point, it’s natural to ask how the model would respond if we perturbed the parameters\n", "\n", "These calculations, called comparative statics, are performed in the next section" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## The Reservation Wage\n", "\n", "Once $ V $ and $ U $ are known, the agent can use them to make decisions in the face of a given wage offer\n", "\n", "If $ V(w) > U $, then working at wage $ w $ is preferred to unemployment\n", "\n", "If $ V(w) < U $, then remaining unemployed will generate greater lifetime value\n", "\n", "Suppose in particular that $ V $ crosses $ U $ (as it does in the preceding figure)\n", "\n", "Then, since $ V $ is increasing, there is a unique smallest $ w $ in the set of possible wages such that $ V(w) \\geq U $\n", "\n", "We denote this wage $ \\bar w $ and call it the reservation wage\n", "\n", "Optimal behavior for the worker is characterized by $ \\bar w $\n", "\n", "- if the wage offer $ w $ in hand is greater than or equal to $ \\bar w $, then the worker accepts \n", "- if the wage offer $ w $ in hand is less than $ \\bar w $, then the worker rejects \n", "\n", "\n", "If $ V(w) < U $ for all $ w $, then the function returns np.inf\n", "\n", "Let’s use it to look at how the reservation wage varies with parameters\n", "\n", "In each instance below we’ll show you a figure and then ask you to reproduce it in the exercises" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### The Reservation Wage and Unemployment Compensation\n", "\n", "First, let’s look at how $ \\bar w $ varies with unemployment compensation\n", "\n", "In the figure below, we use the default parameters in the McCallModel tuple, apart from\n", "c (which takes the values given on the horizontal axis)\n", "\n", "\n", "\n", " \n", "As expected, higher unemployment compensation causes the worker to hold out for higher wages\n", "\n", "In effect, the cost of continuing job search is reduced" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### The Reservation Wage and Discounting\n", "\n", "Next let’s investigate how $ \\bar w $ varies with the discount rate\n", "\n", "The next figure plots the reservation wage associated with different values of\n", "$ \\beta $\n", "\n", "\n", "\n", " \n", "Again, the results are intuitive: More patient workers will hold out for higher wages" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### The Reservation Wage and Job Destruction\n", "\n", "Finally, let’s look at how $ \\bar w $ varies with the job separation rate $ \\alpha $\n", "\n", "Higher $ \\alpha $ translates to a greater chance that a worker will face termination in each period once employed\n", "\n", "\n", "\n", " \n", "Once more, the results are in line with our intuition\n", "\n", "If the separation rate is high, then the benefit of holding out for a higher wage falls\n", "\n", "Hence the reservation wage is lower" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Exercises" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exercise 1\n", "\n", "Reproduce all the reservation wage figures shown above" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exercise 2\n", "\n", "Plot the reservation wage against the job offer rate $ \\gamma $\n", "\n", "Use" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "hide-output": false }, "outputs": [ { "data": { "text/plain": [ "0.05:0.0375:0.95" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "γ_vals = range(0.05, 0.95, length = 25)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Interpret your results" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Solutions" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exercise 1\n", "\n", "Using the solve_mccall_model function mentioned earlier in the lecture,\n", "we can create an array for reservation wages for different values of $ c $,\n", "$ \\beta $ and $ \\alpha $ and plot the results like so" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "hide-output": false }, "outputs": [ { "data": { "image/png": "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" }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "c_vals = range(2, 12, length = 25)\n", "\n", "models = [McCallModel(c = cval) for cval in c_vals]\n", "sols = solve_mccall_model.(models)\n", "w̄_vals = [sol.w̄ for sol in sols]\n", "\n", "plot(c_vals,\n", " w̄_vals,\n", " lw = 2,\n", " α = 0.7,\n", " xlabel = \"unemployment compensation\",\n", " ylabel = \"reservation wage\",\n", " label = \"w̄ as a function of c\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that we could’ve done the above in one pass (which would be important if, for example, the parameter space was quite large)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "hide-output": false }, "outputs": [], "source": [ "w̄_vals = [solve_mccall_model(McCallModel(c = cval)).w̄ for cval in c_vals];\n", "# doesn't allocate new arrays for models and solutions" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exercise 2\n", "\n", "Similar to above, we can plot $ \\bar w $ against $ \\gamma $ as follows" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "hide-output": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAGQCAIAAAD9V4nPAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nO3de1wU9f4/8PfMsNxvcl+ImwqKKOAtjdL067UML9/jqTSz+paZZZYeFTPhlHetk1qnq4V5+Wl2UbOjWamop9I0xRsC4l1hud9ZkN2Zz++PPe0hBFxgd2cvr+fDP3Znhpk3I7Ov/cx85jMcY4wAAADsFS93AQAAAHJCEAIAgF1DEAIAgF1DEAIAgF1DEAIAgF1DEAIAgF1DEAIAgF1DEAIAgF1DEAIAgF1DEAIAgF2zyiDMyspqaGiQuwpLp9Fo5C7BRkiSJIqi3FXYCK1Wi2EdjYIxptVq5a7CRlhlED788MN5eXlyV2HpSkpK5C7BRtTX19fU1MhdhY2oqKjAx7dRaLXaiooKuauwEVYZhAAAAMaCIAQAALuGIAQAALuGIAQAALuGIAQAALuGIAQAALuGIAQAALvmIHcBAABgR2o1bN+tDg2rMFjJBbhwxqsIQQgAAOYiMXrrrHSypEOjC0V7CwEuxqqICEEIAABmk5YjnixhXo404p72X5jzdzZiRUQIQgAAMI8DedK315kDzyXH8718jHlus4PQWQYAAEwuq4K9f0EiohdiOItKQUIQAgCAqRXVsWUZokaiCRH8qA6cFDURiysIAABsSb1ISzLEygbq48c9HW2JoWOJNQEAgG1gRG+fFa9V0z1u3Px4gbesc6L/gSAEAABT2XRR+q2IeSi41D6Cm6X2zkQQAgCASaTns6+vSg48tyCBV7rKXU3LEIQAAGB8l6rYPzNFIprWjYuzsG6iTSAIAQDAyMpu09IMsUGiR8L4h8MsPWgs9ZQtAFiViRMnXr58+a6LiaLI8zzHWXT7wCowxiRJEgRB7kKawYjKb5NGYo48d8uJPjLSaocOHfrOO+8YaWV/giAEACPIyspavHhx586d5S4EbNOhQ4cOHz5sopUjCAHAOLp37x4bGyt3FWCbrl+/brogtPRTtwAAACaFIAQAALuGIAQAALuGIAQAALuGIAQAALuGIAQA+6LRaJYvX56ZmSl3IWApEIQAYF8UCsXgwYPnzp3LGJO7FrAICEIAsDsPPPDAunXr6uvr5S4ELAKCEADsUbdu3VxcXEy3/pSUlKCgoA6uxLhj0RmlJJuEIAQAML4PP/zw/Pnz7f7x4cOHE1FycrLxKupoSTYMQQgAYHylpaV+fn7t/vEDBw4Q0cqVK41XUUdLsmEIQgAwiVoNu1Jlpn9Fd1zsS0xM3LNnDxElJyf7+flJksQYCw4OzsjIaL3s3bt3JyQkeHt7K5XKt99+m4jS0tKUSqWfn9+7777b+pJ648ePJ6KEhITG5zZ1rzmO++KLL+Lj4319fdeuXUtEJSUlEydO9Pf379at2zfffHPnj5eVlU2dOlWpVAYHBz/11FNlZWXNrkev2eX169QvVlVV9eyzzwYFBXXr1m3jxo0cx935G3Ect3DhQqVSuXjx4jfeeCM6OtrLy2v58uWtz2plz1gmzhr7TUVGRh48eDAyMlLuQiyaSqVSKpVyV2EL1Gq1RqPx8vKSuxCLFhsb++WXXzYedPvnAmnVGck8W78/kFuQ8KcHEi1fvryoqGjt2rUDBgwoLCzctWuXk5PTyJEjb9y4oQ+kZj/94uPjn3zyydmzZ589e3bgwIG3b9/u1KnTkSNHnJycXnrppZ9++qmVJRuvR7f+xlvRT1m1atW8efPS09MfeeQRtVr95JNPKpXK5cuXHz16dPz48fn5+U5OTo1/fOrUqY6Oju+99x4RzZo1S6vVbtiw4c716Dfd7PJ3/srTp0/XarXvvfcez/OvvPLKJ598EhcX1+Q34jhu69atPXv2jIuLW7NmzYsvvnj48OGxY8fW1dW1Mqv1PdM+u3bt+vzzz3ft2tXxVd3JTEEoimJsbGx2drbu7Y4dO1JTU2/duhUXF/fpp59GR0frppeXl0+dOvWXX3554IEHNm7c2KlTp2bXhiA0BILQWBCEhrgzCE+XsrQcMwVhb1/umW5/Or919uzZSZMmHT16dODAgePGjfPz83NycsrMzPzwww91C7QUhJIknThxIjMz8/Dhw5s2bWKMjRs3TpKkqVOnTpgwwcHBoZUlG6+nlSCsqqry8PDQT/Hz88vJyfH19SWisrIyLy8vQRAa/7ifn9+FCxcCAgKIqLCwMC4urrCw8M716Dfd7PJ3LhYYGHju3Dn9YkFBQaIoNvmNOI67ffu2QqHgeV6j0Tg4ODDGeJ5vfVbre6Z9TBqExExv7dq19957r35bV65c8fDw+O2339Rq9erVqxMTE/VLJicnv/TSS/X19S+99NKCBQtaWmFERMSVK1dMXreVy8/Pl7sEG1FbW1tRUSF3FZauR48e58+fl7uK/5IkKTQ0dP369c8///z+/fsfeuih8ePH7927V79AS59+f/nLXyZNmrR79+68vDz64/m3+/bte/zxx4cPH976ko3ppuinV1VVNZmif+3t7V1WVqabkpmZWVNT0+THfX19i4qKdAsUFhb6+vo2ux69ZpdvfbHi4mIiuvM30v/InZtrZVbre6Z9du7cOW7cOKOs6k7mCMKDBw9+9913+t2xf//+6dOn614XFRXp/5MYY9HR0VlZWYyxrKys6OjollaIIDQEgtBYEISGsLQgZIzNmDEjNDR069atarXaz8/vnnvuqaur089t6QPa09Pz/PnzkiR99tlnRKTRaMLDw3Nyci5cuNCpU6fWl2w8V7d+JyengwcPSpK0atWqloJw4sSJr732mlarPXbsmJubmy4UiaihoUG3wJQpU6ZNm1ZXV6dWq5977rknn3yy2fXoNbv8nYs99dRTzz33nFqtrqurmzFjBhHd+Ru1Lwhb3zPtY9IgNMeDeYcOHdr47bBhw4YNG0ZEoiimpqY+9thj+ll5eXnh4eFEFB4erlKpWlphTU1NfHw8zzft6fPcc8/NmzfPmKVbs+Li4jt3EbRDXV2dRqPBzdetkyQznQU13COPPPLhhx8OGTLExcUlISHB3d3d2dn5rj+1fPnyIUOGBAYGPvXUU6NGjXr66afnz59/3333OTg4vPXWW60vuWXLliZrW7p06V/+8peQkJC5c+e2tMX33ntv2rRpAQEBXl5eGzZs0F0Sevjhh7t06aJbYO3ata+++mpERATHcSNHjmzSNeZOBi6/Zs2aWbNmhYaGBgYGvvbaa1u3bl22bFmT3+hue6t5huyZdmhoaNCd420TX1/fxie0m2W+zjJNTk//+OOPycnJo0aNWrp0qb5KNze30tJSZ2dntVrt7+9fW1vb7KoiIiK++eYbXWQ25uLiYtI7ZK0LrhEaC64RGqJXr15NrhGChdu9e3d8fLzugzQnJycpKenixYtyF9WiXbt2bdiwYefOnW39QUPaA+ZoETbBGEtOTj569Oj27dv13WR0goODb968GRUVlZeXFxIS0tIaOI7z8fHBDTGt43keLUKj4P8gdyEAxvTzzz+vX7/+s88+02g0ycnJEydOlLuiu+A4zkSHoQzH9pEjR3bv3v3dd98FBwfX1NTU1NQQ0aFDh4goKSkpLS2NMZaWljZu3Djz1wYAYCdSU1O9vb2jo6P79esXGBi4cOFCuSuSjQwtwkOHDuXk5DS+NYIxNnToUMZYamrqE088ERoa2qdPn82bN5u/NgAAO+Hu7o6PWR3ztQj1Fwj//ve/N+mxo5/r7e29Z8+eW7du7d69G5dkAADADHDZAwAA7BqCEAAA7BqCEAAA7BqCEAAA7BqCEAAA7JoMt08AgO1xcXFZsWKFj4+P3IVA+4mMJEYckYPlNZGuXLly15HS2g1BCABG8MUXX+zdu/eui9XW1jo7OwuCcNcloXWiKNbX17u5uRlrhceK2Nky5szT+AjO05G7+w+YV9euXfWDrxodghAAjKBr166zZs2662IlJSVeXl4KhcIMJdk2jUZTWVlprJEmD+RJP52XonhucV++l4/FpaCpWV4DGAAAzCirgr1/QSKi6d05O0xBQhACANizojq2LEPUSDQ+gh8daqeJYKe/NgAA1Iu0JEOsbKA+ftzT0fYbB/b7mwMA2DNG9PZZ8Vo13ePGzY8XBHs8J/ofCEIAAHu06aL0WxHzUHApfXg3++43ad+/PQCAdVKp2bFCB886qX0/XlxP31yTHHhuQQIf7GrHjUEiQhACAFidag1bcpq7UeXo6NjOINR5PoaLs8tuok0gCAEArInIaNUZSVVHIS5S3+D2X94KcaWH7LWbaBMIQgAAa/JJlnimlHk70oLuDdHB7nKXYwsQhAAAVuOnPLb3JnMUuNfimQ/r0HlR0EO7GADAOpwvYx9kihxHL8dy0Z5yV2NDEIQAAFagsI5WnBG1jP4ayQ9R4qPbmLA3AQAsXZ1Ii09pqxpoYAA3JQqf20aGHQoAYNEY0VtnxBs1FOpGs3vZ8wgwpoIgBACwaJ/lSCeKmYeCUvsIrujgaALYqQAAlutAPvv2muTAcwt780F2PwSMiaBFCABgobIq2PuZIhG9EMP17IQUNBUEIQCAJSqqJ92TAidEcKPuwWe1CWHnAgBYnHqRlpzSPylQkLscG4cgBACwLH88KZDpnhTI45yoiSEIAQAsy6bc/zwpMLWPYOdPCjQPBCEAgAVJz2dfX/nPkwKVrnJXYx8QhAAAliK3kv0zUySi57vjSYHmgyAEALAIZbdp2WmxQaKkMB5PCjQn7GsAAPk1SLQ0QyytpwRf7tnu+GQ2K+xuAACZMUZrz4m5lSzEjUuOFzCcqJkhCAEAZLb1svTvAubqQAsTBHeF3NXYHwQhAICcfi1k269IPEfz4oQwd7mrsUsIQgAA2VyuYu+cExmj57rx/fxxSlQeCEIAAHmU3WZLM6TbIo0I4ZPC8WksG+x6AAAZNEi0NEMqqWe9fLgXe6AtKCeM3gMAYG6M0brzUm4lU7pyryUIDmiSyAq7HwDA3L68Kh1RSa4OlNJH8EA3UbkhCAEAzOpoIft/uRJHNDdOCHWTuxpAEAIAmNMVXTdRome68f3RTdQyIAgBAMykooGWZoj1Ig0L4SdE4OPXUuB/AgDAHLSMVp0Ri+spxpt7qQc+ey0I/jMAAMzhwwvi+TIW4MK93ltQ4KPXkuB/AwDA5L6+Iv14izkLlNJb8HKUuxr4MwQhAIBpnSyWNl+SOI5e6SlEeMhdDdwBQQgAYEI3a9hb55jE6Mmu/ANB6CZqiRCEAACmUq2hJRlSrYY9EMRPjMTnrYXCEGsAACahldjK05JKzbp6cq/25Dm0Bi0VvqEAAJjEx1nS2TLm40SLegtOgtzVQMsQhAAAxvftdbbvFnPkaVFvwddZ7mqgVQhCAAAjyyhlG3JEjqNXevJRXjglaukQhAAAxpSnplWnRZHRpC78YCU+Y60AOssAABhNtYYtPinVaikxkH+8M1LQOuD/CQDAOERGq85I+WrW2YNm90I3UauBFiEAgHF8kiWeKWWdnLiUPoIzuolaD7QIAQCM4Kc8tvcmcxS413vzfugmalUQhAAAHXW+jH2QKXIcvRzLdUM3UWuDIAQA6JDCOlpxRtQy+mskPwTdRK0Q/s8AANpPraXFp7RVDTQwgJsShU9Uq4T/NgCAdpIYvX1WulFDoW40u5eAU6JWCr1GAcB+5VSyq1Ws3T9+oYJOFEtejvRGX8EVn6ZWC/91AGCnrlWzlBNindihlSh4er23EOCC1qAVM2sQiqIYGxubnZ3d5LVeYmLi0aNHda+nT5/+0UcfmbM8ALAflQ1sySmxTqSePtw9bu2Psd6+XIw3UtC6mS8I161bt3Xr1pycnCav9RhjOTk5KpXK3d2diBwc0FoFAJPQSmzVGamonrp6cm/2FRzRWcK+mS9s4uLiunTpkpSU1OS1nkql0mq1Y8aMuXjx4rBhwz755BNn5+bvSpUkKTc3V61WN5nu6+vr7+9vovqtjiiKotixkz5ARH/sSexMo9DtSZ6XOXk+zGJnS5mPE70WxwnMKv9v8WdpIJ7nubsNdscx1v4Lxe3Acf/dYuPXRHTy5Ml58+a98847YWFhs2fPbmho2LZtW7MrCQgIcHV1VSgUTaZPnjz5pZdeMlHlVqewsDAwMFDuKmxBXV2dRqPx9PSUuxBbUFZW5uHhcefBa07fqxT/77qjI0+LetR1dpdkrKQjNBpNdXW1j4+P3IVYOh8fn7ueXzQ0CC9dupSamnrkyJHS0tKMjIytW7cmJSX179+/rTW1EoSNqVSq2NjYsrKyZudGRkYePHgwMjKyrVu3KyqVSqlUyl2FLVCr1RqNxsvLS+5CbEFJSYmXl5eMQZhRyt48KUpE8+KEQUFWfG1Po9FUVlb6+fnJXYgtMOgERW5ubv/+/b/77rs+ffrU19cT0fHjx4cMGXLy5EkjlnLy5Mlff/1V99rR0dHJycmIKwcAuFXLdE8KnNyFt+oUBOMyKAhTU1Pd3NwyMzN3796tm7Jjx47o6Ohly5YZpYhDhw4RUW1t7YQJE7KyshoaGpYsWTJ+/HijrBwAgIiqNWzJKd2TArnH8KRAaMSgv4YDBw7MnTs3LCxMP8XV1XXy5MnHjh0zShFDhw4lokGDBqWkpCQlJYWEhJSXl69atcooKwcA+POTAgU8KRAaM6jXqEajufNqU0hISE1NTVu31/iioP617gXHcTNnzpw5c2Zb1wkA0LpPsqU/nhTI40mB0IRBLcL77rtv7969TSb+8MMP8fHxJigJAMCY9tyQ9t6QHAXu9QTezxmNQWjKoBbh2rVrBwwY8OKLL06aNImIzp8/v3nz5i1btqSnp5u4PACADjlfxj7Nlv7zpEAMAQPNMahFGB0dff78eQcHhxkzZri6ur788sunTp369ddfBw8ebOr6AADaTf+kwEfxpEBomaEjy4SEhLz77rsmLQUAwIgaPynwCTwpEFpm0B8H1xyFQhEYGBgTE/Pss88eP37c1IUCABhO/6TASA/ub3F4UiC0xqAgPHr0aHh4+BNPPPGvf/3r1KlT33///dSpUzt37vz111+vWbPGw8Nj0KBB+/fvN3WtAAAG+ixHOlEseTrSwgR0E4W7MOjU6Jo1a4YPH/7pp5/qp4wePfq5557bsGFDWlra6NGjfX1933jjjeHDh5usTgAAQ+3PY7uvSw4891oCH+SK1iDchUEtwv37948cObLJxBEjRvzrX//SvR45cuTZs2eNXBoAQNtdKGfvZ4pENCOG79kJKQh3Z1AQhoSE/P77700mnjhxQj/e6/nz5wMCAoxcGgBAGxXV0/LTkpbR/0bwI+9BCoJBDDo1+tprrz355JPu7u5TpkwJDg5WqVRbtmxZs2ZNWlpabW3thg0bUlJSFi5caOpaAQBaUSfSklNiZQPr688/FY1uomAog4Jw0qRJbm5uixcvfuONN3TDocXGxm7btu3RRx/Nzc3duHHjsmXLXnjhBROXCgDQIkb0j7PitWoW6s7N68XxaA2CwQy9j3Ds2LFjx469ffu2SqUKDAx0cXERRbG2tjYqKurEiRMmLREA4K4+z5F+K2IeCkrpLbjJ+dxfsD5tO3vg5OQUERHh4uJCRD/88ENoaKhpqgIAaIP0fLbjmuTAcwsSBKWr3NWAtTEoCHNycvr06cPzfOMb6seMGdOOJ9QDABhXVgV7L1MkoukxfJwPTolCmxkUhH/72994nj9x4sSjjz765JNPXrhwYfPmzUFBQdu3bzd1fQAArSiup+UZokaiseH8aHQThXYxKAiPHTs2efLkvn37Tps2raCgICYmZsqUKRMnTly8eLGp6wMAaEmDRCtOixUNlODL/V83dBOFdjLoT6e2tjYkJISIEhISTp8+res4Onr06H379pm2OgCAFjBGa86JuZUsxJUWJAgYThTazaAgjIiIyMjIICI/Pz9BEM6dO0dEWq32+vXrpq0OAKAFWy5JPxcwdwWl9BHcDO3/DtAMg4Jw5MiRH3zwwcaNG4novvvu+/DDDysrK7dt2xYbG2vi8gAAmvFLIfvqqsRzNDdOCHFDYxA6xKAgXLRo0T333LNhwwYiWrNmzf79+729vdPT09euXWvi8gAAmrpcxdacExmj57vzff2QgtBRBp1QePPNN1euXBkfH09E4eHhFy9eLCgo8Pf3d3DA+QgAMKuy22xphnRbpBEh/JgwdJABIzAoyT7//PP333/f0dHxwQcfHD169EMPPdS9e3eOwxcxADCrBomWZUgl9Sy2E/diLFIQjMOgv6Ty8vJjx44tWbJEoVC8+eabPXr0iIiIeOGFF3bt2mXq+gAAdBijdefEi5Us0IUWJggO+CoORmJQECoUigEDBsyfP3/Pnj1lZWX79u0LDw//+OOPJ0yYYOr6AAB0tl+RjhQwF4FS+giejnJXAzbE0It8+fn5//73vw8fPnzkyJHMzExBEAYMGDBkyBBT1gYA8B+/FkpbL0kc0bx4IdwdjUEwJoOCMCoq6tKlSw4ODv379x87duw//vGP+++/393d3dTFAQAQ0ZUqtuacxIie6y7090cKgpEZFISXLl0iovvvv3/UqFGDBg3q16+fs7OziQsDACAiqmigJRlivUjDQvhx4UhBMD6DrhEWFxfv3LmzX79+u3btGjp0qJeX16BBg1577bW9e/eauj4AsGcNIluWIZbUU4w391IPdBMFkzDoD8vPz2/8+PFvv/32b7/9VlFR8c0333Act3LlyjFjxpi6PgCwZx9lSdkVLMCFe723oEAOgmkY2lmmrq7u2LFj6enphw4dOnbsmEajiY+PHz16tEmLAwB79vVV6ac85ixQSm/BC91EwWQMCsIhQ4YcPXq0oaHB19d3xIgR69evHzlypFKpNHVxAGC3TpawzbkSRzQ3TojwkLsasGkGBaFGo1m0aNGoUaP69u0rCIKpawIAO3ezlt46K0mMnormBwSggwyYlkFB+Msvv5i6DgAAnWoNLTkl1mrY0GBuYiQuDILJYdRsALAgWomtOC2p1KyrJzczFuefwBzwbQsALMjH2excGfNxokW9BUd8PoFZ4A8NACzFrmvSvpuSI0+Legu+GLQDzAVBCAAWIaOUfX5R4jh6tZcQ5YUOMmA+CEIAkN+tWrbqtCgymtyFHxSEFASzMigIs7OzBw4cKAgCdwdT1wcANq9aw5ackmq1lBjIPdYZ387B3AzqNTpjxoyKioqffvopODjY1AUBgF0RGa06I+WrWWcPmt1LwLdrMD+DgvD48eObNm36n//5H1NXAwD25pNs6Uwp83Gi1D4OzrhdAuRg0FmIyMhIT09PU5cCAPZmzw1p7w3JkafX0U0U5GNQEE6YMGHnzp2mLgUA7Mr5MvZptsRx9HJPPhrdREE+Bp0anTRp0syZM59//vnHH39cqVQ27iPTvXt3k9UGADarsI5WnBG1jB7rzA9RooMMyMmgIIyNjSWi9PT09evXN5nFGDN+UQBg09RaWnxKW9VAAwO4J6KQgiAzg/4E2R/q6+uvXr2qVqv1U0xdHwDYGInR22elGzUU6cH9LU7AKVGQnaHfxb766qv4+HgXF5fIyEhXV9devXp9/fXXJq0MAGzShlw6USx5OtLCBB7dRMESGBSEX3zxxeOPPz5+/PiLFy+q1epLly5NmDDh0Ucf/eqrr0xdHwDYksNFDv+6SQ4891qCEOSK1iBYBM6Q05t9+vQZMmTIO++803jiK6+88ssvv/z+++8mq61FkZGRBw8ejIyMNP+mrYhKpVIqlXJXYQvUarVGo/Hy8pK7EKt3oZzN+6WOc1DM6ukw8h6kYIdoNJrKyko/Pz+5C7EFBrUIL168eN999zWZmJiYmJOTY4KSAMAGFdXT8tOSltGEcEIKgkUxKAijoqKOHj3aZOKxY8eio6NNUBIA2Jo6kZacEisbWHwnaUoXuasB+DODbp9ITk6ePHmyp6fn1KlTg4OD8/PzN23atG7dum3btpm6PgCwdozo7TPitWoW6s7N7FLPc05yVwTwJwYF4eOPPy4IwuLFi998803dlNjY2C+++OLRRx81ZW0AYAs+z5GOFzMPBaX0FhRquasBuINBQUhEf/3rX//617/W1dUVFhYGBga6uLiYtCwAsA0H89mOa5IDzy1I4JWuVIIgBMtjaBDquLi4REREmKYSALA1WRXsn5kiEU2P4eN80EEGLFRrQZidne3j4xMQEJCdnd3SMhhrFACaVVxPyzNEjUTjIvjR6CYKFqy1IIyJiUlOTl65cmVMTExLy2CUNQC4U4NEK06LFQ2U4Ms9E43RRMGitRaE+pBD2gGA4RijNefE3EoW4koLEgQMJwoWzqBvahzHXbt2rcnEX3/91cfHx/gVAYCV23JJ+rmAuSsota/g1rZ+CAAyaO2PtLKyUqVS6V5fvny5vr6+8dz09HSNRmPC0gDACv1cIH11VRI4WhAvBGM0UbAGrQXhzp07n3nmGd3r4cOHN5mrUCjmzJljqroAwApdrmJrz0uM0fM9hHhfpCBYh9aC8Omnn3766aeJiOO4q1evNrlxQhTFJm1EALBnZbfZ0gzptkgjQriHQ5GCYDUMfTDvnbcP/vDDD6GhocavCACsUINEyzKkknoW24l7MRaPGQRrYlAQ5uTk9OnTh+d5rpExY8b079/f1PUBgOVjjNadEy9WskAXWpggOKA1CFbFoCD829/+xvP8iRMnHn300SeffPLChQubN28OCgravn27qesDAMv3xRXpSAFzESi1j4Ono9zVALSRQUF47NixyZMn9+3bd9q0aQUFBTExMVOmTJk4ceLixYvbuj1RFPWD0TR+rVNeXp6UlOTj4zN27Njy8vK2rhwAzO+XQrbtssRzlBzPh7nLXQ1A2xkUhLW1tSEhIUSUkJBw+vRp3f31o0eP3rdvX5s2tm7dOv3jfBu/1lu1alV4eLhKpQoLC1u9enWbVg4A5ne5iq05JzJG/9dN6OuPEWTAKhl0s2tERERGRsZjjz3m5+cnCMK5c+fi4uK0Wu3169fbtLG4uLguXbokJcvCyjwAAB3iSURBVCU1ea23c+fOb7/91snJaebMmePGjVuxYkWz69FoNFu2bPHz82syvWfPnn379m1TSTasrq5OrcZQ/0agVqu1Wq1CoZC7EItT0UBvnOTVDdyQQGmEf4Mhf251dXUKhQI7s+M0Gg2OcUM4Ozvz/F2+ohkUhCNHjvzggw9iYmKeeuqp++6778MPP1y5cuW2bdtiY2PbVNDQoUObfa2Xl5cXHh5ORLp2YUvrEUXx1KlT7u5Nz8K4urrGxcW1qSQbptFoMOKBUWi1WuzMOzWIbMU5x5J6ivYQ/6+zobsHe9JYNH+QuxBL5+R09wdBc4aMI1pcXPzggw8GBAQcOnTo+vXrw4cPv3TpUkBAwM6dOxMTE9taFsf9d6ONXxORm5tbaWmps7OzWq329/evra1tdg2RkZEHDx6MjIxs66btikqlUiqVcldhC9RqtUaj8fLykrsQy/LOOSk9Xwpw4d4ZKHgZ3EGmpKTEy8sLLcKO02g0lZWVd54Yg3YwqEXo5+d37tw5Xe+V8PDwixcvFhQU+Pv7OzgYeRjB4ODgmzdvRkVF5eXl6a5KAoAF+uqKlJ4vOQuU0rsNKQhgmQy6uB0VFbVs2bLq6mrdW47jlEqlcVPw0KFDRJSUlJSWlsYYS0tLGzdunBHXDwDGcrKEbbkkcURz44QID7mrAegwg4KwZ8+ey5cv79y585AhQ9LS0qqqqoxeh+6SYWpq6tmzZ0NDQzMzMxctWmT0rQBAB92spbfOShKjqVH8gADcOQ+2wKAg3LVrV1FR0ebNmz09PWfMmBEUFDRlypQff/xRFMV2bLLxRcEmjzz09vbes2fPrVu3du/ejUsyAJamWkNLTom1GjY0mJvYGTdLgI0w9E/Z09NzypQpu3fvLioq+uijjyoqKsaMGRMWFmbS4gDAcmgltuK0qFKzKC9uJkYTBRvS5u90RUVFBQUFJSUlWq22pqbGFDUBgAX6OJudK2M+TvR6guCI1iDYEEOfPnHq1KmUlJSePXtGR0cvXbq0a9eu3377bVFRkanrAwBLsPOatO+m5MjTot6Cr7Pc1QAYlaEjy9y4ccPNzS0pKWnp0qWjR492dsahAGAvTpWwzy9KHEev9hKivNBBBmyNQUE4cODAd95556GHHnJ1dTV1QQBgUW7VstVnRInRE135QUFIQbBBBgUhHrcEYJ+qNWzJKalWS4mB3GPoJgo2yqC/7MDAQDwLAsDeaCW28rSUr2ZdPLk5vQQOrUGwUQYF4YgRI9LT0w0ZlRQAbMb6HHa2jPk4cYt68064XQJsl0GnRufNmzd79uyJEyc+88wzERERjQdXa/JkXQCwDf+6Ie29ITkK3MIE3s8ZjUGwZQYFYUJCgu7Fjh07msxCMxHA9pwuZZ9mSxxHs2L5bt5IQbBxht5HmJubO2nSpJCQEGdn56ysrJSUlOPHjyMFAWxPgZq9dVYUGT3WmX9QiRQE22dQEObm5vbv3/+7777r06dPfX09ER0/fnzIkCEnT540cXkAYFZqLS3JEKsa6L5AbnJXdBMFu2DQH3pqaqqbm1tmZubu3bt1U3bs2BEdHb1s2TJT1gYAZiUxevusdKOGIj24Ob0ENAbBThgUhAcOHJg7d27jIbZdXV0nT5587NgxkxUGAOb2abZ0oljydqSUPoIzuomC3TAoCDUajVKpbDIxJCQEg24D2Iz9eey7G5IDR8nxgj+GUAR7YlAQ3nfffXv37m0y8YcffoiPjzdBSQBgbhfK2fuZIhHN6CH09ME5UbAvBt0+sXbt2gEDBrz44ouTJk0iovPnz2/evHnLli3p6ekmLg8ATK5AzZadFrWM/jeCH3kPUhDsjkEtwujo6PPnzzs4OMyYMcPV1fXll18+derUr7/+OnjwYFPXBwAmpe8m2t+fe7obuomCPTKoRUhESqVy8eLF7777LhHV19eXlZXdedUQAKwLI/rHWfFGDYW6c3/rxaMxCPbJoC+Ap06dCg8Pnzt3LhEdO3ZMqVSGhIT06tXr8uXLJi4PAExoQ454vJh5KCilt+CmQA6CnTIoCOfMmdOrV69169YR0fz584cPH15UVKRUKufMmWPi8gDAVA7ms53XmAPPLUgQlHjSKNgxg4Lw999/nzhxopubW3l5+c8//zxnzhx/f//JkycfOXLE1PUBgClkVbB/ZopEND2Gj0M3UbBvBgWhi4vL7du3iejQoUNubm79+vUjIp7nOTygDMAKFdfT8gxRI9G4CH40uomC3TMoCAcPHvzNN9+oVKp169Y98sgjCoWiqqpq06ZN9957r6nrAwDjapBoxWmxooESfLlnotFNFMCwXqNvvfXWmDFjgoODAwMDP/roIyLq3bu3QqH45ptvTFweABgTY7TmnJhbyUJcaUGCgOFEAcjAIOzcufOFCxfy8vL8/f2dnJyI6NixY35+fjg1CmBdtlySfi5g7gpK7Su4GXrzFICNM/TEyOXLl+fPn9+lSxcXF5fs7Oz33nvv999/N2llAGBcvxSyr65KAkcL4oVgV3yLBfgPPI8QwC5crmJrzomM0bTufLwvUhDgv/A8QgDbV3abLc2Qbos0IoQbE4YOMgB/gucRAti4BomWZUgl9Sy2E/diLB4zCNAUnkcIYMsYo3XnxIuVLNCFFiYIDjgnCnAHPI8QwJZtvyIdKWAuAqX0ETwd5a4GwCLheYQANuvXQmnrJYkjmhcvhLujMQjQPDyPEMA2Xalia85JjOjZ7kJ/f6QgQIsMvaU2JCRE9zBCALB8FQ20JEOsF2lYCD8uHCkI0BqDWoSBgYGrV682dSkAYBQNIluWIZbUU4w391IP3CwBcBcGHSQjRoxIT09njJm6GgDouI+ypOwKFuDCvd5bUCAHAe7GoFOj8+bNmz179sSJE5955pmIiAgHh//+VPfu3U1WGwC02ddXpZ/ymLNAKb0FL3QTBTCAQUGYkJCge7Fjx44ms9BMBLAcJ0vY5lyJI5obJ0R4yF0NgJUwKAiRdgCW72YtvXVWkhg9Fc0PCEAHGQBD4QICgC2o1tCSU2Kthg0N5iZG4rgGaAMcMABWT8toWYaoUrNuXtxMdBMFaCMcMwBW74NMMbOc+TnT6715Rzx1HqCNEIQA1m3XNemnPObI08IEoZMTUhCgzRCEAFYso5R9flHiOHq1lxDlhRQEaA8EIYC1ylPTqtOiyGhyF35QEFIQoJ0MHWsUACxKtYYtPinVaikxkHusM77RArQfjh8A6yMyWnVGylezzh40u5fAoTUI0AFoEQJYn0+ypTOlrJMTl9KHdxbkrgbAyqFFCGBl9tyQ9t6QHAXu9QTezxmNQYCOQhACWJPzZezTbInj6OVYrps3UhDACBCEAFajsI5WnBG1jB6N5IcocfACGAeOJQDroNbS4lPaqgYaGMA9EYUjF8BocDgBWAGJ0dtnpRs1FOnB/S0Oo6gBGBOCEMAKfJYjnSiWPB1pYQK6iQIYGW6fALB0B/LZ7uuSA8+9lsAHuaI1CGBkaBECWLQL5ez9TJGIZsTwPTshBQGMD0EIYLmK6mn5aUkj0f9G8CPvQQoCmASCEMBC1Ym05JRY2cD6+vNPReNQBTAVHF0AlogR/eOseK2ahbpz83pxPFqDACaDzjIAlujzHOm3IuahoJTegptC7moAbBqCEMDipOezHdckB55bkMArXeWuBsDW4dQogGXJrmDvZYpEND2Gj/PBKVEAk0MQAliQ4npaliFqJBobzo9GN1EAszBTEIqi2L17d93r8vLypKQkHx+fsWPHlpeXN14sMTGR+8MLL7xgntoALESDRCtOixUNlODL/V83fEkFMBNzHGzr1q1LTEzMycnRvV21alV4eLhKpQoLC1u9erV+McZYTk6OSqWqrq6urq5eu3atGWoDsBCM0ZpzYm4lC3GlBQkChhMFMBtzBGFcXFxKSor+7c6dO2fOnOnk5DRz5swdO3bop6tUKq1WO2bMGKVSOWXKlKqqKjPUBmAh/t8l6ecC5q6glD6CGzqxAZgRxxgz05a4/2zL3d29uLjYxcWlrq4uMDBQH3gnT56cN2/eO++8ExYWNnv27IaGhm3btjW7KqVSOWDAAHd39ybTR4wYMX78eJP+FlakoKAgKChI7ipsQV1dnUaj8fT0NN0mfi0R3s0WeKLXemp7eUum25DsSktLPT09FQrcEdJRGo2mqqrK19dX7kIsnbu7uyDcZaB6Gb55MsY4jtO9EEVRP71v374HDx7UvV65cmVsbGxLaxAEoV+/fn5+fk2md+7cGQeYnkKhwN4wCo1GQ0Sm25lXqumTSwLH0bNRUh9/gciWny6h+IPchdgC7ElD6OKmdTIEYXBw8M2bN6OiovLy8kJCQvTTT548efv27cTERCJydHR0cnJqaQ0KheKJJ56IjIw0R7lWy8XFxdUV96AZh0ajMdHOLLvN/pEtaYmNDuP/1w4et6tWq11dXfHx3XEajcZ0f5b2RoYDLykpKS0tjTGWlpY2btw4Ijp06BAR1dbWTpgwISsrq6GhYcmSJTjJCTavQaJlGVJJPYvtxL0Ya/spCGCZZDj2UlNTz549GxoampmZuWjRIiIaOnQoEQ0aNCglJSUpKSkkJKS8vHzVqlXmrw3AbBijdefEi5Us0IUWJggO6CYKIBPznRrV98rx9vbes2fPnbM4jps5c+bMmTPNVhKAjLZfkY4UMBeBUvoIno5yVwNgx3A2BkAGvxZKWy9JHNG8eCHcHY1BADkhCAHM7UoVW3NOYkTPdhf6+yMFAWSGIAQwq/LbbEmGWC/SsBB+XDhSEEB+CEIA82kQ2bIMqaSeYry5l3rg6AOwCDgUAcznoywpp5IFuHCv9xYUOPgALAOORQAz+fqq9FMecxYopbfghW6iABYDQQhgDidL2OZciSOaGydEeMhdDQA0giAEMLmbtfTWWUliNDWKHxCADjIAlgVBCGBa1Rpackqs1bChwdzEzjjiACwOnnsGYEJaia04LanULMqLmxlry4+VALBe+H4KYEIfZ7NzZczHiV5PEBxxtAFYJByaAKay65q076bkyNOi3oKvs9zVAEALEIQAJnGqhH1+UeI4erWXEOWFDjIAlgtBCGB8t2rZ6jOiyGhyF35QEFIQwKIhCAGMrFrDlpySarWUGMg9hm6iABYPRymAMWkltuqMlK9mnT1oTi+BQ2sQwOLh9gkAY1qfw86UMh8nLqUP74TbJQCsAVqEAEbzrxvS3huSo8AtTOD9nNEYBLAOCEIA4yitp89yGMfRKz35bt5IQQCrgSAEMI59tyStxO4P5AajmyiAVUEQAhiByOinPImIHgnDMQVgZXDQAhjB0UJWWk+hbtQDJ0UBrA2CEMAI9tyQiCgpnMf9EgBWB0EI0FE3a1hmBXMR6EElDigA64PjFqCj9txkjNGwEN4V9+UCWCEEIUCH1IuUni8R0ehQnBUFsEoIQoAOOZgnqbXUy4cLd0cQAlglBCFAh3x/SyKih0NxKAFYKxy9AO2XWc6uVVMnJ25ggNylAEB7IQgB2m/vTUZEo+7hHHicFwWwVghCgHaqbGBHCyWBo1H3IAUBrBiCEKCd9t1iGokGBHB40ASAVUMQArSHxOjHW4zQTQbA+uEYBmiP48WsqI4Fu3JxPmgOAlg3BCFAe+y9IRHRmDAOg4sCWDsEIUCbqdR0upQ5CfQ/wTiCAKweDmOANttzQ2REQ4N5d4XcpQBAhyEIAdqmQaKD+UREo3HXBIBNQBACtM1hFavWsBhvrosnghDAFiAIAdrm+5sSET2EZ00A2AoEIUAb5FSw3Erm6Uj3ByIIAWwEghCgDfbelIhoZAjvKCAIAWwEghDAUNUa+rmQOKLRGE0GwIbgeAYw1I+3pAaR9ffnAl3kLgUAjAdBCGAQph9cNAxHDYBNwSENYJCTJSxfzYJcuT5+uDoIYFMQhAAG2fvHXROIQQAbgyAEuLuS29zJEqbgaVgwchDA1iAIAe7upwJBYjRYyXs5IggBbA2CEOAuNBKlF/BE9DBGkwGwRQhCgLs4WsxXabjOHhTthSAEsEEIQoC72JdHRPRIOA4WANuEYxugNVer2cUqzlVgg4NwsADYJhzbAK3Zc4MR0dAgyUmQuxQAMA0EIUCLajXssEriOBoeJMpdCwCYCoIQoEUH8lm9SPGdmNKFyV0LAJgKghCgeYzR3hsSEY0KRgoC2DIEIUDzzpSxPDX5OVNfXwQhgC1DEAI07/ubjIgeCuV53D0IYNMQhADNKLtNx4uZA0cj78ExAmDjcJADNOP7m5JWYomBnLej3KUAgIkhCAGaEhn9lCcR0Rg8gxfADuA4B2jqaCErracwd+rRCZcHAWwfghCgqT03JCJ6BM1BAPuAQx3gT27WsMwK5iLQg0ocHQB2wXyHuiiK3bt3170uLy9PSkry8fEZO3ZseXm5fpmWpgOYzZ6bjDEaFsK7OshdCgCYhZmCcN26dYmJiTk5Obq3q1atCg8PV6lUYWFhq1ev1i/W0nQA86gXKT1fIqLReAYvgN0w05feuLi4Ll26JCUl6d7u3Lnz22+/dXJymjlz5rhx41asWNH69I7Iq2VXq+1xZJDSMgdfTpK7CiuTXcHUWurZiQt3RxAC2AuOMfOFBMf9Z3Pu7u7FxcUuLi51dXWBgYFVVVW6BVqa3kRAQICLi4tCoWgy/YknnnjppZeaTNxX4LjlWtMl7UFDQ4OjI26Ca4+Xo24P8NXq39bV1Wk0Gk9PTxlLshllZWUeHh53HrzQVhqNprq62sfHR+5CLJ2Pj4+Dw12afPJcBmGMcRyneyGK4l2nN+Hi4vLpp5+GhIQ0me7j4+Pr69tkYjfGhtrlI3Sqqxs8PJzkrsL6KHga2dXJodG4amq1WqPReHl5yViVzWCMeXl5IQg7TqPRODg43PmJB03w/N2vAMoThMHBwTdv3oyKisrLy2ucZy1Nb4Ln+a5du0ZGRhqyrQGBNCDQCDVbHZWqXqnsJHcVtkAQBEmSBAFP5jUC4Q9yF2L1dH+T2JNGIU8H8aSkpLS0NMZYWlrauHHjiOjQoUPNTgcAADApeYIwNTX17NmzoaGhmZmZixYtIqKhQ4c2Ox0AAMCkzBqE+o453t7ee/bsuXXr1u7du3WXXnSz7pwO7TZhwgRz9oSyYd9///3atWvlrsJGzJ49W38bFXTEpUuXZs2aJXcVNgJjZ9is48ePIwiNorCw8PLly3JXYSPOnz9fXV0tdxW2oKam5ty5c3JXYSMQhAAAYNcQhAAAYNescjhFxpjuvnu5C7F0BQUFhtxDA62rqqqqq6srKCiQuxBboNFoSktLsTM7rrS0VKvVYk/elZ+f311vqDfryDLGMmvWrO3bt+tuvYeWqNVqV1dXuauwBVqtVpIkDNNjFPX19Y6Ojvh+1nGSJDU0NDg7O8tdiKU7cOBAbGxs68tYZRACAAAYC76XAQCAXUMQAgCAXUMQAgCAXUMQAgCAXUMQWr3y8vKkpCQfH5+xY8eWl5c3nrVjx46ePXt6e3sPHjz44sWLclVoRVrZmTrnz593c3Mzf2HWqKWdqdVqX3zxRX9///vvvz8vL0/GCq1ISzvz8OHDCQkJHh4eCQkJR44ckbFCq4YgtHqrVq0KDw9XqVRhYWGrV6/WT7969erTTz+dlpamUqmSkpKeeeYZGYu0Fi3tTJ2KioqnnnpKrVbLUpvVaWlnrl27tqqq6vr164mJiX//+99lrNCKtLQzp0yZ8vrrr5eVlS1cuHDKlCkyVmjdGFi56OjorKwsxlhWVlZ0dLR++v79+6dPn657XVRU5OvrK099VqWlnckYE0Vx7NixX3/9NY4aA7W0M3v37n369GnGWFVV1e+//y5bfValpZ3Zo0eP9evXl5WVffrppzExMfIVaN1wH6HVc3d3142zU1dXFxgYWFVV1WQBURRnzpzJ8/z7778vS4VWpJWduWzZsoqKirfeeovjcNQYpKWd6evrO23atE8++aRz584bNmzo1auXvHVahZZ25u+//96/f3/d6xMnTvTr10++Gq0YTo1aPcaYbpAdxpgoik3m/vjjj/369fPy8lq3bp0c1VmZlnbm/v37Dxw4sGLFCvlKsz4t7cyqqirGWGZm5ujRo6dNmyZfgdakpZ2ZnJw8f/78/Pz8efPmLViwQL4CrZxMLVEwmq5du168eJExdvHixaioKP10SZLmzZv3wAMP5OTkyFedlWlpZyYnJzc5cP7973/LV6Z1aGlnKpXK/Px8xphKpXJzc5OtPqvS0s50c3NTqVSMsZKSEnd3d9nqs3JoEVq9pKSktLQ0xlhaWtq4ceOI6NChQ0R05MiR3bt3f/fdd8HBwTU1NTU1NTIXag1a2pkrV67UHzNExBh74IEH5C3V8rW0M0eNGvX555/fvn37k08+wak8A7W0M+Pi4j777LOamppNmzbFx8fLXKX1kid/wXjKy8sffvjhkJCQpKSkiooK9scn9RtvvIH/67ZqaWc2hj1poJZ2pkqlGj58uJeX1+DBg3Nzc+Uu0zq0tDOzsrISExPd3d0TExN1vWmgHXDZHwAA7BpOjQIAgF1DEAIAgF1DEAIAgF1DEAIAgF1DEAIAgF1DEAIAgF1DEAIAgF1DEAIYAcdx2dnZrS+TnZ2tGy6yg/75z3/6+vq6uro2+9bUPv/888rKSvNsC8A8EIQARjBs2DCzRdGCBQuee+65gwcPNvvW1J555hmVSmWebQGYB0aWATCT7Oxs3RPjOrgejuOysrK6d+/e7FtTM/PmAMwALUIAI2hyanT79u19+/b18PDo16/f9u3bGy+Zm5s7cuRIb2/vnj17rl+/vpV1NrsS3cnVmJgY3Ysmb3XrHzNmjI+PT1BQ0OTJk3Nzc3WLnTlzZsqUKYGBgc0W32RucXHxK6+80qNHD1dX14CAgLFjx+bk5Ny5uWa3BWB1EIQARvbVV19NmjRp0KBBn3322QMPPDBp0iTdc+11Bg8e3K1bt/fff3/gwIHPP//8xo0b27SSq1evEtH+/ft1L5q8zcvLu/fee318fD744IPk5ORDhw4NGDDg8uXLRDR79uySkpI5c+Y0u7nGc0VRfPDBBzds2PDII4+kpaUlJyfn5+dPmjSpyeZa2RaAlZF50G8Am0BE+rH/e/bsmZqaqp+VkpISFxfHGMvKyiKihQsX6mfNmTOnW7duza6wpZU02VaTt7NmzXrhhRf0s65du+bm5qbLsAkTJkiS1FLxjecWFxfrglC/wIkTJziOa7K5lrbV7CYALBmCEMAI9PGgVquJ6PLly/pZubm5HMfV19frgvDSpUv6WboptbW1TdbWykpYq0EYGxt7+PDhxqtKSkoKCQkhou+++66V4luaW1JS8tNPPz322GP6L836zbW0rZa2AmCxHMzdAgWwaYWFhUQUHBysn6LLBn1PS10s6YSFhRFRcXFxeHi4gSuJiIhoZetXr1598MEHm0x0dnYmotZ/sMncGzduvPrqq8eOHdNqtfHx8Uqlsk3bArAuCEIAY9L1N8nPz+/cubNuSn5+vm769evXiSgvL69Lly66Wbdu3eJ5/s6YaWUlrW/d09Nz48aNPXv2bDI9JibGwaG1g73xXMbYsGHDhg0b9v3338fFxem6iW7evNnAbQFYHXSWATAmFxeX2NjYTZs26afo0sLFxUX3dsOGDfpZH3/8cd++fR0dHdu6kpYkJCScPn26+x/CwsJeffXVrVu3tulXKCgouHTp0qpVq+Lj43W9Q0+ePGmibQFYArQIAYwsNTV10qRJVVVVAwcOPHr06Lp167788kv93M2bN1dXV997773p6emfffbZ7t2727GSlvz973+///77b968OWrUqPz8/K1bt2ZnZy9ZsmTJkiWG1+/v7x8QEDB9+vRJkyYpFIp9+/Z99dVXRPT999+PHDlSoVB88803Q4cObWlbhm8IwFLIfI0SwCbQnzuwbNu2rXfv3m5ubr179/7yyy91E3VdYy5fvjxy5EgvL6+EhAT9rGY1u5I7t9Xk7eHDh++//353d/fAwMBx48adOHHizmVaL54x9ssvv/Tt29fFxaVbt26vvvpqeXm57t7Hmpqa+fPnu7u7d+rUqaVtAVgdjCwDYAQYbwXAeuEaIUBHaTQauUsAgPbDNUKADiktLd2yZQsReXp6yl0LALQHWoQAHbJx48bU1NT58+c3e7MdAFg+XCMEAAC7hhYhAADYNQQhAADYNQQhAADYNQQhAADYNQQhAADYtf8PjN6Y0fSgI/QAAAAASUVORK5CYII=" }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "γ_vals = range(0.05, 0.95, length = 25)\n", "\n", "models = [McCallModel(γ = γval) for γval in γ_vals]\n", "sols = solve_mccall_model.(models)\n", "w̄_vals = [sol.w̄ for sol in sols]\n", "\n", "plot(γ_vals, w̄_vals, lw = 2, α = 0.7, xlabel = \"job offer rate\",\n", " ylabel = \"reservation wage\", label = \"w̄ as a function of gamma\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As expected, the reservation wage increases in $ \\gamma $\n", "\n", "This is because higher $ \\gamma $ translates to a more favorable job\n", "search environment\n", "\n", "Hence workers are less willing to accept lower offers" ] } ], "metadata": { "filename": "mccall_model_with_separation.rst", "kernelspec": { "display_name": "Julia 1.2", "language": "julia", "name": "julia-1.2" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", "version": "1.2.0" }, "title": "Job Search II: Search and Separation" }, "nbformat": 4, "nbformat_minor": 2 }