Secret Santa SelectionEvery year my extended family does a "secret santa" gift exchange. Each person draws another person at random and then gets a gift for them. At first, none of my siblings were married, and so the draw was completely random. Then, as people got married, we added the restriction that spouses should not draw each others names. This restriction meant that we moved from using slips of paper on a hat to using a simple computer program to choose names. Then people began to complain when they would get the same person two years in a row, so the program was modified to keep some history and avoid given anyone a name in their recent history. This year, not everyone was participating, and so after removing names, and limiting the number of exclusions to four per person, I had data something like this:
This data can be stored as a nested list of strings for Maple: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print(); # input placeholderLUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYyLUkjbWlHRiQ2JVEncGVvcGxlRicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUkjbW9HRiQ2LVEifkYnL0YzUSdub3JtYWxGJy8lJmZlbmNlR1EmZmFsc2VGJy8lKnNlcGFyYXRvckdGPS8lKXN0cmV0Y2h5R0Y9LyUqc3ltbWV0cmljR0Y9LyUobGFyZ2VvcEdGPS8lLm1vdmFibGVsaW1pdHNHRj0vJSdhY2NlbnRHRj0vJSdsc3BhY2VHUSYwLjBlbUYnLyUncnNwYWNlR0ZMLUY2Ni1RKiZjb2xvbmVxO0YnRjlGO0Y+RkBGQkZERkZGSC9GS1EsMC4yNzc3Nzc4ZW1GJy9GTkZTRjUtSShtZmVuY2VkR0YkNiYtRiM2Ji1GLDYlUSRzZXFGJ0YvRjItRlY2JC1GIzYsLUYsNiVRInBGJ0YvRjItRlY2Ji1GIzYlLUkjbW5HRiQ2JFEiMUYnRjkvJStleGVjdXRhYmxlR0Y9RjlGOS8lJW9wZW5HUSJbRicvJSZjbG9zZUdRIl1GJy1GNjYtUSIsRidGOUY7L0Y/RjFGQEZCRkRGRkZIRkovRk5RLDAuMzMzMzMzM2VtRidGW29GNS1GNjYvUSNpbkYnLyUlYm9sZEdGMS9GM1ElYm9sZEYnLyUrZm9udHdlaWdodEdGanBGO0Y+RkBGQkZERkZGSEZKRk1GNS1GLDYlUS1yZXN0cmljdGlvbnNGJ0YvRjJGZm9GOUY5RmZvRjlGOUZob0ZbcC1GNjYtUSI7RidGOUY7RmFwRkBGQkZERkZGSEZKRlRGNS1JJ21zcGFjZUdGJDYmLyUnaGVpZ2h0R1EmMC4wZXhGJy8lJndpZHRoR0ZMLyUmZGVwdGhHRmhxLyUqbGluZWJyZWFrR1EobmV3bGluZUYnLUZkcTYmRmZxRmlxRltyL0ZeclElYXV0b0YnLUYsNiVRIm5GJ0YvRjJGTy1GLDYlUSVub3BzRidGL0YyLUZWNiQtRiM2JUYrRmZvRjlGOUZgcUZmb0Y5print(); # input placeholderThe very simple program I used is something like this the one below. It just simulates drawing names out of a hat and throwing away the whole draw and starting again if the restrictions are not met. When I ran it this year, I had to stop it after 10 minutes with no output (the code below stops after unsuccessfully trying LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYnLUkjbWlHRiQ2JVEibkYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1JI21vR0YkNi1RJyZzZG90O0YnL0YzUSdub3JtYWxGJy8lJmZlbmNlR1EmZmFsc2VGJy8lKnNlcGFyYXRvckdGPS8lKXN0cmV0Y2h5R0Y9LyUqc3ltbWV0cmljR0Y9LyUobGFyZ2VvcEdGPS8lLm1vdmFibGVsaW1pdHNHRj0vJSdhY2NlbnRHRj0vJSdsc3BhY2VHUSYwLjBlbUYnLyUncnNwYWNlR0ZMRistRjY2LVEiIUYnRjlGO0Y+RkBGQkZERkZGSC9GS1EsMC4xMTExMTExZW1GJy9GTkZTRjk= random draws).# Randomly Search For Match
foundmatch := false:
to n*(n!) while not foundmatch do
choice := Statistics:-Shuffle(people);
foundmatch := true;
for i to n do
if choice[i] = restrictions[i][1] then
foundmatch := false;
break; # my own name
end if;
if choice[i] in restrictions[i][2] then
foundmatch := false;
break; # a name in my history
end if;
end do; #check match
end do:
if foundmatch then
zip(`=`,people,choice);
else
"No Match Found";
end if;
JSFHSince it is completely random, I did not know for sure that there was no acceptable match, and that the program was just very unlucky.Maybe it would have been smarter to simulate drawing names one at a time and redrawing each until an acceptable name was found and only starting over if no acceptable matches remained. This program does not find a match either but it is still random, so it could also be getting very unlucky and missing a possible match.
# Randomly Match Each Name
foundmatch := false:
to (n!) while not foundmatch do
picked := {};
choice := NULL;
for i to n do
possibles := ([op({op(people)} minus picked minus {restrictions[i][1]} minus {op(restrictions[i][2])})]);
if nops(possibles) = 0 then
foundmatch := false;
break; # no match possible from here
end if;
p := RandomTools:-Generate(choose(possibles));
picked := picked union {p};
choice := choice, p;
foundmatch := true;
end do;
end do:
if foundmatch then
zip(`=`,people,[choice]);
else
"No Match Found";
end if;
Now, it would be possible to write and program to enumerate all possible matches, and if that collection were not empty, randomly choose a match. But, instead, I applied the GraphTheory package to the problem.A standard approach for this sort of thing is to create a bipartite graph with each person listed twice (once as a gifter once as giftee) with an edge representing each possible match. The following one line call builds such a graph using the first three letters of each name to label its gifter node and the same appended with a "2" for its gifter node.JSFHLUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYrLUkjbWlHRiQ2JVEiR0YnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1JI21vR0YkNi1RKiZjb2xvbmVxO0YnL0YzUSdub3JtYWxGJy8lJmZlbmNlR1EmZmFsc2VGJy8lKnNlcGFyYXRvckdGPS8lKXN0cmV0Y2h5R0Y9LyUqc3ltbWV0cmljR0Y9LyUobGFyZ2VvcEdGPS8lLm1vdmFibGVsaW1pdHNHRj0vJSdhY2NlbnRHRj0vJSdsc3BhY2VHUSwwLjI3Nzc3NzhlbUYnLyUncnNwYWNlR0ZMLUYsNiVRLEdyYXBoVGhlb3J5RidGL0YyLUY2Ni1RIzotRidGOUY7Rj5GQEZCRkRGRkZIL0ZLUSYwLjBlbUYnL0ZORlYtRiw2JVEmR3JhcGhGJ0YvRjItSShtZmVuY2VkR0YkNiQtRiM2JS1GZm42Ji1GIzYmLUYsNiVRJHNlcUYnRi9GMi1GZm42JC1GIzYtRl5vLUZmbjYkLUYjNi8tRmZuNiYtRiM2Ky1GLDYlUS1yZXN0cmljdGlvbnNGJ0YvRjItRmZuNiYtRiM2JS1GLDYlUSJpRidGL0YyLyUrZXhlY3V0YWJsZUdGPUY5RjkvJSVvcGVuR1EiW0YnLyUmY2xvc2VHUSJdRictRmZuNiYtRiM2JS1JI21uR0YkNiRRIjFGJ0Y5RmdwRjlGOUZpcEZccS1GZm42Ji1GIzYnRmNxLUY2Ni1RIy4uRidGOUY7Rj5GQEZCRkRGRkZIL0ZLUSwwLjIyMjIyMjJlbUYnRlctRmRxNiRRIjJGJ0Y5RmdwRjlGOUZpcEZccS1GNjYtUSIsRidGOUY7L0Y/RjFGQEZCRkRGRkZIRlUvRk5RLDAuMzMzMzMzM2VtRictRiw2JVEkY2F0RidGL0YyLUZmbjYkLUYjNiotRiw2JVEicEYnRi9GMkZncUZjci1GNjYtUSJ+RidGOUY7Rj5GQEZCRkRGRkZIRlVGVy1JI21zR0YkNiNGYnItRiw2I1EhRidGZ3BGOUY5RmdwRjlGOS9GanBRInxmckYnL0ZdcVEifGhyRidGY3JGYHNGY3MtRjY2L1EjaW5GJy8lJWJvbGRHRjEvRjNRJWJvbGRGJy8lK2ZvbnR3ZWlnaHRHRmZ0RjtGPkZARkJGREZGRkhGVUZXRmNzLUZmbjYmLUYjNiYtRiw2JVEjb3BGJ0YvRjItRmZuNiQtRiM2JS1GLDYlUSdwZW9wbGVGJ0YvRjJGZ3BGOUY5RmdwRjlGOUZcdEZedEZjcy1GNjYvUSZtaW51c0YnRmN0RmV0Rmd0RjtGPkZARkJGREZGRkhGVUZXRmNzLUZmbjYmLUYjNipGXXBGYHBGX3FGY3JGXXUtRmZuNiQtRiM2J0ZdcEZgcC1GZm42Ji1GIzYlRmByRmdwRjlGOUZpcEZccUZncEY5RjlGZ3BGOUY5Rlx0Rl50RmdwRjlGOUZjckZkcC1GNjYtUSI9RidGOUY7Rj5GQEZCRkRGRkZIRkpGTUZjcUZbci1GLDYlUSVub3BzRidGL0YyLUZmbjYkLUYjNiVGXXBGZ3BGOUY5RmdwRjlGOUZncEY5RjlGXHRGXnRGZ3BGOUY5LUY2Ni1RIjtGJ0Y5RjtGZnJGQEZCRkRGRkZIRlVGTUZncEY5print(); # input placeholderJust looking at the graph, it is not obvious that there are no matches:
LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYpLUkjbWlHRiQ2JVEsR3JhcGhUaGVvcnlGJy8lJ2l0YWxpY0dRJXRydWVGJy8lLG1hdGh2YXJpYW50R1EnaXRhbGljRictSSNtb0dGJDYtUSM6LUYnL0YzUSdub3JtYWxGJy8lJmZlbmNlR1EmZmFsc2VGJy8lKnNlcGFyYXRvckdGPS8lKXN0cmV0Y2h5R0Y9LyUqc3ltbWV0cmljR0Y9LyUobGFyZ2VvcEdGPS8lLm1vdmFibGVsaW1pdHNHRj0vJSdhY2NlbnRHRj0vJSdsc3BhY2VHUSYwLjBlbUYnLyUncnNwYWNlR0ZMLUYsNiVRKkRyYXdHcmFwaEYnRi9GMi1JKG1mZW5jZWRHRiQ2JC1GIzYpLUYsNiVRIkdGJ0YvRjItRjY2LVEiLEYnRjlGOy9GP0YxRkBGQkZERkZGSEZKL0ZOUSwwLjMzMzMzMzNlbUYnLUYsNiVRJnN0eWxlRidGL0YyLUY2Ni1RIj1GJ0Y5RjtGPkZARkJGREZGRkgvRktRLDAuMjc3Nzc3OGVtRicvRk5GYW8tRiw2JVEqYmlwYXJ0aXRlRidGL0YyLyUrZXhlY3V0YWJsZUdGPUY5RjktRjY2LVEiO0YnRjlGO0ZnbkZARkJGREZGRkhGSkZib0Zmb0Y5%;Fortunately, there is a command to search for the largest possible matching in a bipartite graph.
LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYtLUkjbWlHRiQ2JVEiQkYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1JI21vR0YkNi1RIn5GJy9GM1Enbm9ybWFsRicvJSZmZW5jZUdRJmZhbHNlRicvJSpzZXBhcmF0b3JHRj0vJSlzdHJldGNoeUdGPS8lKnN5bW1ldHJpY0dGPS8lKGxhcmdlb3BHRj0vJS5tb3ZhYmxlbGltaXRzR0Y9LyUnYWNjZW50R0Y9LyUnbHNwYWNlR1EmMC4wZW1GJy8lJ3JzcGFjZUdGTC1GNjYtUSomY29sb25lcTtGJ0Y5RjtGPkZARkJGREZGRkgvRktRLDAuMjc3Nzc3OGVtRicvRk5GU0Y1LUYsNiVRLEdyYXBoVGhlb3J5RidGL0YyLUY2Ni1RIzotRidGOUY7Rj5GQEZCRkRGRkZIRkpGTS1GLDYlUTJCaXBhcnRpdGVNYXRjaGluZ0YnRi9GMi1JKG1mZW5jZWRHRiQ2JC1GIzYlLUYsNiVRIkdGJ0YvRjIvJStleGVjdXRhYmxlR0Y9RjlGOS1GNjYtUSI7RidGOUY7L0Y/RjFGQEZCRkRGRkZIRkpGVEZgb0Y5print(); # input placeholder
The 7 in the output means that the largest matching in the graph is 7 edges. Since we have 8 people, that means it is not possible to match the people given the restrictions!
You can draw the matching, and see that it is, indeed, not full. Mia is not a giftee and Ryan is not a gifter.LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYvLUkjbWlHRiQ2JVEsR3JhcGhUaGVvcnlGJy8lJ2l0YWxpY0dRJXRydWVGJy8lLG1hdGh2YXJpYW50R1EnaXRhbGljRictSSNtb0dGJDYtUSM6LUYnL0YzUSdub3JtYWxGJy8lJmZlbmNlR1EmZmFsc2VGJy8lKnNlcGFyYXRvckdGPS8lKXN0cmV0Y2h5R0Y9LyUqc3ltbWV0cmljR0Y9LyUobGFyZ2VvcEdGPS8lLm1vdmFibGVsaW1pdHNHRj0vJSdhY2NlbnRHRj0vJSdsc3BhY2VHUSYwLjBlbUYnLyUncnNwYWNlR0ZMLUYsNiVRL0hpZ2hsaWdodEVkZ2VzRidGL0YyLUkobWZlbmNlZEdGJDYkLUYjNiktRiw2JVEiR0YnRi9GMi1GNjYtUSIsRidGOUY7L0Y/RjFGQEZCRkRGRkZIRkovRk5RLDAuMzMzMzMzM2VtRictRjY2LVEifkYnRjlGO0Y+RkBGQkZERkZGSEZKRk0tRiw2JVEiQkYnRi9GMi1GUzYmLUYjNiUtSSNtbkdGJDYkUSIyRidGOS8lK2V4ZWN1dGFibGVHRj1GOUY5LyUlb3BlbkdRIltGJy8lJmNsb3NlR1EiXUYnRmhvRjlGOS1GNjYtUSI7RidGOUY7RmduRkBGQkZERkZGSEZKL0ZOUSwwLjI3Nzc3NzhlbUYnLUknbXNwYWNlR0YkNiYvJSdoZWlnaHRHUSYwLjBleEYnLyUmd2lkdGhHRkwvJSZkZXB0aEdGanAvJSpsaW5lYnJlYWtHUShuZXdsaW5lRidGK0Y1LUYsNiVRKkRyYXdHcmFwaEYnRi9GMi1GUzYkLUYjNilGV0ZaLUYsNiVRJnN0eWxlRidGL0YyLUY2Ni1RIj1GJ0Y5RjtGPkZARkJGREZGRkgvRktGZHBGY3AtRiw2JVEqYmlwYXJ0aXRlRidGL0YyRmhvRjlGOUZgcEZob0Y5%;In this case, you can better see why it is not possible to generate a match by breaking the graph into its connected components.
LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYqLUkjbWlHRiQ2JVEsR3JhcGhUaGVvcnlGJy8lJ2l0YWxpY0dRJXRydWVGJy8lLG1hdGh2YXJpYW50R1EnaXRhbGljRictSSNtb0dGJDYtUSM6LUYnL0YzUSdub3JtYWxGJy8lJmZlbmNlR1EmZmFsc2VGJy8lKnNlcGFyYXRvckdGPS8lKXN0cmV0Y2h5R0Y9LyUqc3ltbWV0cmljR0Y9LyUobGFyZ2VvcEdGPS8lLm1vdmFibGVsaW1pdHNHRj0vJSdhY2NlbnRHRj0vJSdsc3BhY2VHUSYwLjBlbUYnLyUncnNwYWNlR0ZMLUYsNiVRNENvbm5lY3RlZENvbXBvbmVudHNGJ0YvRjItSShtZmVuY2VkR0YkNiQtRiM2JS1GLDYlUSJHRidGL0YyLyUrZXhlY3V0YWJsZUdGPUY5RjktRjY2LVEiO0YnRjlGOy9GP0YxRkBGQkZERkZGSEZKL0ZOUSwwLjI3Nzc3NzhlbUYnLUYsNiNRIUYnRlpGOQ==print(); # input placeholderLUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYpLUkjbWlHRiQ2JVEsR3JhcGhUaGVvcnlGJy8lJ2l0YWxpY0dRJXRydWVGJy8lLG1hdGh2YXJpYW50R1EnaXRhbGljRictSSNtb0dGJDYtUSM6LUYnL0YzUSdub3JtYWxGJy8lJmZlbmNlR1EmZmFsc2VGJy8lKnNlcGFyYXRvckdGPS8lKXN0cmV0Y2h5R0Y9LyUqc3ltbWV0cmljR0Y9LyUobGFyZ2VvcEdGPS8lLm1vdmFibGVsaW1pdHNHRj0vJSdhY2NlbnRHRj0vJSdsc3BhY2VHUSYwLjBlbUYnLyUncnNwYWNlR0ZMLUYsNiVRMEluZHVjZWRTdWJncmFwaEYnRi9GMi1JKG1mZW5jZWRHRiQ2JC1GIzYoLUYsNiVRIkdGJ0YvRjItRjY2LVEiLEYnRjlGOy9GP0YxRkBGQkZERkZGSEZKL0ZOUSwwLjMzMzMzMzNlbUYnLUkobWFjdGlvbkdGJDYlLUkqbXZlcmJhdGltR0YkNiNRaXE3JDcrUSNBdjYiUSRBdjJGJVEkRWwyRiVRI0V2RiVRJEV2MkYlUSNKb0YlUSRMaTJGJVEkTWkyRiVRI05vRiU3KVEjRWxGJVEkSm8yRiVRI0xpRiVRI01pRiVRJE5vMkYlUSNSeUYlUSRSeTJGJUYnLyUrYWN0aW9udHlwZUdROW1hcGxlc29mdC5jb206bGFiZWwoTDg0KUYnLyUldmlld0dRJmxhYmVsRictRlM2Ji1GIzYlLUkjbW5HRiQ2JFEiMUYnRjkvJStleGVjdXRhYmxlR0Y9RjlGOS8lJW9wZW5HUSJbRicvJSZjbG9zZUdRIl1GJ0ZfcEY5RjktRjY2LVEiO0YnRjlGO0ZnbkZARkJGREZGRkhGSi9GTlEsMC4yNzc3Nzc4ZW1GJ0ZfcEY5print(); # input placeholderLUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYpLUkjbWlHRiQ2JVEsR3JhcGhUaGVvcnlGJy8lJ2l0YWxpY0dRJXRydWVGJy8lLG1hdGh2YXJpYW50R1EnaXRhbGljRictSSNtb0dGJDYtUSM6LUYnL0YzUSdub3JtYWxGJy8lJmZlbmNlR1EmZmFsc2VGJy8lKnNlcGFyYXRvckdGPS8lKXN0cmV0Y2h5R0Y9LyUqc3ltbWV0cmljR0Y9LyUobGFyZ2VvcEdGPS8lLm1vdmFibGVsaW1pdHNHRj0vJSdhY2NlbnRHRj0vJSdsc3BhY2VHUSYwLjBlbUYnLyUncnNwYWNlR0ZMLUYsNiVRMEluZHVjZWRTdWJncmFwaEYnRi9GMi1JKG1mZW5jZWRHRiQ2JC1GIzYnLUYsNiVRIkdGJ0YvRjItRjY2LVEiLEYnRjlGOy9GP0YxRkBGQkZERkZGSEZKL0ZOUSwwLjMzMzMzMzNlbUYnLUkobWFjdGlvbkdGJDYlLUkqbXZlcmJhdGltR0YkNiNRaXE3JDcrUSNBdjYiUSRBdjJGJVEkRWwyRiVRI0V2RiVRJEV2MkYlUSNKb0YlUSRMaTJGJVEkTWkyRiVRI05vRiU3KVEjRWxGJVEkSm8yRiVRI0xpRiVRI01pRiVRJE5vMkYlUSNSeUYlUSRSeTJGJUYnLyUrYWN0aW9udHlwZUdROW1hcGxlc29mdC5jb206bGFiZWwoTDg0KUYnLyUldmlld0dRJmxhYmVsRictRlM2Ji1GIzYkLUkjbW5HRiQ2JFEiMkYnRjlGOUY5LyUlb3BlbkdRIltGJy8lJmNsb3NlR1EiXUYnRjlGOS1GNjYtUSI7RidGOUY7RmduRkBGQkZERkZGSEZKL0ZOUSwwLjI3Nzc3NzhlbUYnLyUrZXhlY3V0YWJsZUdGPUY5print(); # input placeholderLUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYrLUkjbWlHRiQ2I1EhRictSSdtc3BhY2VHRiQ2Ji8lJ2hlaWdodEdRJjAuMGV4RicvJSZ3aWR0aEdRJjAuMGVtRicvJSZkZXB0aEdGNC8lKmxpbmVicmVha0dRJWF1dG9GJy1GLDYlUSxHcmFwaFRoZW9yeUYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1JI21vR0YkNi1RIzotRicvRkRRJ25vcm1hbEYnLyUmZmVuY2VHUSZmYWxzZUYnLyUqc2VwYXJhdG9yR0ZOLyUpc3RyZXRjaHlHRk4vJSpzeW1tZXRyaWNHRk4vJShsYXJnZW9wR0ZOLyUubW92YWJsZWxpbWl0c0dGTi8lJ2FjY2VudEdGTi8lJ2xzcGFjZUdGNy8lJ3JzcGFjZUdGNy1GLDYlUSpEcmF3R3JhcGhGJ0ZARkMtSShtZmVuY2VkR0YkNiQtRiM2KC1GXW82Ji1GIzYoRistSShtYWN0aW9uR0YkNiUtSSptdmVyYmF0aW1HRiQ2I1Fhdi1JKEdSQVBITE5HNiQlKnByb3RlY3RlZEdJKF9zeXNsaWJHNiI2KEkrdW5kaXJlY3RlZEdGJ0krdW53ZWlnaHRlZEdGJzcrUSNBdkYnUSRBdjJGJ1EkRWwyRidRI0V2RidRJEV2MkYnUSNKb0YnUSRMaTJGJ1EkTWkyRidRI05vRictSSZBcnJheUdGJTYjL0kkJWlkR0YnIipvdnBSIkkwR1JBUEhMTi90YWJsZS8yR0YnIiIhRicvJSthY3Rpb250eXBlR1E6bWFwbGVzb2Z0LmNvbTpsYWJlbChMMTAxKUYnLyUldmlld0dRJmxhYmVsRictRkc2LVEiLEYnRkpGTC9GUEZCRlFGU0ZVRldGWUZlbi9GaG5RLDAuMzMzMzMzM2VtRictRmZvNiUtRmlvNiNRY3UtSShHUkFQSExORzYkJSpwcm90ZWN0ZWRHSShfc3lzbGliRzYiNihJK3VuZGlyZWN0ZWRHRidJK3Vud2VpZ2h0ZWRHRic3KVEjRWxGJ1EkSm8yRidRI0xpRidRI01pRidRJE5vMkYnUSNSeUYnUSRSeTJGJy1JJkFycmF5R0YlNiMvSSQlaWRHRiciKltjcFIiSTBHUkFQSExOL3RhYmxlLzNHRiciIiFGJy9GXXBROW1hcGxlc29mdC5jb206bGFiZWwoTDk5KUYnRl9wRitGSkZKLyUlb3BlbkdRIltGJy8lJmNsb3NlR1EiXUYnRmJwLUYsNiVRJnN0eWxlRidGQEZDLUZHNi1RIj1GJ0ZKRkxGT0ZRRlNGVUZXRlkvRmZuUSwwLjI3Nzc3NzhlbUYnL0ZobkZcci1GLDYlUSpiaXBhcnRpdGVGJ0ZARkNGSkZKLUZHNi1RIjtGJ0ZKRkxGZXBGUUZTRlVGV0ZZRmVuRl1yLyUrZXhlY3V0YWJsZUdGTkZK%;The graph can split into two pieces: one with 4 gifters and 5 giftees and the other with 4 gifters and 3 giftees. When arranged this way, it is absolutely clear that there can be no match. Fortunately, Mia was very bad this year, and Ryan is sort on cash, so this matching worked out just fine.%!G%!GMFNWtKUb<ob<R=MDLCdNVZJL:hS>T:LkkLQwJ=Dp_XN\\vYyaZhqaXL<\\C_b;_dr_mfims?eNhtuyyYYp<ApE^[U`wbN[BPjD?k<X[hQmEol_GmTpdThwdy^gYlcgfPpd`o_Oy^gfsNq`EgcMapnv`N_sOf\\JfjJf\\KhiYqjgiyuYriVxmGb?fmaomS>mQihGiv_VxFIqYY`aIaaIqiYpVyb<OljFf<ajCV\\`^cR@`[ORbu=FOSU:GCMk>J`Zr>`?>l`^cRTRLBZ\\HdRPZBW\\`^CNR:]HDCiRQBFCeDQsD]v_iv[sHqsD_cF_;gf_g><OcDO;eSGe[:hogh_^Pdc^flF]f_gf?fawfAv^av^RWeUWkcfu>p[bV_eVb@ob@N[DN[J_eV_;KcDOcJuTQuBmUXm=gNMGBaVlcWWWIsCI;EfJ=cfOu>iiZCcv_iv[v_iv[_hn_D?cB?NgeWgohxVwuXHZ:GoNOrDQsDn[Hn[j?hj?jOhlO@gTicVYmlQxl_v`qv\\v^avZ?ir?Aogho?gdOg\\DQsDMEUSE=OOPSgeMehtd=oOQWb`TdDlOXm:FeSGeBqsHqb;Gb;NodPoJGeSGkDPkDXmTafepdg@vfawFv^av^bflDGlOvpF_cxIlkIbLFuSIuBQsDQb;Gb;rdQWN]TN=flOhlqhpiv^av>sVauVMUyL;cdOgdWedQJgYxDenLErVauVLS_Px`pqHAtbEt;\\V_eV_Lv]YvkmyvIY^pn`PNodPOtLilU>ivEylKXlMXjLQtLYyhTUc`T<ItKILhmWh=xoix?xkIxKveYwEvayvApkWTQ<eoPUwjYmR@qYMoeXoKtLQtjmxVIQNcDOCDSCESr@X[QJLYtMipHtVM=XlMX<xjAxJviywILN\\L>pXgQu[XXaqsjixoiL:eqCpjbpohprsYxaIlN`l>XkQtO\\dOgdSuQsHqs@mUXmMX\\Nq=mSHmS\\MV\\MZqv`qJYtMY<YuUY=YuUYMxpqx@wJIn=\\uWiuo=yg]Sn\\rOXOQ=LQtLA`v^aV^`n^@N_dN?DocHoBasFaqipXE\\UI\\OWeUWEv]Yv=pPgMuZhSUpPjyxqyRB=SBHoHeXFpR]HrCXLa<X`asS\\N`lN\\DN[DJCIsCAsFGkdQwdq^Ohv^av>v_iv_>nZ@N^j>`Jf]t^h:?ir?aV^]V^:yhF[SxIdkQTKET;WfAuc\\CF[CBkIxklwVIQ^tNaTNuTQuHsgYSgpT=YtMYL;DJ;LupiLPlL@tLQtL;`tqtOlUXmEXnAwK]mwTYPtvHim=MR<MJhtUx`kfawfqNOXnNMO[awfaKyuYyeWYutcXTa\\XcQt?]pZtULQTl@pPqtPQNhlOHDPkDPrDX\\aJ\\Qv\\AlN`l>PmTPMRHmSHWW<RYtMY^xnajMXlM^]V^]ZAwbAoWhhj@pjLf`of`pmdSoYNAdtOidTOeD`yvai^qv`Q^qv`QFisGirPioQ_hnEKWu;v<Qr<=JItKI\\j@pj\\\\N^\\JKDLK<kF`kndsf=w;PodPOV\\Qr=LumxfIr[XRA@XnAwK]lQxl=QuTQMgYuqxRupXgAviywItXquXrDQsDrOitOdoTep<hmWh]:hkGh[^O`SphNqotPqTfb?gbTIl^`kF`[^xnaX^cF?IimuvJOeTOcTOeT;ir?iZKF\\KBKETK=Ev;YjKuqwWiKxiCtv;gggg?IwMyfk=xZIRVOIoMCamsVGRv]YvKgdOgZSdCAttgXe=ytht@DYdepTlKHlKTyYghoghp]`vLDk>UUIixgIMrpwBelOhlcuVgTwYEMSDMTArndPodLsEYs=ZpqxpA[CF[;wrHh]KipewdnawSY\\Xn]XNnwqb@qcGgcGnkVFa<hquwx\\AukXfrnivAahheupZC`b<vhqwhg?paYv]YZQv\\QfwFPn]Xn]^gf_gZvlEI^QXsoXpXfxm^^of`o>_hn_PqsPov^avZQuoXgBWcEWbDOcDNlMXLwfaWJrPqtPneuth@KETK=umxdYJioUuPBivgLYvipC]tPqdf_gfnyvYxI_]r>h:vrHh]=gb?gZfiwgI\\N^\\>@j:DgQuoWbmWhm[uWiu[awfaCuSIu;eSGe;asFaCPkDP;gcGg;ESCECdQwdATR=UbgwmUtMYtkEyliV^[F^;FkCHKsdhcU<<KF\\K>]TN]LtaxcYj;Uj@DWauTF]uHHsyLPhModPojxYyqYfQuoXKApKWLrkXVAATWeUGdpTekZ@nZ\\pigaviywipgYsCIscqkgYk^N[EV[oX_;NtMYtkgvDi\\VXaqo[kIxkAcEWCuTQuByuqbIt]xJ\\Xn]HPr=xZUt:hsyITV]UFhmutX\\usXhQBHkCHrsXXaAJ:lUXmUBLKDLRZ=VZ\\QwdQohyVeYW=S_PTRUUUURhtl]`qv`MTdk@LMGpJ?hj?@sFacexdiP^mV`Mv\\h^eJqt?Gb;GZNO_ONr<QrJYpawcF^]r>\\KF\\K>lCaftGyhhst>jF_cF_rYvivIjwWypI^`n^@fr?irbguth`t`hcQjJ@lJfwEYuUY]LFk>w_TPxlE>ir?iunQSF]S>_TdcRQoGW=tmwVI]CR;PtuxhiWl=Tn]RcEWclPimuFhoUup\\uthhUblOhlRj=XjLN]TNKDLKDjB@kB<ysIyCLVuPodPKapSWPRf]WflKYlQFXjAtK\\QuoXWjYxmYrJIn=ExbYnIPNdLODuWqymkXRLtNImm>qsWXQk=xZIRVLQn=K_dN_<XkOngwsWPaoObapcW@t`hcUfqhF_hn_hnbv_ivnsXhaeh[`wcYpaGPxlQhrGisG^dN_Dfquwx@Al[VbZQwdQoqfe@AsOX_Q?psWx`_wTipEVypiw=GgcG_TypiCf[GFUEBiXfAuKkdPod<OwbSGeSrSWHa]h;WwkWVADOcDKPmTP=wMynILyqywIHl]tRTpJBLMZppppLymys_gVAqKvqyqyuNhlOhJIn=wZnQwOY[KHlK@kF`kN^f`wpn`pNvbH`];_cF_[\\OF\\YrAPBMNtLQTTNAmk>AmkTVZUWeUomUq@qjCyAKEGoBywyxYIpkWVAcWSIp=f^_f>Cf[GfBOcDORN]TNKYnXJHqsHQQqXUXmUHXvAyk]lN`lJAtKX\\RF]SFLOeTOKd<Ah[UrjavMwSp?iaYU;ER;kYxIya]ypYui=uuwXi[fLEGtwXiqggWcjAxjER@`naxn]Av;YZjAv;_wYyqYFxkIxJWoOA]p^gRn]u_wk^[R>`:?uZOlGakRAuRosTh`Epyxqy>>bIv[InkYvaXXoQwo`OcDOkRQxT^nZ@n:XeqTscYtaXpEwLibLCc>ggTeh\\AikUvrGX]qRPwdQWcgCtbCuywYysesmvSKUSEUKefLEXNAgK]ytYwiGYgQuoCtnctOitkavCYdVwHimE=Qr<AC:oYxmYVwHimEicUt_FToG=mfdOgDWIp]oQlUrEjhqwhQuYaWLanC]UmpVGTlMXl?qlruRdPod@YrAx[mYvIxAaMp\\WRdWgeWcDlB=yJYRIDXxaysaQwMyn@uLdK@`sFaShdUt`lwLYnAn>MN[PUgpvrHX]AyWyXYIP]TN=]WsMUhpUwPsiqquqk]qrGXnTeo``R\\DVIpMw<qvEylmV_eVChOI]Xh`UsPrsXXaQt=Yr=PTc`lwXYqqvLhNE=YkQv?ETnaLQtLmUr@hKVTQp]opIUjlYvAY@ar>Ak\\xRF]SxIlkYlJ@l:IWMqnKquXqmDdj<XRApK_QsOXO?Uw]TOdLOrYyiyqmIyaymaXj=XJOLK?tRF@M;yQxAy=hpohp\\@WLyLAlKV<vMySydSOPS?UMUTMHhMully`ylYKEMSD]RKYlTPmDiNEmljxXiG_OPccIwcIsqouswjQooVG\\>qem@[ZvoXgqDijEv\\lhiuqx>>rZ@nZnsXhaUxrIx]ageWgmRQxT`ctOitvqvQxEoxiyuYP[?Pjpppp`mlffDvkYvahnpnVjaPqtPmYyiyia=Ob<?[:H\\KBQ]gREr<Qr<Eh_gHBIimuvrSWPaGtGisGThsdm]sRGHvCX\\abRQhFKb]yrIWx_ydYmf=Wb=cVlCEu]xbIrIoItAcCGcCOVEUiiMgdOgrWWQqGxOydYgnIxkIF:kBAsBmEx\\irgkHrAIj=v:srFGE=eb<ErPegTExSyVYgvYuYwirTOeTCh_guMOwdQWhausWdMoFGMVeoTg?oNMXFAmkdOl<Qs@X[QJalSV@S?PR;uPqtPHqmwTmyqyuyoRQphMn^`n>xUyeyoTr=YrCVqqwwHyaxAy=_gSOj\\OxIPmAvyvYxIvbF@];GK?hgUup_Ur?X[GrwSHdSGeCymysyShYuix]dDefF;CB;vtgXeAUWeUgkhnceKuTQurgUupGhUuhh]B:qWWQiketdgT\\gBGwX\\cF_cbieioqDWauVAgNMGsawmwsdaYjgubWBBYFAmcj]tbGTNGs^]XlMX\\ahcUtrmvFIEkgVcadv_ivkGX]iRGr;Ir>;rHeetCXgQMUhT=`t?dXoeXvIvAxMbiwgiSs`UHyNY`YLxnHemLTUPUncpohpvIxQxAsJAtJMJZAl[TRR@lJ@Np`OwXTSEUCyWxHy@hMulXNqJQUKQlO^itexT?q\\Jn[YnaFylXOiCWaT`ybYnIPxJIN?ul_BaoghocUoHgMtH[xnUwPiceqtgWV_eV_?uLqwUOsDQShgUuoTU[e>ob@OXmqvGqRcafqcbFasFmST_HCOHS_cxqyxaUwOYoSgdOg>qdouS\\UV]EIn=wJMS^KDpEwLibAwCYkDUMdHEHsyRGYb>ar>mCX[IRUuImWSQh?AGtad>ar>@P[MJ_QXsdYweYsHWMqNkhNw<PAtKX\\tHQjItMx\\mkHpkPVEMqadTOeTVeqtePUqpgUSS`S@ISMpNcaWZIrbTJBiuunfn_hnFZj^av^myvyvYpKWaXfk_AykYvVv`h_]_Qhsfqv`qr`isQxPvpvWn[nkVFa<qgWQqKO?_enCWLStLQt>qdnARvIyayeFcCGcfVmGaYXIiIa=X]_c<=TJ@jY\\YjIJW]UV=W`mV@yVYhYpHuI@OYASwAsguxhiuoXP]TmpdWlLKAEnc`WYqqWhmutX``R\\DvbIt]Xm_akuIx]yrsLYnAWg=XLaMaEqdMWd=ySyVYHtHqsHpmXpmVuqxeqKmOSUQsMx^TypiwEEk>MrkYvAYPmTPM]WCuK>HsyLWXlyKESCEKa]sRHR_PTCAtJATxixQyU\\UStxOLUTMEynYtIUd\\Ffn_hnvsWXaanp^p^MHmSHowq[wYyqyfV_eV@uLPmFgcGg[QioUwbIwcIOuSIukYpIqau?vOoa@g\\:o^^^^j?tZHb>>rxiyuYxiyqyq\\UOlb^n_hnkivQxe`hj?hZwfawFy=y[y^`EwbmqeNxlQXhtaxcQuwo`avcX`\\UOlHAogho_QuoXgcIv[Ibav^angVAqK_gCOjZHtb?ySyfYHtKItKphpohvSmiSKuxbOE<sbHcE\\AgKUfbcdDEEPkD@iiuuxDgGCuFV]irEd=qbGSf>MF[AcKSFT]rxysr?irkCYkIVODC_b=qbGSHtIrgOYLQtLAEOcD?UHmSHHqewSe_gf_OVEMYZmHh]uBuSIuStCIsCxqyuyuDUmSMGHsyRQIWHkyK]Wf]GwayvAwZAv:yGx?y<AGPWxYYcRAuRmXhauSov`qvVmhfEeKatCqdgSUboTeGwcIwSaG`ETEMSD=IumxfMeSGekKGdKw;oeCmRK;RPsDQSx_ydYDqVmsJAtJqV]ATw<OSDMS\\mnDWLdnLEO]LN\\LUNQlAYtaxSmhYuqxnhpohvThPe]rPXNRdr?irV`QsMpp]XvHQrLWoaWSQp?pYxmYNEoN]msTX`TKDLK>ql^=TVPQoMSeALx\\yjYr\\hN[DYJMwdQwr@WKQNd`TdlJ>\\JjusXhQ\\USLYQyuywyPUipeuREUSEmOSMp>AWVxn@@unHWMdWgeWS\\MV\\ufql>mLQtLmMv>IkN@crQsevoRfrL?cMxI[ckKyAeXoeXvAx=yCcsdEIIr=xZqVq;eTUTMUrqyuyuUuiylYxmirP_XAMgeWgsQvEwGL;BYgYpIU=Wu]AyZ_esSX@Gr;IrnWhmWv`isUxTSlJY<RX\\Qr=lxmYx]Xn]X^QoOUoFPXC`kJamvDYLHLKDLntPqtv\\irEXmwyWnYuiuqKQsDQkKItKaqvEyl@ul]x<qkWTQbav^arHi]P^_]plx@sEYs]YtIwaG?ZVVap_ocVyfiarYwixqRIn=wZTWeUWxywyuymKgZYFqsHqVNan?_ON[?vvIymIgk@W^p`^KAtb_`vwywyxoHmMVhmSkgFoCe?UcPCTdcdlidQmU[eR?ebRQX>SV=qbG[hpoh`Av;YbS]UV]Gp_euKVlychick?yAMEGobMkFF=fLEg^Qx_YsGOgYwWdsyvYxIciwgiSqiwpJQ@WE`qx<Om<V:AJTAuRaPUitY]voaKtxOx@y\\dnLEOQtOX]u^ysU\\W:DUQuTAyxXYYIPPS`kItQvApKywE=LTPwdQWx=x;yJN=ON\\wQyoYTxlQx>ql^<KEulhdtt<P@APt\\oEMtLQtRIoMuNt@qr@xfIumPVEIqilKV>jhpoh`gWQqovpgWu`npVVn[PplPligqoq\\_QhsvZF>]Z_\\;yrSYpaGwcIwCw]Yv]]@cp>niNf]StMYtxnaxnK]sD`tmdYtaXDaVllYsivQPVEEtEDXkEXnuXquVaqsWhKhTkqHsyLWTljhyMOxlQXpyuyxaWOQoOUkSMYVhlOhrjAxjMQsDQS\\tDmjv`qvlj>`jJiuWiuZ`XCDslivEIOMHsrqrUtWnDwmmJS<RP]TN=XFAmk\\TddlvyuyqyalpVTn\\avCYlnYxmYVUqpgEY[Qr?Dp_AwNhVEqlKMOOPxExOx@LUMkb]lN`lj=sJHNnMXlMPdtvM`NQ]oRER?PR;yrYtYVAnQpoRLPAukXdnixoidyvayFLYJDvjIv=aWOQoOtJH\\MbMUT`u:DqsHqfytixMgiwgIY^AsKDp_auMxXXIYAPS_Ptbtx@lQBtTh`U[UypiwSlMXlslPplDp_AlnDyAuK<HNtyRTdk@xKy\\yjTUqpWg]XIaxAdnv`qVXRApK_XoeXo;]maaULMT<AxjAX@lJ@lPUasiyX\\UsPhONMOO`mqtWXUnyTVjEJ^EUSEM]TN]DwbAwBiYuqxChOAAOCIsCIV^]V^dwgiwUhS\\EmoYwQYTddllerDhL\\USKdMGpR=IR=pJKitOitbmlmpqkqrU\\lDGy;yZY^`einsNyZv`qvlwOynInohpoHbpIlAx[Ynn?lImQsaVEpUlPYi\\PTdKYtYvIXTMUTMMn=LsixQyUMmNMhPeinVuX]QsOXOnQxlQvZHR=`RiYqFmyKYj]=WxItmtsvTRoPUg=t=Lj<MTSEUCAwbAWtQytQktTPVUUUUs;TJ@<tQytQAWvQOWUp[Ur@Ls^M``YmiO]ogq;gZJP]Gpj=n:huWimcDOcLVEIPdMOeTOsLYnAWdhtdmN_dNChOaIjBXkEXn?hj?tQuawmDp_@MFdLOdLfitexL]LN\\\\KXISYXPamKOPS_tYuiwqDp_`PULoeXosDX\\aRTUUUUMNIyoEsCIsNUoOaYxIiU^wXW^=On`d[afCUdboTegC\\]BxqTHaesSROOSOQvAkwLWdMGudgTekGV=iJ]HGkFyASq=EDwYnoVGQEd_TdkymysyKfc=H>KsDQsRIimuVHSEp[SnGRTwCy[yJoxpqx@CuISwMwsysyVoDPkDGOEJAHb?Bl]yrIx@HRd]kNysNEquXqmTQuTUfEQqiRsEiphGgvMySycGp_D=WFeSGEggUuh`axcYt?qdluRPsGX]Ss_UXaGLyUUKEogho_EykYvcWgeWS?eR?Gp_EPgdOGtYyuYgyuyximDcuvoib@Uf[]Xn]HUiheuVJuvPiTOeTk;Gb;c]qrGWDUMc;=hsUx`MGNKCKqsagHsyRtgRfuybcHocdPkDP[ydYgi_xhUuJCSCES[ggggGysyvYXwWuxkYvAIOKC?GWJWyyAEukXfSb<ObReTOeXQYwFkF:_UmoVGcGf[GrMwNIGkgfnSGDQsD\\Of\\k=yjItLwEyGiyjtVHaM@\\J><MFqyMTR]At[XRnTPmTPBisXyRH`M[PTc`vtixeirPPtfEocHo[AsKXNS\\MV\\Ot=xkdYtaXpXWQGr_^]knZDV[EFuhheunsRH`=_gcNePv_X_cYv]YpfQpqxIbrGv?x\\RYnAw[wxaEgC]FFKVtyR]sRH_vbGT]_xdUtJIyxYyiIWauVawt^CXoepRiquuXx@y\\YktUpc=wNtLQTtAyraqmepyFLN:`qrEx\\dogho?TMCHJjusQUXpMYxiyqyUTAuRAMWASQMWdMOGisGiJwtPhPodPk;Ir;aJ:Ar:AR=xUHLuJTTaNsb@obVjT>^bn_hnnqxpq@nWPhwWuoWhmWqGIsg^_f^teWuPypwXegWyrAyjinQpeLYoWY]cx]f>toQhTgevqo\\otGWdr^HPK?PjAukXdLUMKmUXmEWauVAyUyeyOuv_uuraugquwXyGUpOiPodPfquwXyWtmGQVQiVhmWhdwgiwsHV=qJwHuNTryLTc`TfYuqxOquwXiOBhS=MRFtybusXhQn@pj@tsILPeSkiXULWEMVqxOL`wOYoQpUYhVydynYLW\\MV\\XX@uiHpyXn[pt=qjGT]Xquxqo;aq;_ZJXf@ak[Av;Yj?V_yhnA>l^FqdgtdNar>aR^xSpdqP`x_yro[SN`>?dUvnIwmxHwx>`>hcoic_VauVmdflDxivIxA@uL_pFImmvj;Hj;PjXh\\qWfwhutAxiGc;^^sga:XlEiv\\hs>wb@oblijQneJIish_c>j^FscVd`@pIwM?ul;yPYUiEhMufHMbNgYeYhqqrm_YisUx_YQyVmGFNivuuwwHJ;DJtUMjXLUyQdEKUyKniwYdxbIt=xowpxTpsEiWHDJ^qywYyctlEixL@s`pohpkxqyxayZYZbaqfWfI>^eQwdA]VjVHQmmwrekbIJ^MV\\MN_M`;wl`?kWG\\@@bGgcGVuoXga>c=G\\<`mV`=qv`QbAcRMufHeicWXW_IsMhZox>OVvAykaEt[Xb?ul;SXuguSWeUW;yxM[uRuWHqsHyHw[yUMU:CSLwSxCy^sRH_EcwXuGhkGhNWs_airEx\\osEqWcEB^MXlMH_MHS?gSEUeWgeGw\\Qv\\;ukESoiXK;ER;S:sH_;wSEh\\eB;;HbVjgXPcIWOXstKV<QZ<qgDPvYndQwdmN^\\Nj=v:Ij><r:@j:TnVEmMaLnIwYdmwTYP@JRtMYtomQpUPt`]Ko<X[Ds:@j:lquqwuPjUIumxVIdvlEqZtRp]QBywb=OoApvEylmpheutqkamoEpM:mSV@QK=tKiPLaL:mtmPYoQWt<Qr<plPpL]Wctx^Ex\\irnAh[>g`vr<Qr<OuSIuK>ZQ`_SOb:^pohpoNsmWwHn]v>cc`dd?\\cynYqiuigp_wRIdjI\\tQypggiwgICQwGYmgwug_kBJGcCGcN?S^KYIuBykVFAExKxBYF<_dWQt<;SL_Y^IdA=yNYTIEc`uYUqhg]Tb[D<gyPexoEhrEx\\MBZYRIcI>QeTOEPatNAHf[GF?BrIuaueS[XWgCV;IJWDakSN[uH?exITTMUTCBJEgNMhb?gB=TGkb:oivYfSSH`=Hv[IV=dlWeE=BsIxAyEMYsEYSjUI<mCvwHA?Bl?fZ?blEivqcMCIL=cBeWgeGp_WSQbKUf@EccSREoR]GRUqhgEFK?SjGV=qbUquYAh[UB^KDCKupgWEcc@\\NkxWYqQFpMwLMpmXp=lB]NJ=ON<kF`k>qxgYuiMyfETK?c^N\\B_>CuSIuRWIqmGVcEWCFK?SZIwcIcioitQCoeXoMbxuiKSF@=fj?hJSyqywQ[tHoGRiiuuH\\Wf]GFOOCqUchquwWE?gb??xmYx=arCWD[yvayb\\Of\\[wTihEUYG?dqabhCCIsCAgf_gFpawSYFRgc@QxeygyOvkwrXSb>MFKYcwwxYyYY;BjsWXaINcDOcumQyDOcD[sYwIYUUigxoyx[ybYKf\\Of<UYWiyPif@UfKcfwuB>[BZ;Hj;Dy_ylYcZoXh]fpohPSIqmw>YrIsIfwHUgxnkhXsW^GHoUFpuUw;YjAVfausWDoghoObSAiUSYqqw?uvHie[UWeUGbge;WBAKR`Sd[AwKYfBuSIuRtMYtkcWSI@CeFmb;SB@[HrtPPiSwUUQTnIiwUypilxhiue<SSixRLky]nJ=OZDlB=peuth<S^>pqxpAoixoygwtOn\\PNbgpd=O^K@vixqxQ`sybq?fIqmw>wMynI@np^hC@]gYoIwmx>qnGwLrNaT;MsiwVYqiw=wWYiq?fpkw?URwMug_HogwcQCuSIu[b@obXIiiWtU=GUABkCHk[BZ;snIxG?fCCdvyrYsYF=BfitewtGUhYehoghfitewD;;xMwSxCFsUxbCR=ugUsHTyurewJGF=MEvoUYCudSF]SFsQwewgDkWaIRbGgcGfGgcGsTioUg;gG?sBAS<;vawexMSL_ynYtIECVqeRIRbWY<utFKEn;SiSf\\yX]CGcCc:;EQsDa;igOyYaH]SF=ouXquTIUGKxHYFreF_cFv=w[dukpY<Yr=ipCDYFHpwuqsqvU`KGdKO\\uHeQAxKYlNjUxxlPWMneQYf]SWAkWuloYPyLVWhKqAt=uKCLYn<TwyWRxlQxngyQytyvYXhtUx`UUys`iv_iPRuwqQmoDtQumUuYYYKsPv=]OyAo`pn`qn_\\o=mjFDVgeWgTodPoRIoM_Z:iZEn\\VqdHgyFPhwO`tVffya?pxIPkEXkcVlCAqwWypGbDygDxoUAuS>ckNuQgcGg[g`of@q`gsTfmQheIinEwlB>bjhw<fkgXk@at=WdUqmhFmpfgTVqoWwPAvuOn@>lYoisi^Wf]WfZqXhqXmyqtDXoy?iE_^LXupvxE_^LNZZOeTO]COpb@oBXrAx[aqtgXeSxmYxsdQwdonaxnmGt\\hb>ngXYajWvGFvZAv:igUqpk`qv`mcIwca]p^gRFZjXfAqk<xyPVd``c[wuxhi?vpmA^^_f^?\\:Vf\\Of>VpKPlLPb:^lCafTw^ZQsOX_NPc_`Z:Y[Qn_bwoOixwF^NvOoiDAsBAS;Qsi]CyoytYG_OTciEQaseQdUSuhQioUwB[UYmsTweYwYAAr]iiqqu]\\Tb\\LvqxUyWS]TN]r\\Pn\\lYuiwq`lEiv><rqmusuj^HXpxwYtYvIlDdj<=t_xuqLptexdMUR=UBlTxpOdIpkhXMuY`il[\\t_PS_PvqxuxUObhkuDvbGdjhyI`f=iwp>ar>eUh[ugytixq_oqqjxq_@wmUhlOhb:Nj`?[q^ZyA_^^^>HwcIwTYgqhgUqbZQyPwkV`mVfwYY[DN[bAvZAb:^y_ylY?cTvfyI_nxiNv\\Qvb:^cDOCCGyGGxoW]UBBEhvMeueFjEYJmyxYyiMBJ[wF;TWmBJ_VMQuXoGsaymyscoTeWEvuSNABlmwVIiFKCDKDVqSMMEOeWgeGuuxhiSZqvwcTEqdgSF:kxhiuuqFaaWaqsW_wQygYcGf[GhUGMasFaSuwXZqrUKvPybHMXlMH;;CdAcOYxhYiiQhwUypQbUIYJ[bhaVCYwSMR;;XjAv;Qutagggg_Av;YbC;biuiwqhpQUWuuMKRkquuuwkgUuoX<gdYAEPoGWMSauVaeiRQikgwPgdOGtMYtM?BrItAuEo;u;sTPmTLysIySeafXQSwWHeYweYgWyB]]WgYYyqywaB:asFaS;iWK_v<ibECwayva;UsQibwr@qtGeYLkF==gEuUYuUh[Ur?TJUEGCTUUUEEgNMGbQSCWEeYxTihe]Tb[DTyic[DDkV`mVpCG:_FoyuaqtNatJMFK?Cl]sCeI\\UyAMS_OduqxgYicQuDQsDeWlYfsUx`IWyqUyOYAYsEYw`WxbecgwyNKuyKtQ=t\\Ws:KdNsraGcHoc`atcWT?CGU_FyEy_\\lB]NqdopTt_LqH<NUPupaX?ysytyFEmFmtZmSEDTqARPtLQTr@qr@uWpQKETK;Yw;UxguotiyXLTc`Li`qlQK:<V?QkO<ohpo@eXoePPmoVEK:<Y_ilQ]puIlG`Kc<J:<L:`N\\@NdPxPioUuj;Uj@DVqqwWAOitOyhsXeyX@qUEwRIp]iSyyXn]X><julwUIt_lppppblOhlLVqs=^of`[:>nLGo>F_y`qv`]epdgPZ:^qxQyeQutalDgnrgwoxt:rdgTe_hoMgeYY<=GfggghvXLqUdr?ir<xwWPWBTKETKgqUBiJElLZtPqtxpXWnLMGLtMYt;<JKItKypwxuqxWY=J:iletTZHtb]klhYQyxahJ?^ZqhZ:f^_f^j@pj@tEhotOmTwkqNhqPqc?gIhlRghcGgcGkLPlLFbgkxyXJyTWPQsDQ[xVIqmTyyqawSYLdeptHS_=kKyvDaVl<oNMOgYpD=K>QxIPplPpjdXdaTNeTOEVjAfKplPpnwprFasFVxaysA>ZvOxCy^BIsCIb;GBwCy[yJ;BjsVHaEgYXUAEuyKuOwyXjOhlO@fp>j@Iythk?__Ypb_Pd[`pn`dJPp;Xwx?n?hj?^flFmZo`nGcMOuXp_k@pj@bggggWjow_d?Zcav^ajV`mVF`_^`B_hn_`f_gf?\\Yv]I`lN`\\^v^aV^xnaXn`pn`Twj_PplP\\mwvHiZ:^cSP`?FkCHkbv_ivZCqZWxtUFlEivqfyypaSAc=gmcpoCQsDQjeXO;iWwB;Ir;IB:?XH=Xf]WfKHlKH:[UI]vJui;GU\\CdZ=tZGR:;beuthGvjIv=QuIACwuSbQbvayv]hdetD=XusX=ir?iBSEUSMfRqYnItAEv[Iv;Or<QRvexOyTqeipqUCkYFghwuVauV=;bXQurWf]WfXmwgYIKat>eSGegUChdQHasFaGs;_dh;hn_h>GeSGElQxlax\\uSdcd\\IyayeQqyyMx^IsGMSVoFPueUEUSEclQxlERuYUk_y]sFasFfSUp_CwMynIR?eR?kVGQeoUtZQsZIr=Gt`gSU[dN_dZEylivReit\\v_iv;IsCIK]xRIpJZ]qwynJqyKeywQniHJxxJ?]SYpNytQYUwELK;hoghODQsDATSEUc<mGdUMAmpxneMxlQxZmWhmKEsguwCOE:MisGi[SF]SRicE=UTjWhmWr]wcxKC:;UyoYwkiyqyu=BQiENUIuSaOgdO?qtgxd>jeIuYVZ<NZnHtyIp]wr>?dWAalN`l>v\\Qv\\npFXqLwwrF[kAx^Fk_XcQp`dQu_XcQPgiic]?qaN`mV`[av^a^rhmuHvdQwDPn\\P^;wb`yw>hn_h^`isUxZ:>en@gKigiYmSHm;iuWi]:N]FQ_Pwm;qtWiuWN\\C`rbVuqilevdZggggoqHeZwfawf^qv`Q[XH^kqbTPdIpf`oftWt_X_dWG]v`qvDotIUItKIdiG:_BhwCHIeSGe;asFagCIuccrdYXeyBd]bfyW?axI_vlEIPgGUmBZQY`Gx>ar>ewumv`qvTitXsEv=x;kVIqeG;BRgHemdpmrN]waEvwQFnwYNuEJCE\\arCURBGUIGisGi<oC\\gtqgUksB:UeDUVTqehGsEYsuWVw;cT;R@mR@Mfv_iVsfHeeLST@Ubv?x<YC:;bOWGQMWQOGPyyG;iXIrPyBHSSP_G;EV[EFDYsEIhkUv@]IxAy]QyQ[uBmCWKI>?sBASkgVViDuUYu=YuUY]avCYdtsGuQuoWWRIh]uB:;FcCGcGr_kEQkGV=B:[wVIiMsthgUMqYPAtiIcMwFIMfmuvHQbUtPt]xbIJ?PR;hYuqxCPVy]xbItTAv\\qTFasFAPx]yr=J:YPIaQ=hXeqt[`n^`J_dN_<UupXglNGMm><JRtPh]MfdOgdklhYAar>aun`NJ=W\\LN\\<TWeUGXLalSbis`UTdItRTJBYvAyk]pn`NqoWw`NkwAlJ@\\>ir?IwGqmTgo@gf_g^dV_eVmfA`Dhtaqr?ir;o_QX^b>_B?`UNfuyb;Gb;?itIwaHZ:V`aosvHwRGmKV^@?rEYsEfhoghJAgn>pohp?ajCV\\nxwEhyf^qY_jpykTapcWZeWgegqpxoAFbfPifN_dNbdOgdNb<Ob>VpKIn=wZBaflVncXktowOqxngscXdapwVw[tnuiGu^OuqxgyWt@@d[>bMn`PvtMGeSGcYv]Yfwuqaxnaqh]jVamovFqZEQwYyqyWnqv^YQyX@l^n^`N\\:vsVHa]>oWfejFf<aZHF]l^baivhfet`l:ix=Yoialc^p`pn@Hv[Iv>>r_XcQtyWwdqeJKb<Ob<Ks^MhukErQgIMf]WfscVDaD;iwVIgwcgTehdqcgUiksry[taSTkkhpiUMUlHlKHNh_Qc;gwVQcUqpgGy;yZY>[Lox=`]]ItJOdVXqOik[`t_YyiyQyuYyUjOxiir<gBE;weYwe;UsyXtiWi]fcCSn]rbYXYAY]iC@gb?Gwv_uUEtawYNATw]f`ofLmFMGD:sCYkIvUtuUWPagKqYpGffEe@qtyMwEyIT;HZ=BYgYpIU;MshMciWuRqiI]cpih]urHKS_OTP[DN;wv_wUCwLifEsVGQe_;SSicgWc`oI=?suuhwcU\\iwgisIoItAg[ywb;g_qRjIvAwElgUuoPEaj>muY=JCmUy=lPyqYAtSYOTdk@xWwhxPdWgeWC<jpmhrVHSdSGeSoBSIRHQeoScWWIqmDNqbh?unGWMcGgcGomu;?yuYyM;BywyxYyuoUqYrIsIJ;BwiywyWtsTAuDqabJ[gYuiXoXpmXfcGgcLsiSOQvZAvZhXZij\\qSgIo^`^UwphgiAyxEQsDAaiouvNytQydwokYxmYvuywyxiMo\\mVfewuUp`gOnGhkGVhmWh?fpmW_iwqwq`=Ob<_ZcVqxAq>fj<GnGAuRwc]WwKAm<>stPqtnZAvZYal?NeYamsVh@@ZrowVIa;OsQih:F_@wmU>]R>sqwuwwdaivXQkxfy]XaOyrewowpBSioUw`gIdqb^sCWKI>=BnsHqsV@mR@iWYWHpoyMuUxItLifEEutgXeERHOiLKF:_D]gYw_xLYSfIumwfHYswgdsWXaQHr;IR=dlgbF;FiitpaX?]Yv]I;;HxkIxGviAGRgv@MTV]UFUYuUYw_ELSuLGsCIs[gdOgDqoWWQGp_d@ETWeUGuCIscUoV:cSVIeB?cBkipQueMVEAFseyb;b:Ar:miyqyuQVEEWk[tPqtl;IrtvHimexXUIMSDMNEoN]usXXapsEqQt]xbDJJir?iRJ`L_qj@qsWXQcPTc@mOhl_LoH@xjAXHumxdUNeK@Ps;YjADOOPSiMQM<Ub\\KSyQt]xKyRC<bAg_bY[wOyAGysIyNGOGtrQVtqff_gFoXp`xlusY]qrElLEonqpSiX=uRYeWiixQyUaukXdQhAyx@w;\\NseyfDPIuSIEraXoUMPIqQuaO=Qr<QMvTs?ATS=pZEJUapcUXMAoaHkUIQl]vBdLDdJMMTL]rPPn_ytYuY_hlOhlZxVsMmryyvMycynNUoOyxvTXD=O`pSWPsheuthunmMdYjlywyxylxRIpM><r[Ur@HMOuuouQNatNAx[xjXLvEyOy`Op`LhXUqpkHpkHPjiPNjlRX`YlIcoNgNpufI]\\xiN`lN`bUV]UNZZ_eV_mRQhX>]wWyAwswvxVVyqywix\\Uor@ydYgi?w\\Qv\\P_dN?w?qujIv=Iap_wRgqRQt?NydWi?gb?_pqxpyXwdga=@[Zf`Tf[=OBkIoatMMVEEWP_WTahCOS_OdaoSWODUMSM?gb?gZwgiwGQcGT]Fp_D=gfpohPgUuoX_acSSH>qdlUEI_IlAC=UR=uWUyFdMRq_erCX<OS_OdysyvYhbMElQxlAw^anEmlfDtCEYqpOoIyaymy]XLmo[TxcynYPt?ir?HysIy\\US[eWgcusX`awSYh?qd\\=TVSIp]cDcjZUsuUM<AlvYnUtlPIJZusXhQ?DUDHoI]rjykhNiOpdPod<`oTA``OcDOcbQv\\QrOWoPGwGqf\\Of\\flDg^I_mrFnqVmqYjxXuXYmioqCq_WOqVihJ?uZNZBOlF?cB?nDgnlfZENa`axcYtnhpohvavmvO^p`luQfUqpg_pnDiAi@Si_WhjEv<Mir?iVqhy[sJ;sIysawdQwDY?Y\\IC;uxjah^MtLQtbIv[IrCYdaScgcby_ylYCg[Gf;Y^AsKwBhSS\\CdJ;iX_Cauxhiut;Ta=uVCIldOf\\OrHX]qRkhnbEuuxXidsGisUhrFTlh<tb]PfQt_Fd`?kGfryNqKIkgqtgXmXolkQ[C@mxItvHimAwayva?lIqgk@mtfhdVb=WboOqLhnk^qnQtE_wTipeicsq_Ff[wopwXdapcKauVamuqxgYqeih@V\\:OlQYli?c_PdxWxGy`\\Wcco\\^v^aVdgpdmItAw]oNw_ye]orFHnyxqy@gEYxFflypytYklGqVXmpfgLVeDi]snhfA]ggggGyFY`IA]oiab?kVGQEfYweYSYnAw;QhlOHkgvJ_FAycYsSoOUGahn_HkgfRcCoiyn?TSGEY[bCSD`;hwUypaGcCGKSUD?wvOxDYGnaxnaVXmUX?GpiSxIdhEDUyId?gb?VJ=TJserMNtupg=kvaymysNMOOPnfpPCYsEYnAxjAtUyeyoeqUqPnLkEXkSqoWUQH]mrDxXxtT\\T:DSLXsQxOa`S`TvyqyqyQkhnRdPapSWPnUXmUtJF<MZ=t]POGHnn`pNHj;HjV<PZWtl?syYvFImm^dehtVHamonRQdhIs[XbA@gcGgCI`]CtUuQAtVISB=KytQylQnAt=mJo<p\\Htb=MWdMGqxgYuUPjBqRjEx\\iRtIysIPtLQTANuIwLQtLmpiuuXXrAxKiEte@KxhypYUd\\LDlMv<YJ]TWlNyASq<MDxYN@mR@SEUSEmYrIvAPnc=P>lkXdQDUMUTMhlUv@UndKkDPk\\lEivvqwuxw>UtZlPodPo\\Mx\\i@^Z>^`d?dTAv<>CsDgKU>EgNMscUt`ghbybPiylgpg`plPp\\Av;YjGlV`Mv;ESHmS`XpmXPAtKX\\WJpkPpQCxkIxnTeo`AkKTNFpnw]r>arJItKIl[EV[]SIuSQTUHHTmhWUq`kHp[woXgqFN_kpbwfj?hjFV[EVnAxJar>aRkgvR[GkIxkaWWQioSr=YrGKWJ;vPmsXgIEUUUUUHwEyki?mg\\;urGPDaVllYkirQLf<Ot^y]w>_@pvYfyrYvIpZowicYmtIrjIp]wrDpuy`_WOqNP@Sv`isUgROIF@cXoeXVSIp]GgiwgIeJ?dJAgIAE^=BCmyyYX:SyoYwa]xeawoiROeTOsVIqmlDmFxOy`ylUpu=q^\\N^<TgpTmxUypY@DlbMRFlKX\\QBuNatN]`K^xywyxYmXbAdW_eV?q_WsPFp_A]Wf\\Of\\VHamo^_PdcBMmfR[XpMvLOdLkxgYuQoxpqpgUupDp_AMVTuphW]hqwhQuyxiyWJtVqpuEPywLmIaQmakKixutK<yKy\\y:enLEoQXPYTm<HsyLWtljfyMg@UkPjLEoN]tS<Qk<Qt]xbdUV]Ur\\YrAX=HwQmvFIm=enLEsYpYtISfEOtUR]HtjMr>HKnPplPWLmK=TjG<^^IsMx^S>\\J>buVaunoUwpH_gsnZG_iv_a=Wb=GgcGgCilevdDh_A?`LN\\L>wgiwGqpgWudi`Mnm[>pdgtdNmSHmk_xbIt@WqNxp^`n>X\\`^cZ>ZxfynYt\\hwaN`pnkVFa<Aj:@ZTAuRAwoVbWYjJGeSGsaomsojLFk>Xp`gslNyfgkt@ndPoDXt`hc]`b\\Fv^IsMh[@Igd_[uyXIWauVAqiwUyT[vFyhhGeysYxcFLCc;qV\\gHsyRGwrR[y]wGy_yLOHS_cicinQd;eBqORKuIBKHv=yjUbuSvqMynIwN?S^[Uj?V;?uL]BasIysewMynIVeoTg?iyuyxqFwmtZWBBMdfsGisveugwoRC_R<IR=oBoKYdeh_?TJ@jmlVFAnLEo^]R>]JMXlMhrP`NrDuSIuF`kF`nohpotTf@U[LylxJ[HOf\\O^ajC>d\\Fljiuqwugo\\YyhuqxgagWQqof]Wf]s`isQh]Ph^hxCob@oZafcT`bcdl=r:GBv_XcQdRQdT_sTiheEW_eV?AdJ?dPCXVsrW?cGgc_ufHeebeV_eVJwB=yH@?yrAYtEYsEhGUepcsplv`qvl]tbHTN=ONlJy<U]MxIpwHHpsyRyxyxYQg`of@MOdLOaWqAle]PTdwDMM=UU@hmYxmIIqmuvLqtPqlPlLP\\lEifRYfIh`UIjhAuRAetIysItAyraqqtq[=x[ZVwSyqywa=Wb=G_QXssQvEx_lV>ADUMdb?WnKExEx?yDn]Xn]f]Wf]sirQN@dtJdj@UnKAXPaoS]lCaVV\\Pb=lKMQPik[UypiwnAh;wdQwdhwuxhefGatfnxIvhoghoSUep[ujGV=ouMyXUKGsEYs]ewSYpcTdLYtMYlyjYlYjLw;XjmyvIYpiuuxPu_ypsDQsLVEMtUDQsDQVPP_MK_PTcTyoYwa=xH]ww@sFas^An;UjbtlEIQimuvpVo<ymytYuYKiuWimXpmXhSXdkQTLMxYnUP@awYdmwTYPHr;IrnhpohvTipeerPvnVhauolWXaqonohpovqwqxUGp_AgCYsEYvUygyhcUV]UNuUYUwHilLPlLluwXiqnAHYr=YbuoXgQDUmfHAtb]HVwHimE_QXssbFCE<awfawuQGAAW<;SlQy[qreoTgOfUWeUcsFasrCYlaV]wYRsHOOv\\QVhKUn?cgWUqdnLEsSTP`]pBhv>uX\\Ax[YrnyxqynDen\\awSYpUhStHy>`j>lKT\\PB@JrarMtSnTuK<PL`qnEwLtmtMwcLS_PTpHWMqjYmYsin;]Nq<L=xYyiyQxovPxDdOgdOSQoO_en@gKWpDaeupgWQatPqtPtDQsDxgwhxPWpxxomQxlAyYyyxylPodP_hogh_yxYyiinp^fmKwdQwr_WsPHd_Pdk>`j>lyoysynRQlX>kEwlhFhnAWCBj]xbIt@EiAqu^yEosEyAg\\Of<wgyoytcfLEGuhuUxnHemLTULYJK=TJ=rQqUugvlGauhheqrN`lNFp_FlvpqTAvgxpXQnohpof]V^]rvixayUqs_asEYs]YfIha@?Zv_ykyrGpilPfAqkW^[F^[^Pc_PvlhfEq]b?fTAo<>stO_eV_sPf?Q[pHgMqjlFMYfIoIDiwUyhUcsBStwADYsEIIWMqfKquXdoghosTV@aKMmPEyy=UnKAXKQn?]pmXp]XkEXKyDy^YL]hQVxPkDPKXl`dS\\`UhtVb=Wbtxhiuelp^dqK`mV`scXTaPt<Qr<pkHFagOunnmsVh@_gSOjMgdOgrYqiuik]vbH`nFo^]xkIx[yVyfY`Pv\\QVKUD>OtLQTh[UrdMWdMcUWeUsyayayQvyxYyY?ql_XPLMTL=yYxyvyjplPp\\Xn]X^yRYdY^]LCPXhyjNatNmQlAs]\\J:IV=qjSdulptf`oflsVHQMpv`qvnuXquvYtYvINp`nAlr^yMotMyAOplPPhuthX]`UhtvmxsxTWnUJ<dN_dNvavMxSnXP;yuvUxGHRfPPDqsHqvUxWxHSeTOeLQtLQlYrItQvxvmqXUqpg]WMqnGdOf\\OrTWP_sDQsLYlTgujysyvyj?ujHf>>rAo]s_jcHocx[VonKoZJhxNqtPQh=qjG^wQyoYfnLG_WauVAypYuiw`UvnmVauVmYSwerB?cBKBZweYwEyKybYF]_EWctACIsCITurGqtPqdmoVGQHRGdhWiKuTQurwUypIXrAx[adDefF;[eotfH`BpkP_[lOhlsYwIYgwTih];BpEwLibEqLPaolhKPqtPQxBIl]\\mpdWTdmV`mnXsUtPf=uJaoWdqUDOcDO[QbQNtEYsEPdc`l=wjHfvPioUgklGc^gf_g^q`gSQr[Vb@@ddflLYuUYmYfinIdmHeKFhinhhauCAxjAh<>v:Ij=FquwxhWjXOhWPlLPrQyeygmPn\\P^hpoh`Al[Bd[LV]qrWjPiuN^cxIdmAnhpoHXgPao[WuphgcVlCAyNYD]It]xb?ulowDiheutrqwuwwdUBtyHYaYMAF`MbmOhl?y@YEi=tDQsDOWoOiCiYnoR]GvasevMRasFaKUR=UjixQyUq;WYShhogHwYwixQsBH[EB=BfqtgWeHud\\QEo=BsUFcGgc_emsVHciwgiogeCacSSHrwYyqY=oSquYesvIyeaQf?UcRCESCSS_S@UWeUWH=ejCbuyxiyWpsCpCfc;Gb;v<iJlhXeqtN@S^\\wSYpatqwqxUUjUhlv@X[QJaasSXRIuSIMJZ]V^]Nq`WSQt\\UJAqjr\\YrAPatSX`SuUYuMJZ=Wb=OaqsWXsymysyrbQptmLPl\\`isUHyfYpIQtSIuS@ZR^\\N^r?X[QNxditePfEY\\GPmTP]xqxUygV>`Z?Z_O`SVeoPg?IkMv^lwrHd;uBMOEGobukXfAvmssvSRuSIuKs^MPj<V:tpfEESb:shlWWQqGpqwWYUuaCX=hZEb;as>cdQwdmtQvgiuqx_`b\\FnQxLiVEqdk_iv_eoeXo]Ur?X[cvlEIAmcV@NVhUWMVlykFxmTPmTlyrYvI`XquXa<JpMwNIkEylitVhmWh@uLASXOl`WuphgVF`\\_ZON[?f]VBxWxHYI@ChGEFmSHMWH`]sZgf_gFW_eV?ykyrYsIJAvXEUSEEQ_GSMRIuSIewZywIuIw@VpXm^xnaXx=xKx<nYxmYDJjxSYpQ<`w[aWpDJ^ikVPQoMkiaqmqK=MR<=K:plPplV<PZosYxaYH`kF`@V`d^eWgeGYpawslgrDh\\VVap__WauVA[:psHqsV`asO`qxgYqgnxro>]<f`of`VqqwWaYPidI_d`ddN_OPcpYwQykEolfFfLOdLpuoadPodlwyxiyVHams:Ar:<RIuSImsTndEXaL`nc`tNatjwuxhivysyoy=wiywi<>nohpovZH^]BIymyvmwyxiy@v`:?hcQt_ngVAqKxowpXAtJAlCaVNXs_akHpk`yVYhY`=t]tl\\ExHYQiAX@akS\\kF`k^`Tddn?hj?tjFDM<irExLmlOhlSNIR=PwdQWXPQoMkExLilvZIr=HW[EV;EoNMsXhQuMxExOx@voXWQaRMqVb]mutXHXtaxSQgeIv[Ivv<ijEF]Yv]ixdAwaeV_EXgQqo_AoKCT=UR=T[?Tj]tbGTVqiwUY=WBouBH[EZWcEWCw]Yv]cxuuSiercXdaDYQYeiGdgtdUdy]V^]gYuiXOHS_cMmfFEv^IsMGW_eV?EiVmsxcYtAXcQt_OYymf^yvaYX=qbG[EukXfHuSiunPl@ALdqvTipe]mpdggQc=hbEp\\cahuFbwxksNh^Acd^\\DNmSHmkxcYpaVWQpqMTtVyKoeXo]kIxkaQr?XKSlMXlSC`R<uNatNHAmkTRJuuLMRL@W@aUwPYOTypiwMqqLMTL=NOPSKqnGUM>`j>@Nn\\PNdWUqp?xoixOveYwEVeUWeN]dPod@lPpl@`tNad^`n^@vFImm>akOv>N\\LN\\ZHtb?tdhde^xfIuMfitax;woXgqJIp]wbBgnLgmeAgCalPpl\\ysyvy>qxgYukhiuqh^wfaWbgpd]InAp]<_b>_ZtfhdajpiWAxkIx;_S`SYZUY_eV_=IymyvKdLOdjMv>ICVCIl]BakSV?b@Uf;ufHDVbAt[@Mx\\YrLr<QrFehx>qrGx\\n[VBbuUcCO:^iv_iJIp]wbn_wRI\\gQuoteYwEsWiuWrOitOC\\WfdOgDsdisUPqhiAyrAYVGImmJYpQGPr<QRbdlD]j?hj[LOdNn\\PnJF]SF[UV]UFbn@]m^^kqvUxg\\YlIoa;QkOV_jaymys]VauV]uxhiqrhheu@pewth^ewPiON_OP[[F^[>[EV;IoH=WUqpg\\ywiy[awfaoMeQSHmS@SHmS@MXlMP\\Qv\\AXvAyk]r?ir[Pn\\PJhqwhAwQyoYLyqywIpywYy=eoPUwNqXmMntPqTTyqywAqvGYmkhVEqLVeqt_tdg`txhiqkBAsB_hfAU=^jwhqwiZWe?gBKdLOlfIum@kGhk?In=ujjmyv?pj@p:Ar;XZkNf>A[v^yjYrj?hj?qeGaSHmS@idIoa@\\UV]EhnEwl\\Ox^IsI^oGAlbf_gfrJIn=GlR@mBh[Un`ZV^]VrZay]Xdapc[naxn]OhlOp^yAwyAuthhenbIp]GxdYgiOvmvOxC>ZZ`qv`]upH?hoUwP]yxYyiAsCIs;WgeWG\\SF]CtwWYq]BAsB];Gb;ChkGhsCfuin_hNsvHie=MR<MBHoEwKcR?eR[NF]jVmOAumxdYjAs]tkZ=ujHVjUXmUYZUUILS@mR@lQxAiRGqlg^fgggG`movF_cSP`?n\\Pn\\<Huv>hZAZtyxiy[iv_i^ewPIEYsEITyhiucXcIt=F\\KF<cEt[X:=R:=bHmeyIwcIwB]SF]rSWHa=DMSD=WrAwC]sHqsDhqwhAEkKV>kRH_ECoUwOY;EfJ=wZYeWIe`uE:muDiheutjMx^IS>ir?IFhkGHsfHee<MUTMEdUWeEB:kCHkCjAxjAbMWdM[EWcmKW^V^]V>fhogHVauVa:>jDgn<HqsHadWgeGdV_eF>vt?rZHtb?lUXmE`qv`a^qv`Q^qv`QF]SF]BwcIwbWgeW>Z:IuSI]WVap_rOYoQGdPod@xuxWyghrp?k\\G`qowV__UopFvwxXyhncV@a;@uRAe^pn`Pj^^sFasJqpgChogh?XkEX;WhmWHVc]oTGCiVmCEUSE=GOOSNodPOftOiTcv_ivbcGgcRpmXpkgWdKSV@wfaWvLifEMulQR<MRJCDKCbhiuutkXdQFLn=hWh\\tPqt\\IxAyMA]Wf]OPmoVEk>ar>]mxdYTtVHam;ijEtLJeTOeJ:<Pqt`YweYgguohj?h:PegpjghogppwVZ:hogh_^PdcN_eV_KGdKG:KcEWc[Gtb=dQwdqUteqtpgWauVA?vZAV>sBAtnHemJIoMuNn]wRILddlD]mYtrB=ogho?wevG\\exdiprTh`e?`p_wRqZiXayoyvnkYvaHXfAqk[arCX\\rfiteLOL:<JUTMU<YuUY=ir?iJHmcZpdeHvbAwBV[EV[R?eR?b\\FlbWyiQr<QbJ`bsGisNsEYsKXMQFasFACuSIuBasFaRTMUTohYuhpoh@ufHeeJkDPkbhcUt?feuth?WQqgWoYx=e`mBC]F^[FZAr;WBr[XbADHcEt[bEudhCBrouhaywiy[Qv\\QBqsHq;itOi<QuTQEPmTP=Tb[DjOhlOb@Uf;Eql=Wn>_cF_KqxsH]SF]r`isQ`hvex`[ZQyw@\\KF\\;p]wNiZN_dN[[Iv[ichWjohpo@iiiqqAx;yZY>vCy^Y`rQwewgZeV_efmyq^tqnr@qRVbAp[?ijEv\\jyxYyi]XbAtGuwUKcy]TYyY@ob@OFZ;FZgruyRumxfIrjGV=AHp]wR]gREh<KDC_vpWWdUWeEDQsDAWbAsCdUuQmR@mB:ToPeonXJgeoUup@XpmXxWTuQeTOeLDMSD=lOhl?`of`OVeqteLQmoVEttaPPmTP=wTipeLYpawchxc]K_hWVeqtoatAw]^iwixQApqxpAasSX`kFilaf;ym;ir?irr?w[xjZav^ajwXiqQndPoDvyvYXgweqcVCI\\gWEkeXoejaxnaReqtgghxkfoTWbd\\j@P;V`mV@OdLODNatNAfn_hNcF_cFTqYhQuoWWBmSHmRKETK;B:YsEYCKGdKOuxoGb;GbGruURbKUV=BSADOeTO=inEwLkGX]iB_tNaT^k^GWmpF^b>_BWwZ_dN_dbwg:PyA@uGpcCPc_PjDgn<Xj=XjpXdo_hn_beqtghp]xhxpqx@pppp@>Z^`n^@^n^`Nv_y`yln\\f>eZNuqwgc_r@qr\\N_dN[EolfFrEy_y`owYiSGeSNlLPljGv<iZ^f^_Fvdite@sDQs<of`o^lYxmIdN_d>PqtPag?vRwuJisGis[gggg[av^a>qr@q:itOi\\Xn]X>kGhk?wvHimkyuyqyQw^mNm`bsEx?yDkiuquu[yxYyYA]Xn]xGuwOitOIF]SF=UItgYkQv?eg=SdQwdA_eV_ENcDOCWUYH:[DN[D:;BNOS_XLChsG=ZZ>ZC_b;CgcGKUUUUcdQwd=isGicUbLOy:[tGisGkuXquTIUHqTgPtuyxqlXdPod@Ph]ur\\yxYyiAiIya]?ujHfGOyvipeCV=ijLTLMdgf_GF]SF]TAjjv^avZ_gf_?of`ovHsShlEivjppppjsHqs^_gJehtTQqgxoMqPgMuZhUupXtDMsxPkuVDTKEDlR@mB`j>`J^tNaTWWdnFasF]LQtL]`of`KOeTO=OeTO=PR[@jDen<pR]HjuXqu\\UV?g=nciv_ifwBvqaxnapsniyoytY?itIwaHvZAv:xexGy_qp:XsR@_dN_<Av;YjkGx\\ibfIumxZ;FZ;fktaugpyKilevdJhlOhhM?`rw_yAc]Ht:qtPq\\Xn]XfklykF_yyoysyvY^[R>`:Vb@`[;QyoYwU`vI_v_iv[F`kF\\CHkC@cHcKGMmqnpiTY<PPypiPy:Pt@qr@lSHmSjppppRLMTLlNH]mBpoWUq\\<Ob<KXmUXMYGLd@`xnahf^er@\\Yaimi[Vf]WF`eotf^ayaymQu;Hf[HivIxAIhZAr;^mvFilqkM^ZQx?GdR?eB?yrAYVmivEUUuCSEUS=GhkG@eXoehPyifweb?hn_h>gcGgsGUBeeWUqh?=TJ=D<Ob<_BSEDJaF>SUVSW>aGR=h:oCHkC<wFj=UsOX_cVlCE]MV\\]BoWV\\QI?ir?axoix_YrIsIf;yx[ecST`?Hr;IR=TUcGWgBEkDJmFMGXEqdgKbSASHmK:lRq]Q;HPJmTPmr;Uj@Dt@qr@uWAitviyqyu>vouYdF?wHXZAn[J>jXwxUpesPh?huthh]hlOh\\QyoYwoqVqt`^yvaYHf[GfnWhmW\\_wyy?cB?[YAi]i[wXuonhHamsVbAwbAo[WNaN_l>PfsIysalCafvixQyeoqguH`VoqvGminqrQ^OPc_fuWiusIyaymeiiiivlhfEA_MHsrXiqqgwPuo^ZFGZ^WZ>^Z>>x_ylYotEho[YrAXtUYuuHuXHy`?cFX]qnkHqsHasFasN^uP_gf__;>xrIx]QjUQgC`isivQ`lB_^vQxEy_?fpMWdMWbOPc?itexdENgahnK?dJcAucX[Xn]X^Ih]HwGqwCY\\L>ZIymyvoqVm`^hAOdLO\\;>`hn_HwopWodPorfgTa`D_^LncX`aSAflh_pnjVauVohhU`wbAwBi[Ur?FDobawexMe=mbFCD?qhkOdV_eFuHqsHpQwOYc_eV_MnKinEuLx`xLYS\\Hui=kn`pnlqjQrE\\TddlnaxnavQxUxEOD=jw]vBILdBYyYyiYwWup[BTmx<Qx@;Ip]wRksWWIAGx]yreirXQsOWGKETKEbQuUweTikxTMGysyv\\oYuqXtuvUxGpsMlWn\\RqpWWALJ<L:xWyhyP=XUeOGhoUup\\ilQmU;amsTXjdXdaT;eWCaVl\\J@lJ\\lQxlUJUQgDkf`of\\xhiuUtlhdU<]SF]KtpXgQoqTuoYsFXwQPOU@Ph\\MWdM;<JsDQsLYoXoJ=Oj@YkQVfMunHKUlPf=R>]R>LlMXloQo[qYBIsCIRypYwAlQxlAhYuqx[hWUqp\\@wBLKDLPoInG=NwdQWTJAlK>UgUWfEqlgNj`visx\\wWypirXhau_bmxi]FgcGgR`asO`viywIpmwvH__UoPMXlMH`oSWOC_OTcwTgCYsEYrMvCwFJcEWccqoutUSiohGcBM=BsUCeuthgR:=R:Kr<QrnQVIIuSIEYuYw\\oSUp@TMqlWNYkGql@MYtMQ`pSWPkcXTaPv[yjYltUhuammsoivIxAgwxQaMv[HIl]vbjavMxc\\Cs\\qqquuMYkHMN\\L>`j>`Jw@udmw^hn_HNdL_dN_d>hjAv;_piwuXwopYwm>hTPZBWv>Ir;IZDfj<ww;^fwV^ACkMx^ISBefL]XgQuOSepcWLcRAUVBqsHqRn]XnKcDOcjwWYqIrQytQc`gf=ubH;ivEyloHcidCWIMWLATj@dK<PS_PrpiwUiRYyvPynIuMVXQqooWWq`Nm@XkQv_\\Iqaqm=xqyxapwwXikinqrQZaysYxrNH_M_xX>a<vtMNjGx]yn]^Fphgutp\\U`vchfxWwu>dOS[yfYoY<AikUvnQWq=ujGVR_IsMH`_SSOFdUFgmcJ_rmysysCoOUGgREoDcitpAikUvJ]UV]cGYeqSwOqWmevfIum?En;WJKyoYwAgvEydeishubHcEFUfaQIZausWXBOcDOb_gf_kCV;I:sGiLYQATYhSstQytUiqpG=w@tJAtJ^uVaUk`uuAyrAtjHdM<AmkTVjAu]uk[MynIwbpohpLGuS=]V`mV\\xXiqub@ob@rxhYuAvgiwgLoX@nZ@N:<PoYnqAnb@oBTR@`K;eV_eNpmwVIWJtR>dR?eR;EnJ=klTKsywyxy\\Mt^HSjyxqyrXiquExOyTYEvvIymAYhIqaaRC\\MeIUj@ffquwX]yfynYlpgd>Wc>a\\:ou:qkWVaxy]uwvWf\\OixwiwIas:A^wXk\\NnZ@_L_d\\GbGf];?bGprZWkRAp?gk`FtRApUVg\\Wk?V_b_w\\wgRAld>^?q_ZPfN?\\C>[BWlKp`mxuyNx=xdyHp\\asVHm;xfgnleG[ViyFaehimuxsSyfY^qvGyLnixoiLwkwpfGQ]bQwdQrYyuY^tJA]Q_g>fZ?FvlivEAuwXiq`tqXdbOunH_v`qv@puwxhGo@id>OplPpZYv]YZuVau^]v>iJOoWhgg_gf?xvIymqjSWoi>^sFaSncHocbGt\\hZ\\N^\\^nLobxqanghoW]L>csnrBAsBFysIyFg]Tf`d_jgWupHfiquw@ukXfA^mV`mdwpKFfGohpo`V_eV?^NN[Kf\\Of^Pqonhh_hfEqlJwdQwgb`vrAZ<Fj:fytix=yayay=X[Qn_Bhfi_dk?nhpoHViuWi>_b>?cgnftOitnbGP]?VcEWc>ar>AfAqkW>ijAv;^ywiy_nqqHvAAkF`k>Qj?V[jYyiyq]XiqqwFgeRWtJ@bxHrXhau?vdQwDpvGYmEgappj@pZpiwUydufaYArQXlKHl;HgMqn[OynIwFq_nwiywiVoqvG]SGeS_c\\Y_<fZ?fZjIxkIjhpohncX`acfxoA^oVnai[IvaoW^lN`LnghogbQt_X[hfet`dUQuYh\\tPqth[=HZl_k[Hn[NhlOhRWg:>Z@h[Unj^`n^^qtgxDvewgxONb=WbSPyvVipa[hn_h>vj?aB`kF`bmpFkfxcHj=IVobo=dY;flOhLSBAkC>MSDMCHyeyscPigUUhPMYEsHqsHVEileR\\IXX[Ir=bKSF@=rDQsDCxkIxBKCD`pn`PFPMoLKD_l^n]yYf^av^AfbAt[@ypYuiW]tqlZH^;`o_ivEylrVipaoNQmaaqEViuWi>^Z>>fPaOkwYyiIas=EDZKFFGEmkJGeSk`VCQL`mMwXYqqjxpqxlxfIu=as;mmK<K><wWYqqLKET[n^`NHst?\\MWdM?geWg]qwWYqLwkgvwVpawO]XquXAxkIx[OlvyqEpj>NdxH`n^`>Gb;GZegkT__gf_K@lJ@Ziv_i^xgYuQV[Qn_>@c^Nltxb@ob@^eVCbSGe\\V^]NTpPgMOoujIDV_eV?`tNaTPQMltjJ=O>AkKTNJTMUTkmxVIQrPqtPhpLyYjUXmUrMynIEx^IsMDkVtyxiyuAxmYx=hpohPLTLMDpeuth\\n`pn\\]rBHLlDlrLJyqmaHN=mj:UTMULutXhalshqjDUJAl:myYtZt^Z_gf__[R>`:HoAaysYx[Wf]Wj[YrAXsVQqDFi\\>`j>\\KGdK?uwXiq^dN_dRHijIyv_iyiyqAuwXiqWbcOxaO^NN[k^hbAdvnIkr_YsQGeP_xn[HLIyvmxgYuAwwxWyHSFAmc>qywYySogSEYMob>KTxGWVAikKXmUXSUWvgbTOeTkxgYuAgsUwH]etdgTjIxkIddMduavCYDr?ir?RMUTMCdKGdFUS>yuAUrTMxyQTMYf[asSWHrCX\\<uUYumpTtuNWQqoUjdPod@uQIR`pn`PvuywyxjohpolWVAq;hQumxZdPodLxmYxMTWmnlIOFYmqtKCHkC@KCDK[muRASP=WB=NyykwTYpAvuxwxXj@pj@TTIdN_dNfiuuxLcEWc]Sams^ImAykYTVPaoS=mmtVH`Tq@KruM]xRIpRtMi>qr@QpPGlU>kBBy[y:?hj?HVGImmRdiutsyQobAweIYVMqfG=EkKV>kfIueHgGUmhBat=AbXoeXUR<CGAAER;EjSw<QykkYrIvA[r>arZcGgcCYeYoiDLWdMgFXSx;YbA;XpmPWeUW]UsPX?mNTtovXKeUWe]ymysydKeyky_b>x]y_yKVyqywAIt]xBOitOhPMYiKGdKGj=Xj=DUMBsuwX<Ml\\VB\\WgeWkUypiWfyuyxMqqwWYrqyuyuOMhMGusVHQ=hTepT[Ut`hSbAukXNeeMSIjSqKNPP>MUTMM;<nj@pjltddp>lJ@LlLPlLdN^\\NjpTKXO>MNKDYr=YJhoghOMhk_uuAhmWhMGPMoLkopjVAPumxfMvkAYnMwNIOPQO>]RnyvYxYLpqxpQeeKs@VkQv?ar[AXbetdhTfhTXIsI^yK`mV`mRWgn>dAohfAu;OuTQufh`x>cxoixFitOiLPkDP[gguthd\\GhhquwXcGOmnF^uWiuOisQx_`r\\Ak=`sFac<>bKItKaoO_f<HgMqnKPlLP\\Wvax_moPsaFpvGylOgLanCy\\WVvHimu^veYwE_ehvlf_gf?wJIn=_^NN[?aFmbAucXCdHocHCyuYymoTKGITKDBMFD;CB;f`isUWsNyEl?S^KFquXqMhpoh`OxlQXPQIlUrYuYwiRvkEIOv]YvSUgvgr`isUGSWeUWOcEWcSUgBaI;Gb;_B:ohfEu<QU_odj?hjKB:EIsCIfgT^mDK?S>uIwaxMCxr]ITqhgUEeeeqQHumxfMWYqiwSWGoBdAskWnK<JdPodPVgPx;]j<ENGymytmr`UhdkVDQLPsDQs>QYvYwQyoMpqxNhlOh\\PlLP\\kp]UOdbOgdOsniq;Oef>ej@jr_aXf]v>iJhpDy^Mv]Yvc:>wxiyuymwYqqpgWQn;VZ@>\\AXr[VeUWetNh^AkFgaiwqIPplP`dAukX^SIuSIl:?^Zgo]VhNYy>Ndb^\\LHocH_GImmvjoPsy?sBAsZfcGgcTHamo^eg\\s@^qv`Q`xoixcOwNIofhdxYb[Gf[FocHoK?fZ?^eg\\SpvNIoM_r]IXgIumHeedq?YxaQ<<RKDLK\\oO]VLPwdQWTDQl]NkIyvMQv=yjTWWxKlPV?QKdeuthPeek@LwB=Yr=Q;<nVauVmtdtm>IumxVCuSIuktlXfAScIwcQVslVf]WfDWeUWMxnaxnRYLMESLIoMuNTHP]mJeeK``oREp<@QVlK?tJATpPEyfLOeTOCeSGekpxWYqyCyqmUv@iKdyuyxQk=QVLwJIn=dMulXF`R\\Dl>dO?YsbHT]@SQuTQpMylYFQU?mNKhq\\UVcTLOdL?`sF?]x^irVgOxyZOgdOkoVgPAfGQmo>cB?cZsBaIysyvYHn[Hn;hfEulktdsy;uRAuB=oBGKrHgEu;Ue?sfCCCCCRKaRN`^?[Px_YosTwvg^kGhk[hoghkn`pnntdN`Agb?gZvgiwGh^AsK^mtfhDVj@f[\\gonIbNatNA^J>[RWgnJtPqt@JZtPeAUuuxhik^av^=Xs`UnEwLocYpawibAYkB@k:woXgqZawfakMynIWs>wf]yc_hcUp`oQyXNyaymyO^Z>^:V]p^g:AwKYnSWwvo\\DQsDAwXiquNf\\OfxNymxtixeAwqxgyJIoMCSCES;Ix]yrkWXaiCGB=kBBiSqQtgYuqWviwixQrxgYuAV`mV@QUAmH[ee;Qh`]vBIdNifEuDPQEiiR^KDKwfawFSMUTMteytiGUeAsfsVIqe_;BNKETKsTevw_r@qrL;BDMSDMVgOFm]fawfMGf[GFsGisGsNQuOyHcIt]wBwAy]ycfgH^McLQtLMXmUX]cEWcEDgcGgVgWxC]WYqiWmvQAto;xxmewSY@=B^mWSOrAAYwQyoccSSH@?IVkCGIemsbdWgewIuAE[Gf[_fdOgDUbAsC`OsDQSC;UDmd?WCQKTUqhgEUe=H[Uypiw>Ivj=WoQwOagOMwFQv?YcCatNaxwwuI]SF]fxcYtADAWr[oSWOIKIgMuf^QW@Ih@_f^_FLETKEfsYxaYhPEdcMwoMBsQwOYGLatNafGWEqKhPEyZCeSGe^ggggSMyfIuVgOFM_dPodLGgcGGwuywyxfgTxKcGgcGccYsIXgh@_SK]TN]RgMunGFUUUUMGdKG\\egmqUviywIsWiuWgh@_sJweYwSWUipeF]SF]KiohOPQQY`sxiyuIk=GfgHt:g]sgxdilFy[PniB@nZ@^d_tbH\\sHqsHtEx\\inasyxHh]unbvoaYpbH`]Swn^YdP>ajkNhlOhVxeyd@qSYpauKkAYvLUv@YkTWOxO\\LN\\Lj:<tMynIuutyy>`j>LwWYqqDJZpOWMqJImmtV^QPk]Ntyxmeo?UkP\\vcIwctpQImn@oQiNfxNH]m:eR?eJ@`KSLrTev=`PimuVTWQqo?QyoYwKtLQtrTuR`AKB<K:@RZ<rtixeIUe`i]qrGXr;XZA>xditentdN`;gf_g^@^[R>Z;@B[Hn[T`wxQMWQqgWeihsitUdfawf=IuSI]irEwDBGcCGRAoCW;UecYlKUTMUZKFvoYwQeoOS=cX:eUWeEvmIYCysIyfgTdabywiyKv\\QvjavCYDRIuSIvTiheuEwiewYyqYVJAf;=EmkVFkXgQu_STUQvvmCgMunGROeLChWBuOE`MwLYNTnAu[Ywiwi\\En\\f>fgXx??uUYu=xsaY^tNaT>ZjgwTi`rAyrArXquXFysIyrvhha]LV\\MFtaxcYFqcfdwW\\[@dBvayvaJF\\pywYy_qxtS`pbxtC^vXhauSuUY=Ar:AboOsAExqyPIuSI]kTdPdHv;W]>yRAuvGYmktfGU]ShuyUwGsjIv=IFNKCk=xZIRPQGFIF\\;yuYqoYwQILTLMDTLMTLPQSY\\nWUqp=sHqs@EXkEPeeL``ywyh[AvZU^KD[kF`kBPkDP[gOoIEOeoSVGsxKEy?muqQxnWhmWroYwQXVAqkjMXlMr`hSUpuuYpulXfArBIl]DPgMun\\WXaqSmOY\\se=osxTv<YjWfMFwjoxfIeFV]p^[Mx^IorDileFEsUFOgdOGtoXgQc]wRIOrEYsEcuuwXAETKEDHyeysUU_SDYHygypYE<Yr=IX^AsKCiBYCRWrrmBNGEIqewSFhsdEuFH]eZeglIs^eV_EdhoghcyvYxIagO]V<OcDOClGhkGFIuSImtdse?weYweFugugdPShaus`kIYwSQmgVEVgOxC]IsMx>?BJ]UV]EeeD`]usWXAOenCW<eeusX`_yvaYPQIoMf`gEwmR@mBeed@KopewTIt\\hRE@Ue]YkLNK@kP`OSMRvlMIpjHdMDen_hnieYyysyty^lKAXREtLh\\V]<O;\\kGhkcesThPfhP^ls_YsQHS?eR?prHhMetp_amyYSF]SFDmSHmK<JtQyeyocQv?Ykfhl>qRb=WbDXs`USPux\\SPIoqHK^QsOXOCuUYuU`UMp]qIhUupXKtlEinR@mRltdVp^GsLNdQwdQXqPVsKITCBZWeqsWloT[mRZ=VZCXr[ETyhiuEeedImRb[DLOeTOE?cB?ChPEV<]Yv]IcQwdQdEWcE_ufYIqqGhausWR:;wXiiu]gOMEbWFwKYnAfYoYtIcoobRAirEx\\CER;EJghogH_gf_GDKyiUiI:ToPeo\\]WalUVhmWHwAxMx=VgHNKMn]XnCeSGek@xKYloJTwbQn\\PnBisGik:<lGhkGPrgIkvavCYLLYtMYnKTN@=pPEleLwgEKeqmwTYj\\VBALjIyvmtdtm?AoKUnJYqquWFP]NNsDQsRWwjV^gf_GVsPh_=Ql_Vc^qo?Qp]Xn]^_gf_khIgeoOCMkSYoIGGGMmfZEylivRkHf=EeeeImbEiv\\gWUqhoQXW[v_YsQGtmwVI=ItKI\\aysYxJatNaVg_Ta]hn_h:;f[UGICI@Ar:ABisUx_VgGFp[IwcIkeytiXbWgeWjwhQveYwELJ<\\Up`gOrFImmFeeIkOppgWu\\qywYyfh`^nb<Ob<NypiwEvgiwgspeiP[:FlKHljghogjmXpm^j<G^<Yr=I\\UV]En]Ixdup[Loucv_ivjixoiNmqvgHh_UopjptKX_dif<FmV`mF`tNadS`uuIxM?uthheN[EV[K>\\J>rTgjC^b>Hh]qr;qtPq\\yfynY\\egmtF`x_yr_]r>hZpuGNZNawoAax_yr_sXhAegmImlPpdxXC\\vkXVAAtaxcrqxUygk_wRI`nNgNAkoPtQFdmpZlH^;`lY_hoghON_;`ZxiuqIadN_Dnf`ofrnhfA]v^av>`[Or>ntTOfAQr<QZcIwcaoo^^<ioUwpZiv_iZAvZA^]r>h:ogMxrB@kB>auVa=itOi\\Vn[AFlKHloHs^plPp\\fawfa\\`FjVP`_O[Xfat_j]vbH@sOqmdPp:gqF?^qawSYZEWcE?uUYumpdcdkGhkkyvYxI]WVAiKCTKETfgX^ospgWUAdR?eBgeuspUYMnAx[YrKmUXmkJ@lJltdLT]It]xRbYuqxOtmxfIkGXMqLpPI_f`of@lLPl<Qe=Og>fZ?FfjAv;AmjFf<nxfIu=f^_f^PQcY_cGYb<Wba^fsibKV\\BGlB_jYoisiZcF_c>mnFgLnoXgqDv[Iv[v@ikQjoPmRGpn`p>YxaysOnwtYcCGc;xnax^tvhhak]xbIPsWghU>Z>xjAXrSU@WeUWEN_dN?DOcDOUyyuW\\AwbAgJCC^qgWUiJ[DN[byoytYShQe;Is<cxhCbf_gf_r;YbACH\\]rBktdsU>weYwEtixeyByuYyebuGDy=cQ\\q:amsThTapcOhohh:yy\\?fZ?j;VZ@>fAqKSWOCgJwdQluXqujtPqtr;YjAdvpDxq`pn`R`mV`eqRhqTUp`eK@ikUtjsXXaQV=qjGLXWiykiSNitOIJ:dn_hnFhST<oeLqtFdN_d>Qe=_gNgdOGf>AKKb=Wbk]vBIDfmuvGEkEXk=sFas>ufHeeJ?dJ?rTETf]hheuT;ryWBDOc<YfAucZIv[IBEUSE]etcXDmwd_H<Yr=Iv^av>sXquXbCGcCFtKITsThPJatNaxXxaqMXlMlwWYqattW@limuvHkCY<SX`aSnYwQycoocVMTiQDBYDakSZ?gb?C]sRH_VgOx?aWSQh?cr?irlEUD;UQmYwixQ=WcEW[muvGYfgTx?ekUv@IFxkIXsXiqu_eg\\CT>KB;KypiwE;J`aclge`Nthheu>k>O^?xg=waqowV_sRH`=VwPio=Qv?UPQI\\uREUSeoUFKBbKGTKETKCMmyYmUXmciqiuqCasSX_rsWXaAtywYy=B:ubHcEJ_eV_CUUUU=IuSIe[sTGYmSHm;Xr[E?GuEKH]SF=kWhmWjcHocduwsqwHMsRxseI?eR?EVEil\\MWdMy<yumkHpkZLN>ar>ASCaTv`LPlL<ytQyLWYqqurlhVEAUeAsgdxhDjVIqmuNv]Yv?uRAmoPsQVt^HcM^gTapCFj;Dh_UsOrTuR\\aRAuR]uuxgYRuixeIn[Hn;UeaYkkGhkGbUt`gc<us<MDKkRH_ECwbIsE\\ayshv\\uoHyK[EV[EJ_eV_ejWuJcLLC@PcMt^\\oTepDTqpewLXuolrYTROeToHVY<SslR=UR=ENpYVgdOgdjqxpqloXeqTUubPwG]XoeXkmxfIUFamsTLy\\yjYJ@qkWTklQhF`g?YjDPKoVGQe[Ix]yrfgTx?ef_gf[xfIuMKytQyr?X[QBnghoGUecYLcHCMfuWiu[TN]TJSDMDV[EVj=Xj=y^xuQytQyjoVgs`cZFkBVrAx[iho@_lQQgbFeZpe_>lItIPsOXORtPh]MeeLkHP^=sJ\\KR<P:TVAqkO=wL`odPod\\ST``v_iv?xgypYQpPI\\E^]HvZ]orFHrXiQebw=eG;CB;rcYtaGXnAwKQuLiFsmRCESCcWTapNatNmtdLVaPodPK=yjItRj=XjlkXdQd@LOMMiYRGeSGEniylDpk@pj@`uidub<Ob<juXqulwYyqI@kB@KnuwXiyWxQAivlEp^EsL\\mtdXDtRIp]av^a^f`ofDGuP_qn`gSQdhyfZVxlQxZIv[IZOR?sdhcU<ocHoCeefIODPkD@sRAuRnawSYDGOEoKRF]SFkGYmivIsCWvU?ItKIDiV<CifEul[Ux_YSsbIsE@Uv@icSUwBiHoQG;_usWPRTMUTrEYsEhpD@UC\\KF\\rexTi@P]mrFltdLL]euthXrYyiyq_qpsQsuAMoLWN\\J<DJH`MsLrTeRfaWSQp?ToPeo<=Xj=PVauVAUeAkGTSEUS?Xm;`YwQyolqwqxU]mxdi<Wb=WgEAwNf\\??c:OwmNeTOeJN[?Phu>xPhmWtSIuSCYsEYBocHoy^gxviYuqx?MTLMD>KB;KIqmwF?xjAXc;eDmbPgGUMvcYta_goKwFeSlyUWPMQpOWMlsQsTPmSiRIn]JgdOgoWHxhXc\\Ae=XpmX`hxeyp_QwxKYcQTR]hbEDxAy]yCnAwKYbookapu^<lOitOAyeyoy@Pd]tbdjbaNrqNGXMqlrPhOU=pwUyp]Ut`XChpH@uCasFariuqwqjsXXaQsWqmIxM]HX]qrbytifjeVfwPh_Q[``cSPj?WkPFsOqeIxm<WqpgwNN_;`_cF_;xlQx\\\\Yv]Ih_QsOfjDoxYyj`pn`WrT>csnn`G[=`aw^qPAxrIx]?ar>a:?_NN^`n^`YptxaT?eR?vTiP[UWeUKYgQuGfoUwOE>]F;UUCAVhmWhshm;d?ir?hv_ijLPlL\\jAxjEaxl=oT`NKYr=YJdQwdAqtexdlOWsQyUyeqIhwbAwBPwdQW>ir?Ik;aTlaQumhvayvA`b?tZ^cWPaOhpHPbJwgL>sJAtJ_v^aVSH`]CeeDC?veYwEsUYuUFWEqkC_cF_[go]rDyGy_y<SV]UV?ge[eEykYvkgXeid?H_EdquwXijxXyHTR@`K;aysWpPI\\ufwTip=YnAwkJgdOgrTs\\MxlQxZQwdQcnaxn]RAuR]WWQqgfgd^ObTOeTUR<CGAAseMBSOdLOBAsBA;wdQw\\kF`kB`kF`sew]CGcCG[Et[XBSGP]g:aesSXj[VBADsWYY[sFas^QH;lTPmJYtMY\\v^avZ\\Of\\KGYmqtVg`xHmOWMaHn[H>xnax>PqtPa\\Wf]GhkQv?Gp^nko>]UV]]hdepdlGd@QeSGeCveYweRN]TN_VAfwVcdic<Fq]wrH>qsHqc^uFntU`Z@nZ\\`qv`]MqnGWfgP^pNb=Wbk_yrIhfouvH]dN_d^oo_^<XmUX]FisGi\\\\qrPhlOhZYv]Y^hdatCFr;IrDVpoYrU@eUWe]PodPchy`=qsFas>XlMX\\DXkEH\\UV=QuTQeoOdNATOeTg=U=CGAAs]MBS?eR?CasFa;UR=UZKF\\KB@kB@cXxkDAWr;ygyoyDWcQsG\\KF\\KBWQioUr=ybIcrbUGS]sGiskQyoYWvYxIyIfgTxCeToW\\IwcIwr_YsQhFmgcygSgUfitewtUEc]_fDiHWgeWgv\\uGlyeymySsxivrIx]ihu@Io;x_ape^>lIyMIX[Qr?[cWSIPghD_Rk;Hj;rPgGU=DV[EFWCQkGjotsQVDYsEIH_MsN[CX[IryIWIwNCChsdEGh]ur\\uwXiileu[uSZ;DZ=ZZHDGDHwEykGQWEcsYDcWT^ehvdhXsRw]v>i:v^av^bV_eV^`n^@GnAntXij`pn`PrfWZKw]cHcZfv_X\\e?ir?aViuWItwXiq_myviXNeTOe\\GahXmUX]hxeyp[of`o^hgQuOvnIwmPVskg^GWsPT:;dUGUBQsDQSvuxWyXrWXaqCh_UsllPplfhlXQn`DSfitexLndPoDLQtLaDt>Ip@tNatN^dN_DsnYXEquwXYkhXeqT>dJ?DngUeSWwb^\\oQ^;`uwXiq^hn_hNnnuwvA@]j>FGr=lrrpsxPRr=J:<L:`N\\@NdHX]av`YroiYftUx`MsIysAUmpVGTWODkmLYnAWNtLQTvrIx]aoOMw>@Tb\\rJIn=ExnIwM]mytYXmWTImQiJOeTO]pfEuLmWM<sUxPiMrSIuSdSUpP?]V^]NTNuNhpL`tKAtJAgbFfOXfnf`oFZByrF^vcXda@tuxhi_xcYtAvrIx]QVyxFjGYmqvbF_cF^iwgiKyqywiFymyv]\\FlB_ok^rGWp`gsZ`of`_QfknOodPoj>ijAf>yrAYv<iJ[WgeWSUGOQTM_FtEYsERUUUUCXkEXr?X[QruUItQcUsRAuRNwdQWFcCGCMGkqIQWIqmwZybYkY:ahcUtZYwehpHPr[@xC\\><TJ=L@]kRDnjXP\\tyEqvGYmKeUWekYxYxImoPSWHSIuSAywyxyHhrExL]HUmpVfhX^lSMpNG=xGyPYAsgqVKYTapS?=UR=MHamsTNMhnwLv@mUUDw>ar>ArOitOlppppBTKETjXpmXTW_lNn\\o;`liMW`=x^eYPDYYqaZYweYkKV^@?fYqQ_rXGRN]TN=hmFpgWup^ykyrY>wMynInex`icFlROv:xr]In?WkPN`yVZc^\\DF`v?yj_ex`I=Wb=GtsXhhpL<JZQr?XKieNHHxkIxrtYxaqNQLAQMFisGItvHYmEmfTVglOhljixoiLQoG[evdh`fgXnJ@_vOZSn]XnkavcX@_NquIx]=wcIw[UopfGrhiuuH\\TN]DQeapcFomvF]gQuot]ycyKhPEdTSVAqc?]Xn]HX[Ir=rTevm?ulgVEeWcahwgiwSWWCgZeWgeGqEC^=Wb=Gv_iv?vhqwHWXaqsOYwo?FdMWdMCQaWfoI;Ivj=fhoghStm;dUwpFHL]lRZMunHWRQqoUoNmPftMqlWVLn]Xnkuxh?wLiNWMWQlr]stPNeikn=kBTVAqk?ImmtVjmvFIMS@upIn`mXKYuUYMTQuTAqpewTlsYxaWQqoWf`a^EXy;O\\KnbIp]GxDwTBCCCCTrgeQ[V?cbI=FqwWYqCAsBACeeGUQ_HwYyqybYweYkrGWEAOr<QRPQIYgr[YrAGDPkD@?r:ArteX[yxditEkf`ofBKCDKVgOxCaexcYTST`_k_YsQXVjAv;aoo]n@hn_hNhyuyxOmin\\ePVLQn=KYqYuiO@tKX\\kJ@lJPYMekkqQTlt:MsyLwdQwlTQE`qfEul\\yrYvI@Ux`ifPeoPcdhs>QqpgwDX]qng:atNa\\Ywiwi`piwUy^o@uYXjfvg_Ib>?mvFiln[V>a:XfAqk;itOilcxcGOlbiwgi[WgeWQu>IdPnZfg]Wf]Kv\\Qv^MgeCyiyiyq_msVh@vjIjCUl`\\oo]LQLTZMPmTPCESCEkpqwWYsTejCdJ?dJ^]Wf]SxmYx]oOmQSPtLQTdmtfHMGHMmljoPKMlLilUFmR@mRNeTOerTev]`N_dNKPmTPMG]mrDloPkNISB=SZ<JNpmXpsTev]`WSQp?@YvlMGUmpdk>MNKTWWDmZ<Pj<lnixoIUe]PjiJRPmTPtDileDUe]q?@S^LncYtaXLQXs_hOUmpjdXcPodPncYta>Znfhdadd`of`fdYxy`_SOp>PunHg=Qe]imFAmkVjN`lN@w>IkM^cwNb=WbCquXqm:>lIxkIfeuphGHoIYqrxiyU:;GpkHPghDCDKcR?eRKscAYfoSWPAhPETr]DtCbVwHimEocWTaddKGd;Ue?H][Hn[dr[EHcEt[XBghDyFkSYpaWLItKIfQsGX=hPEV<YdasSBWs_QtcxSmpTsANIqmwTNMTLMLXmUXMHqATLc=xditeLvlEqn]yrIXPQOY\\V?QkO\\r[AXbypYqY]eo\\TTVLQn=kr`UhTWGpJx@JMUTMMUkPV?TWGPUdXoeHWfAeCGeSGmpywYysTwnPXbAp[Kpj@pZsVauVdhoghVgWPe<Xj=HcGgcGhp@yiROqnG_kGqVOuqxgYV`AXhaqswhlrn^^^^jVhsa\\F_cF?gcQt_`oo>_av^APmpfgDwuxWygWrZGoN>dRQ\\PQxlQhfguth\\]yrIxoQivTouXquR@akO^`fcT`jaysYXpPIyZFwcIwRwphg]Pv_X_[=Wb=ott^cbGulh^V_eV?\\V^]FQe_iQCb:cytix=ocHoCHwEykC_eV_mtDMTAeUWeEgKUn?RDMSDSWOwX<]RRGImmF`qsWWcGWEqKVXais]gO_VDcIwcIB_R\\Cieswi=vyYTMIcOmDb_gf_rJIf=Ehyuyx]EukPxxyxYYPQSo`KX\\QRDpkHpBQsDQRaqsWHXwQyomtD=Jxiw>QOJ<K^MwT\\unHWMlvIymIhSUp`jHf=anXvyLinE?wPioUNiqqWAr:ABCGcC?IqmwVKipewdcXQws;ir?iBQmgVEVdATMICXeTOeDuoXgQTBiIbgVGcbG=F=MR<=TLMT<GCMkFjoT[msYsYvIB=UR=]cVCIL[R>QUaiivQxEyGj?hj?r^GSM?Ue?H?yuYyEaqsWWrEwDi;Ue_yAKF<yxYyYIwVIqe[arCWDDciWuj[UWeUkuuxhIpPAyILR[@LMlNF=rtih]wsXhaR`assTES`AtOit?;BSOYreWZYxZQXsOHkgTOes:Ou?WCQ;DTKEDoiwUyloTtyCgYuqwR\\MV\\KuoWWAsBAsBfiuuwdoOTguXoEUS;uXYhauKWPQOTOP]o:arCXL_PMuLN\\LJHpkH@wOYoQ\\XoeXK@mR@kmxVIQnEulhLToAoelwhqwBxkIxVtxM^Qr?XKKtMYtk]xRIpteyvLDo<AY@\\T\\=uSIuKAp[UrRUWBaKCHkC`nfboYwQYhPEYasVIqe_<Ov\\QVhpDTX>LJ;DWeUWEaVGtyfIumHkIyvM]SF]KeeL`aJ>\\JJhlOhLeekq@ob@oZHR=pJKP_OGmiVj`Gs]xbI@[:f^av^mpdc?nH@uTQuLawSU`oC?gb?_vZAv:MytQyN_dN_rNivM=ghog`GEmkVJ;BtIyayeSogowGf[G^;BnEx\\iR`mCo[EykYV?YvkEGIem`T]qr>arJXoeXO;<NquXqMqtexd`T]YkExnIumL<JtPX_QKM@yaysYxNHtj=UuqxWaMLypq\\@lC\\VV]UVDJZ@yrAYPQOldrLnlJWn@gkbquwXifhdXQnv`qV`_f^_b?v:IjfhDGV<abC[VeUWEQU]iGpuoU@JNYu``TyYsxiyuISSEUSmVPAjPhlOHlQxlQDWcEWK]R>]JeeMSpnZ@n:@JJivEylSUonBYuYwiHGQeoScS]yVauVMhmWh]SV]UVDESCEV`ITQkCX[IBMWdMW^QwdQSsEYs]sv[tNatb;Gb;cS]Y\\KfEudhCDYwsaGSMoFCeG`]Yv]IsMYtMD:KXlMX\\?gb?GcgrP_DgOUoOf:?b:CgAisBAsZcYweYTkIv=iNYVQyXNKh>gXwQyoAhqwhaMiqkcfKDJ;D:SIuSIrIysIflOhLghHeGeqtgWrmyvIIhtexdmtdKH=AgKUfjuxhiU^sFaShPEB:[R?eR[]yrIxRgIumHvayvAUeAs>khpohbOgdOrwYyqIUe?fb?gBkEXkEBmSHmRr=Yr[UV]URUGCaHtOit?vj=IGcFfOXFsb=IVpwdamV`mFV_eV?TLMT<?uRAUREUSEHkAgeSR@_C;]Wf]GX_IsMbHieuhsUxPS@YR@mR@PgDVGXkEXRyqywIPb=tZ\\WTapCMvkQlMXlKynIuMnuwXiMipUwPr_sBOcDObMWdM_r]USTsHqsH>mR@MSokV_eV_kBIkEFSF]SFfeut`T]uPZ@je=NyIyayMVtQx]qXyo]XYQ\\QXtKumxfIr]xRI@pZEr<ltt<JxiUyApfEul\\sXhQUln`pnfhX^mjhgh=hlOhlF_`MIinAwKnZH^]BpawOyZGylivfhh^oZEWcE?_cF_[qwWEMucVauV=ir?iZSHmSDkCHk;wNtN`pQlAJAXr;pohpOXmqvEcDWZlor=xZI>v^av>naYxkR@mR^pfGuLhpLgmbAukX^LPlL@tthhe?ar>aZAv;YjLwhbotfH]m`ZlqtgXejIxkIjAxjAnhiqugFt`X_qowVIbyqywItoXgQ_qrGx<Fn[HnBhkGtmwVIEc?adpkWhmWB@mBPtLQTchrVHP]mJhiuuxj]urHHRGeSGMWkUMryL?XSZTJ=TJ[=VZWBSRRUgBaFgWUqortgXeAhtexd]RAuRmot;asSWH[=Wb=cSSH`=hPEdskRIoEGWRAoCkcURoUV]UFwWxGy@cGUmh>quwWYUKIUgi;Ohl\\pcUt@DocHoFaMXpQwMKAuRA]qxeyTtTipU?hn_hNmtLsURQuTQdJ?dJfhPT<o]LuTG^LFk^P]mqvGYmjohpobMp>[R@mR\\GWMqfLecikWF[CF;X[XKR@P[_iyiYkVFAe;CfJ=Go?yfoVZsEv;Y:sSIuSnmwVIE[CF[;vkAYLCcMOdLOb;Ub@Cf]urH?sBAs:IgMufJ?dJluXquLDkAQLQtLQ<K?PR>ar>AS_luKY^\\Wr@h[RqqwWi=eAAC?OSZSGeSGkgWUqHFgEukhXuWWIxkkrHgEEouwWY]]vBIdFQS:?BZkF`kBAsKBhpeut\\HT]pRFaQ^el[YrAXnn`pNtNImm^MLY=ONLV:Aj;<OgdO?Ix]yrUlRrqu;hoghOmHMBapn`PrLQtLRWOa\\Xn]Ht\\hbEn^XNxDpmXpe=G[e`m]fsSqkRAuR?qsHq;QuTQ][Gf[?tMYtMPefGc\\`n^`joXgQQfiquwDimuFsWiuWcgCf?EUSE]SQp`T\\etJHlKHjXhQuMnOUoP=QwMyn`RXhLY\\Qr=j[Ur@HnwUypAqyuyxlkVDQ<XMqlWZxWYqqD>\\pHcMp^jPplPbr?ir`r]gav?yJVf@ak;arCX\\k^hbAdCxre?vWA_kp\\rw]sIysAsGis?GdKG\\XwqxgkdQwdQuIV[GgcG?_cF_;gdOg\\tNat>`lN`<Hj;HZHf]t^j\\Qv\\qjlitI?faqsW@pohp?atcXdkXiqqwIpyvGgcG_Xxayok<Qr<_lOhl;?_Nnt`vmTOeT?vkAiJwdQwjhpoh^cF_cZHn[Hx;YvCfj<_cWPaOn]Xn]byuyxqrneLPr[_f^_Ziwgi_wTipeioSfxVauV_qrGXEV[EFdSGeCTXmUHwtiwU=wr]IREUSE;ryWhekR@mRb]urGXWwIZsfFEe<WWQqg[kF`kB`kF`KVseSD_R_eV_[SGeSk=v:IB>gb?GB:KSDMSZ[DDCfdOgDoRGOE;wsayiomG>iRlMXl[iwgiKqhgUUVgIumDtKItKVukh\\KTLMT<_iv_INcDOctXWFK?S>WEqkWZAsKWFJMTLMgWyTJeTOeDTKET;Hj;H:oixoY=AvP_CK=UR=cVauV]dN_dZ?fZ?BiwUyorCYdaCTOeT?;vyyWIQtbGT];WeUW=AtJAD@kB@;TLMylwRWWcQso:HJ=<v[IfAx[YnjDPkDy\\yp\\SWrIysIndPodohnPx^H_m:Wypiw?q]A@kJ?dJ?j<Pj<>k>O^vnivUR=URYUIaDimYPGxsaYb=Wb=RYuUYKytQyYcYp?yJCIsCIbIumwFnaxnAX[Qr?ChIKcxiyqyuRMh^ECpywYyCESCE[Er;X:SBAkC>sde?TmeHiirOitOsdhcmn`pn\\lPplPqmIQma]L:dpYhk:yqIqkTPmT@tQytAHj;HradqIMJ;@J=pJGLj?hj?ltixUiDqQTt:yR[ALkXuR<pr@qRDkCHkBESCEr=xJI<Xyqyw]Qt]xBtOX]qraw`tOvmQYLytQyJqtPqjEXkE\\OgdO[eV_ejhhUupPfIKmqMHq]PvuvWX?dJ?DrQytQbBdN_dJqpg?Xiqqw[f_gf[In]v>rmxfIA^J>[xVwRQwdQwjF`kFbUqpgGf_gf?VgeCpmXp=hlOh<sb=IrPgGU=xMySyCvHtXTLsIlu;eR?eJhxUypkmtVHAvxiyuAOcD_naxn_v^avNqaffidfkUv`@WkPf_Zgf_gZeV_e>uRAu:qUwbxoixYYyuV]qrG?ycyN[avCGxGy`YaicYsKXglYxmIlR@MqwWYiBUSEURD`L^mV`mYpqQW`YxtM@mR@=WMqnGews@wJIn=LQoMwnIUCmY^]V^LyoYgwNinAgRWykyi^iv_IvpiwUAivAykgwQYlavcJhmWhkvayvy_dcc=Wb=rJAtJkf`ofjsHqsbsGis[sFasJqhgUmkHpc=SjdrBeXoePLUTMElLPl<`xnaX^xnaXvKY^JHmSHy?wvKAtJA\\@ob@?pj@p:hj?hZTwphgkphgUQrHqshphZAvw_]wNiNVr@h[=Av;YjK^]V^y?Isb`oMxlQxj;XZAN^sFaSFr;IrR^`b?tagyxgdOgdgYxVYlavcjaxcYtTyoQv_X?nZ@nZYkpYnPGdKGjxpqx^kGTRGeSGf_UsP?WSQh_[sGik@qr`iq=hmitUx`jEXkELsEYsKTMUTK=UR=QQu\\yitSYpQ?Qt_XSkytYuY;asFaKmyvIyrjHV=aLhDX^LNvLYnOdLOdjavCYlqpwoHisGiBysIyomIps^]H^xoUnkWVAE`mV`=HmSHegiYQuRAu:auVaEVkCASV@ac;IcM<v@ikULXupyRETJPW<DUJ=T:XKQl_nCG?ir<SGeS?@S^LjkHpk\\Ogd_LQtLfoUwp@Wv@ik[_gf_[]V^]>geWg=gcGg[Vo_qp`K^_hn_@@c^Nj:?^:GdKG<so:mXpmPlUXmExbIt]\\Qr=x:DocHoBIsCIJQXs?h\\e^xbIt=ncHocjqxpqdRPtMFhj>ijAfNv\\QVjIyv]n@xlitU<eTO__gf_[ggggkphGLV\\MJ]TN]<mR@m:UUUUMTPmT@vj=QoXpXdR?eRZLNNplPPnbbf_gf[irEx<CUSEUrwYyqILUTMpywYyreytiPnaxnAvZGZ<Fj:nv`qvRqpgW]]yh:o`JN[?t]YvkEx\\iR>uRAUFcCGcoxwQhpoh@UipewJqhgUuTYxZ]V^]BWcEW;gb?g:eR?eBdMWdehm_x\\Cdboxt?sGis?mTPmDlSP\\dN_dJcHocFlKHZ:>plPp<Xn]X^VgeWGv_ivOWa\\Y]TN]DxgxHy@VcQp_?awSYpSoqg^cbF_cFr?X[Q>\\Xn]H@mR@]^hn_HZ:Nen@g;VgeWgRGeSGrNatnpxv^`h_uRNatNaZQhshpOI\\<FJeR?eJN]TZ@obNhlOhjaysYh^aV;YrAx[KtLQtjuwXiINkDPKROeLt`XcQJatNa\\xditEduuxXyuwT`mmtVH?n;WjJyoYwafIumxnXoldylPpl\\n`pn\\kGhk?qkWv@ngWQqOWqHPcQwdqp`;Y`qv`AHpkHhgAwpHn[H^nghoWgIIdGys=vyx^xxPioQ[:yq]^uipewPb;Gb;NxmYxK?dJ?jQv_X?^mV`mpx[GwcYta@ob@o:PlLP\\ff_gFtkXfA_hdU<WdMWDt[XbAFkgHOMc@YsQwGKCDKCbR?eR[FasF]qvGYeJ;C>;vmIyoGStUwPiosUx`APn\\P>Uv@ik[]V^]JGeSGQuIyModPo<ob@o:@kJ]TN]JZyum=UTMUD`qv`aEYs=ocHo[xIyay]vNinAopYob@oB^ehv\\PplP@wVIQoWWQi[wVIqej?hj?goYCDKC<abCSDjCX\\aRf=ujGR[UsIsyQOgdOoxdYtlPgMu>HmmtV\\EulhViayUpLDdjrhYuqPhpUwPkUxPiMvHimu<qquwXLOeTO;YvkAtfHUm<mUvoGOxFf[GFnixoYWyipn`p^nhpoHr_QhYQi`@imQifv_ivbSGEUIeEUmidWgeWUeRoIx]yrohfqTIuSIcEukX>UypiwKIimuVrCIsCRAuRAkEXkmWhmG@qr@QkhTNaV_eV[EulhVBlKHlRmpVGAPymyv]KY>q<a[l^f`of\\N_dN[CGcC?qoWwPngYqqGPlLP\\j?aVPumWeM`wongVAqporYAr:AZdQwdipaYlIyv=geWg]:>dPodPWaJ^dN_d>PplP`^yvaytXWosGiswg_vnSIuSA^\\>gcSjghogrYyYyic[WRAOvQwUxERmqvGIewwHG;S[CbvYyiyiKKDLKbmuvHIvTihe=TKET;ucXcIJYfAuCnuwXiEWQioUdREyOETKEDhgUuobrAyr]r?ir[kGhkCOcDO;wXiQnqwWYM=tJH\\RepTg`NLTUPHSB=S:Il]tRjMx^?yuywyHtvHim?auVa=ItKI\\Hn[H>pn`pNVyBImB_^<OeTO]hpewPkexdiP^lN`LFeSGej@pj@bypiwA`r?XceusXPSWFEUA=GNKv\\irE?Ip]wRksVGI=_iv_IRAuRArSIuSkCHkCj=Xj=dBEwbYgQugdUSMUV\\MVJsDQsB\\KbUWeUeWagtTosnex?Or<QRVkIv=EasSX@kB@KjEqV]xbIt=lkHFvbAwBViuWyiN_WPiYFeSGeoxt>_dN_\\hiuuxZ=Wb=_xgYuQnqxDvcIwSWY[upywYycKUf@ErYyM<TJ=TwGMlLeTOejb@ob\\Ut`XCDTKETrHX]qJ>MNK\\of`oJIp]uRRIuSIvexoxPRuqxginp<QbLLC@lKHl;XUqpW[qvGYmrHX]qJhmuvHkfawf=WeUW=ItKILHqsHAwMynIUR?hrU<LKloWUq@XPaGbR?eRngVAq;ff_gfRIuSInEwlh>wVIQLqnEj?hj?`ryqqmMXl=lV`mF`v^aV^dN_DNkDPKDysIybEDcIumx>GisGI`isUwbsUx`IVCQd_KDoEdOmXiquGGcMsF<itOiDuyxiybHoKVAqko_V?q:XoQwOgcGPtLQTnDWLaJWTQp]RAqkWDt[XRA\\XbAt;doUup@PplPpNaUEMSD=Xiquw\\uwXYqpPShqwUyp\\J<>gdOg\\Podt<gBE;Hd]tbwGhmYNgeWgcOUgPEVUqhg=HlKpsXXaQVNA_^qi:woZ@n:vvHuJkEXkcb?gb[IwMyNKETKMauVQUYxUQp]wBTWeUWchlkuTN]TNqT@itveurHX=dV_eVjTPmTjmXpm\\uWiu[Yv]YtjDQ^dW^Dps`vexTi@WQqoW]v^afr^]HFmR@mJanCWlbausXhnQyoYgC_jva^>NZ;fmuvhHp^H_mBor@qr>Ivj?sCMupXgQnlPpllVXMtZ@pj@lp\\WRARpppp`J:PuqxWIUkPdO\\XwQyomTXtpYwQQg\\Ur@lf]WfMWWpPh]uBeR?eRFam^HrmxVIAW;Qj?\\tvHi>ivlGs?ir?ptixeIwcX`a[OvMOdLOb[F^[^`f?ujNtJAtZf\\ObvayvAG`kF@GcI_HCocHoFysIyKTOeT_cGgcGTkHf=EWCIl]bDUSEEeraIx]yRotiwUImGhkG>ivlEsNatNoDh[mPeoTeRVlKApVGQm?MNK@kCXmnDLB\\Jn]xbITlYxmYNWeUWMvj=QNIqm_`wOynOawOynf\\Pn\\lpdvw^cIwca\\N^\\>W^@_kZV\\MV\\<>bgWuphnSWp`Gd<Ob<VgwnfVwqxgmxgyoyddGt\\hZ;>^UWeUOyoytYGw<ijEN`mIueN\\C@w`isU`xuywyXlaxnaFxsaid_tbH\\GF]l^jHomvFcOf\\O^oOFmJV]UVc@b;CWeUWMUd`cSB;BoOWOQcviywIWqqwWadXoeHQUkiiNmTPMTV]UVcypYui]vdQonhpoHk=IvJuthNtLinEGwpiwUymo_qVauVOy_ylY?cOgDoVGQeKqfGUe^qyiQFmSHMoyvYxIMXoeX_kEIwRdQwdav]Yv=UgPeOkIhcPodPkoPvy?odPo\\@qr@aTGqlg^sAyrAlTPmTF_cF_KXquXag?ujHjlV`mFeentE^rT@b`qv`Qt<hZE>cYweY`dOgdc?ujHFmivEe>OR[?I=Ac?OwdQWtsXhaEG[Er;dN]TN=s:Ar:oDhfv_ivkpdMV_sHqs``eoT_hn_hBUUUUe`[SR?RCIsCagooy=MV\\MFGwEykencHoCSEUSEOB<KBbsHqsdoodREYrAx[ccXcIT_dOgdCAuRAe`qsWWSyuywyHeegq?GgcG_gEukXJgiwgI;;fXcIt=Tb@TPQU\\eR^LLKIumxVcXUqpW><jthXeqR;ER;]sLprqIxbIt]LKB<KZTV]UVLmTPmnhhUuPsnYrT@QB=SB=nkYvAYlppppDxsaYlaxnangTUp@tmyvIIUehYpLNK@kLPlL@OZ<N:`of`oB<JSMUTMtDileDwYxYxIVgxNkmUyNm<XJMwVIimCBZoXgQuKQf?UcbcGgccoOuaCTJ=T:UIqmw^sCIsC\\Ixr]t^GSMKeqsWXcIumxFghT_TBmSHmfYsYvIdnixoIcAYvKGdKGDgcUt_dLUTMEUegtSOsDQSt_YsQHGeetDmSHmOqK`]oWUqpYjIYMsEYs]PemtfLTQuTaTN]T^xgytO\\B^ZL_`Qv__iv_a\\LbJwbAwBkEiV<VZ=R]xRIpnMunHEs_YwL<K>\\XlavCMMoLWNDweYghvLwcILKCD[_iv_aooa\\PFp^>l?hj?``wOY_tNatBAl[dOX]qRmoLDpv`qvLUr@X[DMR<MJPmTPMGumxdU`uRrxQOPtLQTTXPamKcPodPlKHlKdoTepDPSDMSRUWw]l\\Qv\\MUkPV?dPh]uR`tNatbmwVIqltxZuys`v^avJxqyxQkAYvLWMqnGdJAtJMeV_eNeeoIPLYtMIequux`lKAXRWPQoMnr@qrltDuUFitexTcXTapS>Ivj=wUxWxHnrAyrmtDu]_gf_fZAvZMhj?hZkAivNxqyxQ?o;ilDQsDOyeyoy@owWypipI^hUn`f?n<Pj<ntdOf_qsWDwaxMyS^wfawRDQsDaveYwEESCESfgh>qSCEKT]qrEPcYweytPUPBYromx[lmytYHUKQlO^pnGUmLPlLPLGdMt\\ThML[ys[`qv`mpmwVIyPiprPX_QSs`M:IyNLv\\QvbMx^Isoxt^yXYiYAEpkHpoxuyEyliNGYmqFgdOgLHj;TywyxYiFasRwt?_eV_ETWHamSgYwgytiwEW_IsMddWgeGUeGcGOsDQKlavCMwQyoYDOeT_wfawNmuvhhPbwclOrQcFJOR[?dpsWXaS@kB@[VZ=V:UEp[WJWwEWgf_gFoHf=uJUytmHimufSdmwfYSvZIr=_Vf]WFMItKInoXgPXsLnNmTPmRy]ykyJcAwbAlcHocdMt\\XBhpLyVMeUWeSeqtgXoweKuqxgYlEyqaXMqlWJXquNvj?anNf>A[DIsCIfg`xSav^avJxmYx]k?aVNxjAxZXeqpgkpdtagdXoeHgiquw`fdOgDOatNanpgWQaspyZy\\B^ZnHh]qbdGt\\TDQsDaH\\]rBCefocJsH_iv_aXbAt[KwLifECBZsXquXtOX_QCeegikRZ;DJQsOWGCuUYDwbAwJQr?XKcirExLfhp>QS_eft>hZAZSAuRA\\Ixr]Hv=yjMYnACPQUY]S[EV[cGUmhFOenCW<MGdKGnkVFAetEXgktJmUXpKYlQFeQt]xbhovHuxhYuDwbAwJpmXpMgTUp`ShxJlXPlLPbMt^>oKWn@_f^_f>W_P_obx\\CfdpohpfypYuigpMN\\Mx^IonF`kFntTO[=gmM>sAx[YNdIp]w>kIyve^rFhuU`tFAolIyvOhj?hJXmI>kvayvOxoix_n_QXc]orFHleHeZyxKXmUXcxqyxar_Qhc?tZHblW`eFxnIwMOhn_h^f\\Of\\TXaqo_wPioQkoPtQVhfAukN`of`_prGX]MImmvfRWwvO`apC?sJAtJ_SGekkYvAIUeaYkdn_hnntXhaULETKENAoknaxcYdPQcYhjB_^\\XZAn[JHocH_cTd]HoMwNEiueC\\QFf[GF_Iv[IB;BsEYsETDMSDSW_OIkmxfIUlsHqsFGcCGKeqsWXcivEyLghL_RKKC?_XZAr;KWUqPLeTOen?YkQTs_QUrPkD^phgU_CF[kHpkHdsXhQupUNxTy=kRAuRMMj<V:DXs`UlTPmTnmuvHIpPMomdPYhLdPod`V`mV@UmqtW`MuA`jOLJ;@jpdWTaR`mV`]ndfd[N_Uaf;Pa_>lUypiw^of`oNpmXp]Xqj>`LIy:>ZZ>ZC_b;_dqwwDXuCofrXiqq_SIuSIltPqtfZ?fZkptsA^kF`k^ff_gFgsUx`a@xjAhPQa\\w^f^?SDMSDlCHkCdsQTDYvAycMohpoHSQuTQtWWIq=UeAcOOdLODTcIt]Hk=IVKelcVD_Sh;hiGfdOgDoFGMe>=Bb]sRGHDsx;GXaqsWKhogh_cEWcEtCX\\aBeeeIMvhiuu_tgWUqKvlEi^ywiySSIuSagO_V<?cB?ClWhmWF_cF_KelcNsHMjMsIysaxwxXyH@JJAv;YjeiusaodPo\\hTepTKpj@pJohWUqThPSouSWPQ?eoTep\\ddd``movFgjT`ZJvZqvgXa^iv_iNZ:gIcYRgHsWgeSYpaw[ofGdNWdMWLUwPYo`UH<XBXmDPkDNioen]Xn=gcUt`_hiuuxktDMXGyV_;dosC^]UhdOR=p:mOPIXwEOOhlO`PiGi>IvjctcXd_Sx;HY[Ir=dN]TNxoixo<ukvqLN\\LJuyxWd]pbG@wjIv=aooouCQwOYoCXs_QtNH_M_\\t_ni^^^^jnf`oFsUYuUo^QqtP`lN@laxnaFgcGgKIp]wrRWwB_kQyoYwtXYlQqoWWsTwvw@[?PbTgqtg`oNgNAktxhiqcqngVAfg`^m?[?PbDN[DN^wgiwOgWQqo`sI^l?wbAWlcHocFmSHmKinEwlRWwjf^]V^=`qwhqCGeSGmPaoSW^MimLX[DN[BysIyk:>tjHf=Q]DOyxNr_XcQ@s@qr@``oRTQh_UcFueUMF\\wDikUJyhYqYE]Uhsdx]ykyR??g>UDqCYsEYnCX\\`r[AXBytQyp[iQdXNY`m:mlOhlKuoXeqBUTMUlHemtdNCuNS`v>IkM\\n[Hn;mEEeD]CPigU@QVlKGImmtR`yWfMv:]NLDtfHUm@k=IvJqrGXMSUwvhrnHWMAkAYvK=VZ=NeeLc@XeqtgLPkDP[xoxPyDmnppUc<Ob<nHhMuLlCHkCPrGAJyxkGXMqLLIxr]HMmlVjpTsyKsEYs]vhqwH]YxtmP]oRENQYwpdn;mXpmPsAyrAlLP\\TOqnGoFouQYZ=VZCSLMfxiyuyHFaUwyE\\CdBothgUEMsDQsNyiyuYS_ww;DWcmTpPgMSGQmovfIqm_go]v`NxlQXd:?b:F_cF_Kxnax^_yvaYpPOiaFlKHl^_f^SEoDg;GlKHLghHxvDile\\VdMWDeSUNeinpgV\\qvmN@bxpiwQmvfawFsRAuRGnEodynrgYuqHoCWl`^v_iVaRs;rHgEu;cEivLqxgYuSUgBeegWUqODQWs_?vZ`oO=kB@W[Qr?`raYx_QWg=nr<YpawSDUTMULhqwhqF]PJQOgdO_TYuUYlPplPTRqs;xw]atcXT>yvmIWCQ\\RWoNQlPpl@goTgp\\pdgPeKisUx`SWwBi[\\FlBp`iouFOsDQs^yvay^Mgoby\\gNe>_]HvjxwywyhS`chGeMv\\Qvb@oBCIuSIEat:QupgWUASSEUSoBGKE^?tOOSL_FkCHK_sGiscgTeoTlsxf[ieuthKvmIQjAv;aTV]UFQUAmWbLOdLoWqsiuwXiqfhX^QkIpNJPNK@ktyxiySGMmnDTBqpOymEMWdMOolWVAm@\\KR<rnYrmawSYp>YvkaVhmLHMmfxUypmr]QXTxwMKq]wRIRvlMIEnEeNy\\rmxVIAo?UkP\\v_iv?axT@LDdj^IwcIS`qv`ix`uopxy_\\N^\\jr]QXdwVIqMhpDdN^\\NJpohpOsDad?_KNo]FlKDcIwcIdmWhm_SF;tFIemsJeTOq\\oWLyBtKYlQ^plgTULhmWhmF]mqHMmlVJtlEWsPh_e?ctyqJ`yvailghog^GgcGGmShvUGqlg^k?aVNen@gKWrsio=N^K@k`ysYxcVo_QpyrYVghH_ujIt>KXcQt__fggohiuuxNGtMs@vHi]BWeUWmP_oRGr^ni@ob@FwcIwKQn?WkR`rQh^<NZ<>s:Ar:P`mV`S`ryXhaq[cPodPtphgUAm>U?_xnaXLitOifOWGQMHm=Ux_YsCwcIonahFa]^GjGWmpFlTPmTVtKNxN`lNN`n^`^Hr=xZEabopjvVxjIv=O`kF`[v]Yv]`xw_?fZ?^kAivpjLyrI_vsYxaatthheOy`Ymi?mPhgIuIyFxseIuFIme^mvZ?WNeTOEtbIt]GSMUTMGyTevTWwlGVJuvEICDKC\\cF_cn_UsPltdLX;yJM<sb@obLTLMTd=qkaq=XVAqkKPlLPlNYw`hR\\DLsDQsDlAxjA`UhIOblWdXoeHsWiuW`UV]U^pQlqTSEUCmtPqtn\\YrAXcprOhTH]mrDRDQsDaSpyKEmSHmN_efGvxdxy]?ujDSUUUUHc]XPWdMWR`kF`[tawSYob^ITF]f_gfKGf[GFG_EsKdC]yRAuRMvmIyoqVwuhr?SIuSacIwcItixQyUS_rYUipeGcCGcCG>qx?Mh@?Tb[fKSF@=dpohpcf`oflCXrkXfLvkAYnhXeqT`DxODlT`jvHvSMv]aqqDjfPodn`pn`lFuNHbP?yoytYGo]wrHPdgastxiyqil^`n^lEisVi^?yayay=OytQyn?wJI^cprWWqpg_SHmSH_VqxJve<y[y^y:weygyo`dMHiK@c>gat_xZHcMp^Cg_``oMOdLOb`of`_phgUMgkeR\\CDoIwMyR`mt>QGLCSCES^of`pxfIu]dtrPJ;@jf\\Of<way]fftrPk<?eR?]kIyvGoIadWWqpgkraixWrFal>Fohpo`pywYyMhoghoNYm`fAgI]cIwcITMinEgNUvPyBxUygyHLytQDUSEUfhT^MmqqNJxYxIyaDmTPmD]x[<nlPpL`WgeWC<JSEUSEsWAWoEUSEMSPmTPtYxiMOokarwN[F>v]xeofs:NkDPkxFwyanGqrGX]CatNaDubVaqsan]Xn=uRIpMOTykxQoiqNhrmElYxmIMYtMYNLLLLNo@mApKWLNweYwEpqljrUxiyqAukXtWOHnOuTQUTIpMwlusekJDpytK>uyhxjNYtMYldur:Ar:ARLqtPqlRqmcummuoL]R<TJ=DSEUSEMo_TymlVFANEUSEEpYYU?IXG@s<iXpIOFUmpdkfdOgdnPaKc`n^`jTmpfEOKIRoPmqiuRAuryQ=@oLqQi\\OyqKDPkD@sFasFpNImmfdpRPNK@kVauVAoausXPLU\\owutwhTOeTO`uWiuc\\Of\\S\\DP_eJ[Bqup^Iv[IrTeR`HYaMJc<LB<SIuSIpytYwiDk@tqwUypYUy]mlAqq<Uj=XjDMR<MBeVnIWWQqo]tvHYmEpIAYdLR<DUOeT?mN`lNLUWd\\LJ<L:eMt\\XJ@skhvsDj^LNT]qrEPoXWQqSdTpJPNKfpcWt@plgVe`nx]wyii`jqv=Wi`of`yZMv\\S?aIN^K@kfgggGgxaysQdCxdN_d>OqtPqnXgQq_ChrbxwC^nB_^\\vcIwcTn`f?mNOv__f^?llPPCd`EFoIG;_DB<oSUp`MTuaYTxQymQSEUSESn=RoisemwyUSbTwMMJC]xiaWiPlLP\\gW]o_yrIhLQtLQnfawfGk?AyRiiPGtEQnmPpl@cMWdmHnNhx=^qmFjFN[DN^=VZ=FkIqvF_mrFxgxaBIx]yrE_`XD>KB;CER;mWYqqUSvlTupXgaNLAQaYXh]qlPmn@LKdOR=p:`Wf?cvncOgdOf`cOt>p`ioufFl]yiCYicV[aQ^eV_E`lN`lbNatNe\\Ip<Yr=IcCGcCO^UohNaqIpdPC;;YeGTLqhgUM:Lppp`viyxA\\Uv`h_n`gsTHc_`sxypYqi]phgQUcUUgGEywo_hroYwQIcCGcCtwYyqiFXSwQwUxEfheutGS^AuoIG;_F\\Ky]yKJUoPeo^lYglv_ivCev;yxGyVqTN]TNdDOcDowqUwUSZDkBpjHdMDeyuyxQ@YVDlB]RWLQn=nsXXaQSnlsyqqYhTOeTNPlLPRwPYoQN:\\thhUuDqePMvaU`usXhSpmXpeKWhWYYruTLBqWWQqKyOy`y\\Dt:iR?eR^Xn]XR:<WwQyoaJ:`pohp_QXMMvcXTaPTIpMw\\NTTNxlQX@JJmbFFpYVeKO\\ByrIx]M>ZD?cB?lb_mmxfIQllPpl`rXWovx^J`b>gqtgx\\Ht]xbE_aHAkKV^bxhiquLFapgsuAqpgwTOZ:geuph_PwdQgdpohpnhfet@\\:NeqpgW`cvxuiYnj@pJ`lN`l^nqOicsGisFwcIwC_iYodSoiihnCxnaxn>yoiPplP`LAtJAn=xZINc^Ayoi_;`_dN_\\fdOgdCxsVasUx`IPuqxgiFxApuTxxWwcIwk:^qoVqTw]M>sNatNOvj?aLvwxgihausNdKGd[Pj<PZCprswuuIynIwMOZ:_ixve[yxU`sIysaf\\ObsqTkMhDsDyYRkEXkKdLOdJYhausyiyP?UCSCESRKETKKUoOW?Gt]wR]gTeoTbkGhkr_YsQWWymf\\Of<kDPkDZAXr;CCCCsyskKR<MR:Ivj=V[EV;OcDOCJCD\\SF]CHj=v:=wbAw:Wr[ARSEMV\\MV<XhausDkwpLIuSI]N^\\NZ`n^`R\\EP\\^bZhdepdjf`oflR_[kOr\\aeRHmSHrFasFF\\KF\\LFaxg[KF\\K>ydue;WeUWE]HHyrbkGhkBAWr;sb=IRkEXkYIymvlivEAvj=IJYtMYrEydisymiy\\Of\\;ETKE<Wr[AvLifEMVmUXquXQ?ys=B:?sBASr?ir?SnkRioUw?r]IxJ?eR?cf_gf[V_eV[yyo`u]QnhXpyyyTXOj\\KFLrjeL;EJK=RJ\\q:pj<MWseSnXkWap^`uo`WqhxLqotXudEWpPuOatdetleWmhtFQsfdspV_\\uBYIZKb[?CleX:=EsWHmQywIrimvEKcDKIYGiZaIYsCXKCmSXHIyvmsvwuiYXXyeqYyvWtMYt[CdB=Ht]xbqXyStXwWfCt`[uVauJSDMSFrwGLMTL=TOPKMpNGMLNuSAELl]wbewUQplPPflUv@MdepTLNK@K;DJ;<UupXg\\xteqZxtqdVDaLfAukXJtdmH=PWDOcDObXoeXrRIp]eJMIX]LwdQwj`WSQP]xKGlqtyryly;PqtPqpuQMAtJAXEuURMtqMOOPKCDKCLj@QN:<x_ylYMvKxRXDjB]NL\\TIHjQqUueK:<pnEwLYMHXRgHwbxWiupy`wByx:=K<Qr<ALXlMHhWUqpCLoaUypiwB]SF]juXqu@ntmW?`S`TjB]NdaXFHVEeYgxjAxJLTLMDxoytYUK`Xr`HqpTnn\\MJuO^as<UXmUPAhKUlR:\\Yaimq=SLxwvXxHDjeYkO]qsqvU`J:ar>arpTS]`XtdMMTLMDK:AYjyVeIUbpxx]jd\\wKEUSESC`R<ieiq\\>oaCokYvaXHsCeZKhKIcSWiHoI;_hNwG>_Y\\cVZkHpkdmqvGYDFmYAeyKIDY]HpkHlwYyqy>;thIi_obaWW`oG\\eXbAt[KBZER;EbCaVXUSxmYxCBjcGgcSJCy@WybGtb]cwesuywywsoSWPAEuaFGoRMqgy_gcgSBCiFCt:yexaxakCUkHF=TW[VaQydCf@qcPywWsIx]YuwwQKiliv_WSQ?C:=t]]f`qsWXRApKO\\SxikXPMcepTmr@qrXAtQDXkEX@Qngdmoij_hYqqtUuWk<NZ<RjDySIuSaJ:YLalSBln=Aj[qYOdLODpaucGXoo>cMYyPq\\Ta^syiEo]?`rIysIa_?X]ihxYWhmWhUh^fXvAykapcaXwn_k[WgxgeoPgOfyvay>ft[WoVwl:ooVGqLpqxpq<P_wvhha];>d\\FlRVZFQj<PZDhr\\OZZocHokkiq@xr_Q^K@wtP^PN^K@k:>i[Qr?Nl^gdOg\\MPlL@ygyP_gb?gZUTMUDESCECypYuiUDbEUmgGNkIxkIvuwwwx>SdYKETKs_WSQOC\\Sy`ecsqTCKsGoy`EGY]GSMh>gYtaxK[RpGBoPUjhyI`ncYkbawVIqM@REQLkgv_qrIydPodLYr=Yj:>qgWupVlXWbcGgcFZjyvYxipFoVqtvaxMyc>>rlPplFb^ypxxkUp@?C:GdKdkOXnyTyfYpUlJDmtNqNXyYyiYtMYtMK\\Tu:AsKXNsTWPaO;eXJhmeYoFeQp=M`<UTUyPYr=YjutXhaVgeWgTKETKsDX\\aR<<VN]TN@vqQr=Yr==tmyu@qkW>t_OpqNguVcP`_[>ZDaflngVAqKhdOgdfPodPv@ikUF_OPcC>ji`qlQsoO`hovEVrs?oPpxWHnin\\dPqwylYoiCGpR_gPhaIiwoykhqwhaob@ojFkiggkhchGulhjlFmF?pw?v_gf__Z:ymxOyCSxUWhmtAqRAuRqGI\\QfmCH@ggsiXiquw_BZmtdmvpOroEC^yuyqyqErdWST;Un?WKCBj]urGX@qb`WtcAIh]urKBZyuyfkiitcahvxxXYiC^pWWfyPioQg<>vwxXqhc]gy[yjYBiYiiqId[DDWwx_xHkCHKbWUdJitHctdehZubrSCK?RLodkirAwEx=Gb=hfWtcAGPSc?cI`OrNIC^eYweik?DFUwC=C=YTyAr:ARMwTKkWhmW`?S^KD^AeMSBUqhgUfB]FdUh\\ErN_hxwc?ir?adCaV@yiCaVlkdN_dnMG;_FgSt`khheuDEc>MFbqeboIwMyjEsLgF<Gsq;tSoiDat]ub[eTHUWYqUuCRLWeUWS:[Tb[D<wuE?cB?C]=hg[B=sBH[v<gBE[BMwY]oid;Ir;urCRmeG@_R_;Gb;coixoiEpib[?rEgfwudXoeH=BvsXhDR^yoTepDpuXqu<@sxplPqqm\\MklJ:xWvHx@HSvUSTqUU`SCES[<J;qscqQoMwNDJjasSXP<@siesGPyQEqVmYWeT`qs@AMp`vQaof`O<<V@mb;gxRQ^Qiw;`qtgxd^mWhmihymHsbhoghr@h[U>Z:Vh`as;Dq?eZkDEGHumxf=B:qbGSEJUUUUWvYyEwGx?C:;UqoOndPoDncHoCTwQyoA<Jv@y\\Yk@EMUpPgMrRIp]EpquwXUvaYUMAtJANRiXcdlD=WoPU;avYeqteLDenL=PsAREQUompFMOVuxMIuwqYPPx?PTc`rOYoQeJKhKn`wYAteixJ=ONLjcAPolKHlKRmpfEM:<vgxpXQRsEYsLOeTOkyky]y=<Jj@WK?hlOhlFoHGk>OZav^a^tNatR`dhWgdWgeGnJCB\\N<Hg:YsEY[CF[CnrYY\\LN\\ZIwcIucF]PPgMN[?PZtfmhheWpn<WoOQrOitO?`sytLIlxPsNYfAFseqyXf\\Oft`yhoPeG>Zq^uaxfD_eWgeu^paawpGohpo@XkEXkZOxUYn[Hn;fj?hj:>jKX^AoeqQybHd]@Z:f:XwTYsGaYKquxDOE=yHAxWaLd]kdpohppBquvej<EVVYKs`YsQXVmqvEytxxnmtqppTqN;<nlPpL=LsqjRTTbAUjhP@pqp`pn`LmpVGQR]UV]lrGXMAXKQlORtuMImRTrPayd=w=djfHX\\UoVul:MquXq=UnKAK`@xjIv=AOdLO<<tL]m<Ap;mT^LLStPeyLQtL]At[XR@ysF`MsLLhpoh@sBAs:IqmuvJXmUXkF`kF<qtPqTTQ\\PytQYflUv>ZZIqaqm=odPo\\dWgeGblhuHasNAgnN];w`ovheqtG?dy@mLVctQb]HtZXeqpg<Hsqohpoj=Xj=hsrQr:AqkWvJN\\LNZgpdEh`eCrytyoy?cc@UBisGi[SSOH?avtQweYwKUUUUGbwGNMGOKWdMWJuUYuGRoC=KVk?EywywywGwiIaesStR_Yn]BEuhCsRAuR;uF@ciwgiKmTPmFR_yUiRbIh=MGOohsiuJ=i^gi:;sNadQwd=YuUYUjCydehTaG]uvG?wfEDRostQrLkim[hKsGisG;]vuAyrAfn_hN=DSyh\\IvAwE@ucXcIjevDiDfgUuox`wwwgdieWogST[yeYweYGB_Y=af_gFv]w_iv?gtewT]]rBGDbWgeWr<gBEKuF]sn]F@Ah?uiTkwouVa[ciqBhWc:_QsEnv`qV=L_]NkPWOQoHdqqetdhT@yO@XmUXMXlYrIV:<raumwmjyayayQ:LUt\\OqtPq<J:UV]UNhdUt`JZhnT<UR=URHX@YNwdQWanQItXdv_ivjIxkILFmqQxlQhRATxHAVCuUNxlQXKp<QU<Tehtptl:MQtLQTtVBxUyeyo]qvQxEAJ:h:[BsMX^[XZ_tTmhsOu?AsKWF[AvZABAsBA[cRCH\\WTYgh^UeJAWnKbIkYxoixorCGReMrPkrHWu;_FDSCECvayva;eHsUYuUmwBdoCHkCjyxqyB:oXesByaymys:;ByuYy=Ir;IRgtpSTJ]TN]BC_R\\;Uu]xoix?eTOedZWGykW>WhmWHPoGWMC:;YuiwqwgueimkiOCc>mHQqF;odawfhkGhKbwcBpYxmYbB]Fl?u^CbNMG?QwOYg;[hNMhHQsDQHxotK?E=qDuQuLOdL;c>MFnuwXhnGEptloE=N]MV\\=TKEdGYvcWdK_eV_kWYqqWZ:NpmXpUiex_lMXl=>ZrIvAx]J_eV_gvawmysyv[:>eypiwHhCNl[yg:WsQVuJ>\\vxxXEh_UsObTQuT]YoitQ=YnItAeSxeGgGsEYs=eV_eF@[CR;FRocxiyuYv>IcMKbCyH_kdnirkYvAIDMSD];gH?wbAWUXkPaST`PCDj;HjJYwoAWb=W:PS_PrnIwMiJKiX\\arC<S_PT>]R>=K\\tM:LyoYwADk>MVptUrMYtMnxpqXdxoixWpK:dOW_bAwbENo]?yjIvr>hZAjZPahw\\eo]ungQXnAwk\\pqxp]kIxkQjcAkGhk?Iv=yj?VlYq]Hn[H>itIwaHZ:FsCIsRapcW\\nPeg^pTg_xfynYdvVyfYp:>japmtOs`V\\ByexGy?VZAn[vpwcOkc@kIxkA`c`VrxhiuaZKxiennFGm\\_cLvo_X`xhhpohpHqpF[:FocHogopt>mTvfawf>ar>A^of`O?`Wvp\\N^\\NZMqnGWZ:^sYxayhsKObqPkk^gkxow>hZAZ\\Of\\_cxhsaDVUicKhsGiSoghogvavMwSFmi[QXOQgO]BTmC^qiKedjov`qV@ir?ID:UeLeroixoawOYgQGX=eWioUw_cUcgG[sYwIyguGuiqyuyuikyy<=h[Ur@KgNMG;Qcs=d^yRYcY>uHqsH;MguehqushgycaWKcEE=y\\GisGedcdDWEp[WjCifqtfsUx_e;ER;MbCywbwItSTJAs:yFY_Y\\]YW=s\\wSyEyEyUr;YjAV;avU;Dl?tAishYf;osNCtk_TyatmwVImikqrUKbBqHZmg\\qCWGwe_CROWfAwBUEeeyT?dfKUn?SJQg\\aFs]wR\\JTqT?uP_tXl]t=UY?EXhmvETWkiUN]TNtUxEy_Er^YlgdLKxmumwsDRo=lqlwYtPf=ujUrpAuStuTQUU`Wh_cIv[InoYwqX?dwVkPf_\\_f^_nZPaBYmIxisGis_lB_^>>r=wjHfpsgwPG`@hOewUyhi?fkOdgSthiey]wkwrrAv=wCT_US=Wb=G;;xysysysGuuqGYmqV<;Vb=WbUemGwPwGYmWvQrnwXXaS=UR=sypyhyGT_OTK;BWauVAIymyvmdN_dBKy?USD`ratmvMTJDu@lOX]qBEk>MNBIqYemCLstLQbTU<yLuqhAGoNOsEwlhFmVohe_jHnluNwIXuC?^In]v>c:^hn_h^GdKGlZnxM`fr?irvewgxOGr^Y]R_qrGpZWjcishYn;ps^>lP@gMF]SF]>^sMGbhNatNmygyeye?ftkWaC^^cOmkXrTOjTpn`p^pqwWYmendf@\\FwZCOwoQi@pj@PxoxtXW\\>oq[AoYFmFohWIqMi`of`VOqnG_=Pj<`kqY`r>aRxowpxTWmdokp`l:of`ofL__PV[xob]yfYhi@w[Iv[]O^`^\\qNqIPegplWYqqwq[YwWfxgh_oHcL`ytYwiHwdQwd>ykw[SIuSa\\EhrvNinEboeUecyUhaus`;BHCEl[rr]SHCYeAE=qdvQeXoeHEgNMsmwVIQC`WrPGWqqsa_f^?TdcdpGIuSsHUy^yvaYTdcdlAv;Yb<Wwt=v;wBrcWTaH;ixRQGImIsaFacST_VPcUkEXk]eqsWXGUnEeLwbYkYR?B>cImww:Ib=[DEgr`EwyksYwIIEhR]YWaGbgePkvFIe=AyrAYm?wTqiwUIW]UV=gKAWFQfiqW_yuyqyqctdehkAroEFSuixeIweYweSx]sICSxQxEyG>;RYsEYCR^YUUssxSQHHMmlRjeQtdmHHv[Iv<hNxqXhxRaXtkLPlLlExLilPEpQmmrtdm?aMkljs@mrDX\\^swW\\h?mtx[T^`BxisYsY_scWkGOxLYciF`pn`Pa_tpivIxAOasFak@qr@ufNyfGk\\Pn\\Nar>ajwsXha`GtqHgMq^dhtdGraGiGGcpohpfeWgeC>bJIejy^X@i<x[w^xJ@flyo_F_cFkMwnHg`UpaUGndPoDpwhqwq`ekIfd^xtgaA^[R>rSX`aOm?wuWAc?gb?VinAw;y`YaiMa_tQgeStYyuYxgwhXQHc_uYqYuickIxkaB:IcMsFDKY@Ego;X`aKNXs_auyxYyHUniYsivQ`TddlFqsHqPEpquhmqmusujXpmXxpvTqSaTVhQumllDmFxywywyes\\xo]@melrjtJYyYyiQ_QXs@VE=yuPJq\\SZtxiyuIuRAuRuisuHKamsVHn=Xj=tKYlQfmPWXnAuk`akSTPFqnIqTrmvSxVrlXfAUmHwMIwn]Mj<V:@vuIUFEReinX<JR@lJ@X=iQByXDMYtMQ_MPSHUHLQp<lOhl?EqVmOrQlXTU]Ev<ijV<Qj=nZTy`xW>yoypyDEaVXuqxgqVmHYqCxrXViFXZAn[fWpoXbboqxQyeO_NN[XXaqos^Nxhhel_i^AsKVlBipP_htf]]Yv]eyCsr=x;yBSSDMSXWqYYUI`gvbIt]_dEivVQioUgSexhkUv?exoix_GisGqSgXqxjsVFGVHKsDQsbYv]Yr_SSP?UTaDeov`WcAwetMwckrAyrUgXjOhOKETKEr[XbATHuexcufOYIuexcSs_UHyeymySagtegSgiuhnVmOamV`mnSexxywyuy]Xn]XnOysnhphauA`KSLNRQtLqj@pJH\\Mr<ly]y]yM?DlyUPxAxAxQj=tZHRpqqdyym]yrIXtLQtLXYqqwmVQiy`YmiMT_PTkatcXT`utWilsUvGxPb@Tb\\stDQ]=vKxRXDVf]WfTWdMWhAUP@S^LNJQTjdViquwpNjpstHUr@X[dqv`qFqMbyTN]Tj<Pj<lIhQpAmZhJxqw`mOV=q:qMwLYR]VOiRMUTMtjFDM<Il]tRT`nWmuClvDHPFIRGeSGTLMTLs\\XbATuUqshJqdSZTSDMSbYweYsydycyS`QpAqVrEv?xLRiquuXPplPPmWux<ijEDwewl_f^_nfQigg_\\Of\\KYuUYejQvWv`\\OynEuqxgYWPgyBmtHYcikiBAb:?BE_w;Wtb]HfIt]wBaasSWVpeuPqRoeXoSynIw=yVXGY@QFtiXtcEasSX_SiuWimv`qvT]r@og@QuoWWckDEGySyVYGU>uYsEYsSb=WbS_dN_VIKgtCrasevMRC_R<ieusXT]RyMYtMIOMGOSdMWdu_ylCVmUTJ=T:AvZAV@yrAYUfCbusYxaIwiywIeN_dNqfJgcWWu]Gf[GbMkFF=fywiySxmYxgcWHgtmUsliRcGgc_dEintexdUXRYVM\\qqquu]lEgsL?aahaTPmT@]Yv]IYihIqAQvmvcP`n`pn@HhkGhVnav?q?QjTXoQwolxgYqqqgiZgpkWv@Os^O`X>aj?r\\o`^pn`Pddfllyuyqyqhrf?pnfsGisFOcDOfR?eRhbuqj@pj@nkVFaLHZ;FZpy^KxhBQmoVgbFlB?y[yJoDoWvNIgMmr^]vhmweQIDqtgWUcsdEiGhyh=wBIKtSIuSwcykyrSwdQwfKWEuT[SHmSd;Ir;acGgcoSuxwrUCXdatcKYtMYlMt^@YoQwOUkTQVEAWoPUx<x:YJnahcoxOagpPcAPwYqoYca?UfkvTiheebpwrdIyZYbI;GPScsygyeyEQfp]DN[DJyuYye]wRIoiesdgix][IEKD:;B?SVLCTJcDn[Hj]tbGTF;CB;V[EV[gRgEIwMyncTdcDYoYtIwuOXPwxewgxOf>MF[yBY[qLqnjetdhTN@chQsw>itgqXXdaTcqwhqWOSBZeSGeCAucXcSQsDQkYyiyqqdpsr`AWhmW`yEyAyAMS^KDeGe:iSCES[WcEWCasSX_WYYUqUDPqgWUSC_R<yTXEY?Qt`?dfEeVUTegtV[Ir=h?yrEUUauvHieneXoeV\\MV\\SGeSGgcWHCsPgiaqIxkIV;Ij=fZyrRgX?MCDKCRcEWcSysIykEukXFQt`AuFcEx;R_esTgHNSc?QJuMsTEteixveyoytclLEHyIyYxYtLqvJ`Wc`r_IwcIskUv@IuNePJYQ_PqtPmqyuyuqOeOKXSEUS]PR[@VlMXliUO@timuvHmlEqVaOamQp]l?UkPDThtlmYxIyQq`pclV]Hn[HZIwmHgnLGsn`pnVcUXf^HocHkIyayaa_N\\Cv\\gNe^we`gt;OxmYxsNf>A[dflDoiuiwqplpvnGFwcEwcQl=ujHVpiVXutJAuRWx`is]@c^NvuxwxXgcWhTAxUygyHpYwqx_xkIx[qkWVaffgHhsKwDIXxaysaDEgjVYXIIUWuUPxmYxsBAsBMysIykuxhiuPpPAqVRipeuLw]Yv=MWd]?fZ?nlpvr`@wNI[VXwPio]`c`VvNIoMwwdhnJfpohpvOvCx^bVlCAykyrYVeTamp^mxfiTpyxqyFPkDPqenqvqjHOtYyuYQ_XPpnp^_f^?pghogVf`d_lOasFO[CQp_WsbN\\C`olP\\gyuxqxqNk>Onpw[Gxwd_dN_dj_rBH\\fqtgX]MOdL__gocu`oWWqPP[?Pj=vZH^ptpheggvOxCy^NGoN_[Iv[qPu<feawsXhfypiwAw[Iv[GpwiiPqbxoixvjFF]<gnLGsgVep@eTampGtdCawSYoS:[epcWTgyFqtHKdPod@Ahj?HtOitOX=qbGkdphKcpohpvMxSxDSK@S>IUmpVSylnpu>doPUsSXPaMT^LLkMunHWpQQPtp;unL<SL`ysyvYHw[Iv;AsBAsuPvKuwkXVAAuixeNWoOqdU^mSn]yXisGikYqiqqm`psNjkXfAq[tOitOeoQ`G`kF`[@nZ@N`^^^^XsPxny`isQ@oEt=clCeFQgAStoYwQYTdcdlIdAmEcQh;Ot[YrAGEV[EFqUwOYSeY\\mdMWd=IF=FqVosQpetGwh@m^GwFFmSHmVf`d_\\?QfkvvHimegxM`pof`o^cHoc`@c^NvmvsvVfOvrC>e<fmHwrqyuywmhogh_wQyoYhbd`vpolWWqpGpuwxhadeDQagSUXQegTGwFcR?eRvmxSyVckDE\\xbItpTx>iyExOx@nuXquTJ<LJrHYmqvuPXeesG@teixVaqsUP=LJ<<oPUoshWUqPEUm^UpnMQ;`NUMOydN`lNLmNMHXCchCusaHn[HjEsLgFNGs^]EsKX^gtq]ETegPwsvSxFGX`Igecs`?WoOUxsxVYX>;rSSH`=UwagTEkLlkWTQPPTc`lEulhdwLew]yrYtY^xqyxQ=LJ<\\opMR_hPyYyYyyRYnAuKpAwKYjumxfIpnHQ`Tn[r_WSQOTdcdl]yrIxfSGeShnGSWKfcGgCwEv=x;ctdeHOQWosIrAv=oGOqIhubEudhCx?wDX=fNMG_Af;UbFQYh?hc;upgWUcyvayboTeGykyrYsuOeBpvlY?ar?xZOs_eEsDh[htafygHOgdO_YcifQ?wbAwBAdJ?DxEx?yD`eImktTGtb]HvEy_ydcav^aVmGSREXkEhkCyWKH^=c?UCVIUECgcGgVKH^=C?QVksewmxSUyCmBq=sgeFJ_VEagUQsOWGcav^arJ?\\oytYWuVWZew[wpeIi_Uopj^^^^jHocH_esPh_hcWwtphgUAwhqwHweYwehOunHs``gyp\\wpeIikUv`LytQeAwbAsitQweSSU_t[]xteIQugXeSasFakbAwbmyiyiyigfGMi]KxmYxscVDaD<;vNGGM=UKET[EWMOIFoR]Gv]scvKR:[YnItAegxMHbqTfquwWe[Iv[aXlMX\\QwOYggMhGWE<wTs_UHuYyuYxWyhYiWMWLYg][v^avjyXyWyWcEV[ERiiuuXh=ujGr`UBrQwdQWHqewSeLEgNgYtax[qvGYegmxTMI<Ix]yrS_dN_RK?S>ab>_B`]V^=UTafUqFysIYwSxCy^cr\\EH=MR<=y[ybYkuogtWyYuiwqkirQvE_XpmX`uhheurqxUyWUat^?Ru]EukPiiqqqU<<V<MR<tqyqyuUmVTPhuLwpUIimutXl=yjIv><rKTN@]uOToads;iWa<l@LxmYxsarMtSJ]NLDPhlOHxuxUyghSxEQoMQWtXfAekGhk_\\EDYoYtIWUgCnSsEYssaymxnR]O`]UV]mGiXRlj@tMUTMEEoNMsQlUrEr`ulAev_ivkIrA>c:^mrFh\\hsgVggf_gfvvIymikMfbp`eGWhaqsW`[CF[[Pb[@v<hZE^_lojeimj_vBI\\H_mrFl:>yZYjIN`iv_IQt`fukfZ?fZVx`io]OPc_fuWiusvgXaaU@e<>iu``qv`mwthheFOC?GPScSKETKsIoItAgEaTncsGis_YTIeI?Ec>MrjAxjmgWUipWsF]CbixtmwSYhAWd`cS\\?S^KvZGR=OiNqdK_uVaUHQeoScDcb<OWoOemuvHiiekcZIWf]W^yHYaY=IsMwFMMFK?hQugX]UsOX_ude[SROdLOrkUv@IT^KDkKGdKcemtfGhcGcZqs\\Gtb=i`esTkR@mRL]FLCX<abC[uywYygfGQwL]ukMBc=vRIh]]erCX\\cR\\CD=YjmYvIxQpHk;XRehtlYnIpQ\\=Yr=Q?QVkTlLPlt`sfarkXVAOr>H[NFKSV\\MVrIyaymdiv\\exoixVQp_UKuyxiySK@SNinvEx=yKy<PhlOH@JrlVFAMhiuuxtdXltYXaqskmsVHQN=ON\\xpqx`YqiqqeetYimHPtJAt:ypXQYEpUXmUN=ON\\mmtVHtsWXQaEWmpWBpUixvIxQxAskTV@AL:tjFDMLinPPvT<tb]PveyoytS\\MV\\S:\\Mt\\XbtthhUeUPEUXierCYlaDqjEv<MysIiR__`iiqiuAy_y`ylXsxfnuVh`a[a_sRHbav^aNoNO_HqmwVudW[<fuDPlLP\\hPeoPkwOynI`xFrRIp]wjOwxYyh<GisGaQh_Uofvpu;XZANhoQwOaqrGx\\hnGW`SNaWpkcGgc_muvhhfqv`qFhglYkinqbQxE?pI_mrFrYiyhEOOS_ceV_ercXdaThquwWiEaciyuyXYxDx>?wZAv:glDgrSX`aouOV\\[nl:afC^n;`sFac`v^aVtKItKPc_PlCIsCauqxgYhdoNs`qv`oynYtI_cHcGgcbmrFGEPuU>OvpEIx]yrsEw]xKMS^KDtEYsEXhausoToegasSX_vVIimEgPUgcSdCAyrYvIWuf=hkUGpawSYVVmSL[EV[s_YsQWUGIiVehoghVaisUHAecTcRK?S>Ar:ARhoUwOeoghoodpcs^atNatjiiqqu]=R:=bk;YraymysgoVsOT[EV[Ue>OW>AcKcUlCXvoDwoUIadN_DHUepccDefLODC_bCCCC[Yaieq=eMWd]EWmQIFUV]UFqiwUyrsUx`IHb;GB?BRYgQuGxOxDYGpSilgvp=gb?gZYuiuiGAl[`J:qqwUylilQmUkPy:pof`oFXwQyoaAoKUnbDlB=oLEorTWPaOUpUdPYu\\Mt\\XBXPams^XquXQ;<P`lN@XkQtO`Il]tRRatNaVcUxtdrOXOQ=qwUypmsRHP=puXqu><rB@kBloREp<QWEPxCDkPUo_qrGXMS@lJ@Rk@UFelDerAyMy]mUuphepcxNMPMGvpfGu<yrXVIWgeWG?QVkSDMSDsGX]qRewgQGVeAevCbn;X_QKVupheMApKWLS:\\TehtvMwcxnrhhgp\\ShdhV_eVvPioUGagOunNir?iRvfsxtgXeAY_QooRhuXVcjGwLi^hvex`uR^l@pj@Ph;Qj?^aj?v:HeIa`d_gf_fdOgdvvIymIquwXiM>ZuwXUX?QcO[GdKGlSeWkd^asSWHVwHimekmPV]UVtTf@U;akF`KmpsfulPpllYtIuQ_YRIdQ>ej<ERS`S@yjXLYBXqpewdQpIuRTUVRMTrDYlafCafnohpov=y[y^sIwawatfhyNpeixf@ob@vdf@e;AQkc\\CdBoUX@yLYSidXcOaiobWgeWvhgQu?yuyqyqqr:xsIysIXdapc_ybYJ`mV`htF]SdepTmn`pnlEulhVvxwxXybawfaWF<qYeYoithTQ[ltSlkXdQDIymyvmxVIqm><RyuYymNatNmUx`isPtYthTOeT?iQumxjEr<hJV<PZ=J?Qft@qr@hdatc`y`YmiOqFQ\\]Yu_HqsHmuqxgYvYxYIurCEZQv\\QrkSV@AXSQh_]SCES[eTOed_gsfURxmYxsitQweksXgIUGHkCHN?S^[dDefVCIl]FQmgVPoQmmRXmLPlLloUupHXvAykaXj=XJ?QVkTn]XnsTYpaWxUxG_o`OlU`gS`eWqqwWaawsXhsxiyuYdfn\\MItKu>GCM;ixeytUeUQe\\UsB?SLKBmEv<iBfQuolquqwu\\n^`nZpawNb=Wbk^hbAd>ir?I^f^_FF\\KF\\jaxna`CpqlQxl_f`of\\asSX`rNh^A;ybISFasFAkcHocB]SF]RLMTLkFF=e:?r:ARM?wmgHBMvbxRkisqtuZYuiuq?IwMyn[awfak;YjATN[DN;DtKItB@kB@RJ=TJ\\nLEwWDwdmWhmRXmUXlSYpQGXLalSZAr;XJrLX^_tOit[N`lN\\Mx^Ior^HcM@`Z?r:>k>O^Mfe[hwJatNajN`lN^gYqqWVap_w:inEwlZIwcIkuowsxZ=qjGVbN_dNNr=Yr[ywiyiAQqdPod@lWhmGXtaxc]Ax[Yrr>ijA^HqmwV[?Pb;H`]orZOt^Hcr?v;xZZIv[If<X_mhanN]Gnquqwu^wRIp=vaxAy]NgeWgKypiwe>yrAYfbAt[@wQyoYNr<QrZQwdQiAQqDV[EFlOhl?Xdapc[f`of\\Ap[WNr_YsQHviywIHcMp^[Ox^IsB_cF_jFo^mFrOHuxNiwp]avcX`rxhiuAlLPl<hyuyx]PplP\\Dfj<fytix=wyxiyKf\\OfjJ@lJ^Z?fZ[xfIqmJXs_q^qXvDile>sEYs=oeXo]HqmwVkMx^IOv^IsM@aqowV^xtga<WB]F^[FZquuuw?AcKSFZyvayVlUEtOBawSYorXiiuEhausX[f^NuTQerWiuWfJAn;?]n>gJN^\\N^JYqqwg>`j>@bc`dT`ciWhmW`h^er@jVauV_fawf]AwKYnrNinA_lOhl?Z:FtKItrxyxYykNinAgVYhIiaj_hnS`WieCXxays]wYyiYSyqywAMWdMGlUXmEB:citex<]TN]D\\Of\\?tawSYSVU]xoixO[rHor@qRV]irEDQko:`qv`Q^]V^=vNIoM=QsMx^loVEq<DqVmk;YjATVrAx[AMx\\YrljGTM`MlxYqeTTMUT=XjAtKTTyTaxnaXndPoDrMYtMDtKItBHkCHRr=YrLj=XjK\\LN\\JYuUYUlAqW^DTN]T^]weUplPpj]yrIXV@QkMJ_iv_AlCaVBhkGhR\\MV\\LLMTLk\\WRAPb\\LDTlTAVaqtRhN;`WGeSGeKLQtLAlPpl@XrAxK]dOgdKTdk@<JZIv[IjZ@nZ<yrAy:yrAyJxpqx@TddlJEoN=J:pWWQq;<JdTOeDJn`J>yTipU?EXkEPDMSD=TLMT<XXaqsStUQUoOAkEXk=At[XRKtMYtkRAuRUyQ`oWLKDLKJPlLPj=uZ<OgdO_HamsVZWpcAvZAvZnqwWY]WYqqwjIxkI^yvayZPdc`kx?hmWh=>tL^d;f_xGodPo<GdKG\\DOcD?hcQTCIsCIb]Wf]b>MF;=UR=ELKDL;XIiIqAF[CF;cIt]PkXWppRBMNmTPMTyqywAIr=xJk=xZIR^yvaYJ:\\TddL<UR=ekx=xoihQv\\Q>_OPcBafl>_OPcn^`n>npppPf[Gf[JQgo@_eV_=GhkG`DPkD@hkQv?CikU>;BrOitOEUarjIv=IDQsDAsFasFEmUtgtKuTQub]sRH?EwEdPod@OwdQW:;R:=R:KB<KBFgw<YuUYEhkGh;dEivJ=GN;Xj=X:oTegRmUXmkgXeiDcgPUWnYRkEXkKXmUXKeTOeB:;CF[C>Ah[UrFoiB?cB?iesFLMIEoUiwRPmTPkSV?I[]ysCYlaFhsUx_C:;DEgrjyxqyRqqwWXr=YJdepTAyiXn]Xnk]MjeXoej>MN;eYweQdQwdAJn`xaexoixr`YsQPnLMGlOYmqFPtLQTN\\LN<n\\Pn<<JZDlB=tmxVI]r>arZLQtLMKItKAMj<V:@V;PXQmnkHpKtrHhM=y_wi\\cIwcAyoytYGlMXl=pv`qf:>jYxmYNZ<NZZIwcI[IwcI?iuWi=gnLGr?ir?Ndc`\\Hn[H>db^\\boghojPWo?>t\\YrtPqt^lQxl]`n^`Z_iv_A_hn_@ijEv\\JatNaZ:>xqyxA_cF_[@v[X^k;Wj@FfjAv;AdehtPVqInpFGgcG_Hx]yngFouHgmtffVVy;>rKItKFb;Gb@qhbIv[IZIwcI?oNO_rFasF]MfhOPc?FpR_u`haPwdQWn[Hn;N]GpnGycKGdKN[EV[[xteIZn`r]FlKHlB`kF`byqywikMPcpIpgqsbHocH`pyoancVTvAyk]V_eV[ohpoD:UciUYoQw?sSIuSbgtdUVucTdcd@Ay>MFK?EMsxdQwd=wnMIncHoCEAyrEydiSfv_iVAyiIymyvKuUYuC:;Tb[DBsCIsWMytpywYyEHqsHqDuwFpMUjSY<CuXcV_eVBQsDQRpmXpkYuiwq[dPod\\_f^LkEXk[htdETWeUGLl@aR?isGiK\\DlBlohpojEXkEjixoiHPcaKDLK<uuxhYGMy>UxhUn[Hn;DuSIu@umNlLPLnn`pNtlhdU<eTOeTU`jK<RU`jLgn<wxhiu[iwgi[ywiy_j?hj[^?pqwUy<Ir;Ir\\ut^UoVEqleJSEUS=sFas>mWhmokDLcDOcDRoehNatNAnklTPmTTV\\DOMHsZQwdQKiuWiUV<IMR<Mb]Y<pLJ<LZEwEQpCmOX]aSGeS?sBm\\irEpRy\\lPpl\\PqtPur<NpdPoDrSIuSLXs`MHqsHAXoeXgUlryxhiuUDLKDLB@kB@PHmkSIPGdtOgkmptsGis?_dN_dWlBNgnN]NiTeWLgRLor^[BbEC\\eEWcE[oTegc;sgqwhqKYnAw;?fZ?F>cB?CFj;HJqyn=U:MeTOeFwSDSXlMXjEx\\ijZQpo]UZXtcATQuTAPytQypDRdXoeXOVhmWHvcIwCtOitO]uUb=YdHuuxXi=qr@ajidpggnQiwNkDPkFxcAvsYxai_g=P]GpZ_iv_AodPolnctOZyy\\M?]tqc:>ddflj_hn_gmF\\^Iv[IZyvay^xfIuMAyNXtJvjRI`IfRp`TQxlQhb_`T^lPpl<WnKAvditext_Vk:noEO_OPc_^tdg`v`qv`kMV[@piPAx>d]eeReR<CWAqcW\\wRIp]urHhMuJyLVEUMZurHh=VF:GbwCbnWVAq;]?Jt\\jwDjnXVAq;\\GZt^jN>rCWcUFfAqkWJp;BeyvyIR?CEWSbH]FymI:;B:;RLEdMCde?DR?6>\"\{\}LSUlUk9PVEc2Jy0lKUJPVU5EU19YRzYjJCIiISEiIi0lKUJPVU5EU19ZR0YnLSUtQk9VTkRTX1dJRFRIRzYjJCIlPyIqRiotJS5CT1VORFNfSEVJR0hURzYjJCIlXTpGKi0lKUNISUxEUkVORzYiJSFH