code
stringlengths 10
174k
| nl
stringlengths 3
129k
|
|---|---|
static boolean isInstanceOfNotEqualConditionEvaluator(Object o){
return o instanceof RangeJunction.NotEqualConditionEvaluator;
}
| Test method which checks if the Filter operand is of type NotEqualConditionEvaluator |
protected float floatSpeed(int lSpeed){
if (lSpeed == 0) {
return 0.f;
}
else if (lSpeed == 1) {
return -1.f;
}
else {
return ((lSpeed - 1) / 126.f);
}
}
| Convert a CBUS speed integer to a float speed value |
public Geo cross(Geo b){
return cross(b,new Geo());
}
| Vector cross product. |
public String globalInfo(){
return "Class for running an arbitrary clusterer on data that has been passed " + "through an arbitrary filter. Like the clusterer, the structure of the filter " + "is based exclusively on the training data and test instances will be processed "+ "by the filter without changing their structure.";
}
| Returns a string describing this clusterer. |
public NearestNeighbour(int k,boolean weighted,DistanceMetric distanceMetric,VectorCollectionFactory<VecPaired<Vec,Double>> vcf){
this.mode=null;
this.vcf=vcf;
this.k=k;
this.weighted=weighted;
this.distanceMetric=distanceMetric;
}
| Constructs a new Nearest Neighbor Classifier |
public StatusDetail withDetail(final String key,final String value){
final LinkedHashMap<String,String> newDetails=new LinkedHashMap<>(details);
newDetails.put(key,value);
return statusDetail(name,status,message,newDetails);
}
| Create a copy of this StatusDetail, add a detail and return the new StatusDetail. |
public IntIteratorSpliterator(PrimitiveIterator.OfInt iterator,long size,int characteristics){
this.it=iterator;
this.est=size;
this.characteristics=(characteristics & Spliterator.CONCURRENT) == 0 ? characteristics | Spliterator.SIZED | Spliterator.SUBSIZED : characteristics;
}
| Creates a spliterator using the given iterator for traversal, and reporting the given initial size and characteristics. |
public static DetailPostWebFragment newInstance(String param1,String param2){
DetailPostWebFragment fragment=new DetailPostWebFragment();
Bundle args=new Bundle();
args.putString(ARG_PARAM1,param1);
args.putString(ARG_PARAM2,param2);
fragment.setArguments(args);
return fragment;
}
| Use this factory method to create a new instance of this fragment using the provided parameters. |
@Override public boolean hasActiveShield(int location){
if ((location != Mech.LOC_RARM) && (location != Mech.LOC_LARM)) {
return false;
}
if (isShutDown() || (getCrew().isKoThisRound() || getCrew().isUnconscious())) {
return false;
}
for (int slot=0; slot < this.getNumberOfCriticals(location); slot++) {
CriticalSlot cs=getCritical(location,slot);
if (cs == null) {
continue;
}
if (cs.getType() != CriticalSlot.TYPE_EQUIPMENT) {
continue;
}
if (cs.isDamaged()) {
continue;
}
Mounted m=cs.getMount();
EquipmentType type=m.getType();
if ((type instanceof MiscType) && ((MiscType)type).isShield() && m.curMode().equals(MiscType.S_ACTIVE_SHIELD)) {
return m.getCurrentDamageCapacity(this,m.getLocation()) > 0;
}
}
return false;
}
| Does the mech have an active shield This should only be called by hasActiveShield(location,rear) |
public static void notifyNativeGestureStarted(View view,MotionEvent event){
RootViewUtil.getRootView(view).onChildStartedNativeGesture(event);
}
| Helper method that should be called when a native view starts a native gesture (e.g. a native ScrollView takes control of a gesture stream and starts scrolling). This will handle dispatching the appropriate events to JS to make sure the gesture in JS is canceled. |
private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, java.io.NotActiveException, ClassNotFoundException {
s.defaultReadObject();
thisX500Name=new X500Name(name);
}
| Reads this object from a stream (i.e., deserializes it) |
public static boolean gitLocalConfig(final AtomicReference<String> path) throws IOException {
return gitLocalConfig(Environment.getCurrentDirectory(),path);
}
| Gets the path to the Git local configuration file based on the current working directory. |
public void clear(){
fullyLock();
try {
for (Node<E> p, h=head; (p=h.next) != null; h=p) {
h.next=h;
p.item=null;
}
head=last;
if (count.getAndSet(0) == capacity) notFull.signal();
}
finally {
fullyUnlock();
}
}
| Atomically removes all of the elements from this queue. The queue will be empty after this call returns. |
public static final double show(Window owner){
ApplyTorqueDialog atd=new ApplyTorqueDialog(owner);
atd.setLocationRelativeTo(owner);
atd.setVisible(true);
if (!atd.canceled) {
double t=atd.torquePanel.getTorque();
return t;
}
return 0.0;
}
| Shows a dialog used to accept input for applying a torque to a body. <p> Returns zero if the dialog is closed or canceled. |
public final void sort(){
flushLocal();
((SortTODSharedDeque)queue).sort();
}
| Sort the address on the shared stack. |
private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
if (xmlWriter.getPrefix(namespace) == null) {
xmlWriter.writeNamespace(prefix,namespace);
xmlWriter.setPrefix(prefix,namespace);
}
xmlWriter.writeAttribute(namespace,attName,attValue);
}
| Util method to write an attribute with the ns prefix |
@Override public void run(){
amIActive=true;
String inputHeader1=null;
String inputHeader2=null;
if (args.length <= 0) {
showFeedback("Plugin parameters have not been set.");
return;
}
inputHeader1=args[0];
inputHeader2=args[1];
if (inputHeader1 == null || inputHeader2 == null) {
showFeedback("One or more of the input parameters have not been set properly.");
return;
}
try {
int row, col;
double x, y;
float progress=0;
WhiteboxRaster image1=new WhiteboxRaster(inputHeader1,"r");
int rows=image1.getNumberRows();
int cols=image1.getNumberColumns();
double noData1=image1.getNoDataValue();
int image1Min=(int)image1.getMinimumValue();
int image1Max=(int)image1.getMaximumValue();
int image1Range=image1Max - image1Min + 1;
WhiteboxRaster image2=new WhiteboxRaster(inputHeader2,"r");
if (rows != image2.getNumberRows() || cols != image2.getNumberColumns()) {
showFeedback("The input images must have the same dimensions (rows and columns).");
return;
}
double noData2=image2.getNoDataValue();
int image2Min=(int)image2.getMinimumValue();
int image2Max=(int)image2.getMaximumValue();
int image2Range=image2Max - image2Min + 1;
long[][] contingencyTable=new long[image1Range][image2Range];
double[] data1, data2;
for (row=0; row < rows; row++) {
data1=image1.getRowValues(row);
data2=image2.getRowValues(row);
for (col=0; col < cols; col++) {
x=data1[col];
y=data2[col];
if (x != noData1 && y != noData2) {
contingencyTable[(int)(x - image1Min)][(int)(y - image2Min)]++;
}
}
if (cancelOp) {
cancelOperation();
return;
}
progress=(float)(100f * row / (rows - 1));
updateProgress((int)progress);
}
DecimalFormat df=new DecimalFormat("###,###,###,###");
String retstr=null;
retstr="CROSS-TABULATION REPORT\n\n";
retstr+="Input Image 1 (X):\t\t" + image1.getShortHeaderFile() + "\n";
retstr+="Input Image 2 (Y):\t\t" + image2.getShortHeaderFile() + "\n\n";
String contingency="\t\tImage 1\nImage 2";
for (int a=0; a < image1Range; a++) {
contingency+="\t" + (a + image1Min);
}
contingency+="\n";
for (int b=0; b < image2Range; b++) {
contingency+=(b + image2Min);
for (int a=0; a < image1Range; a++) {
contingency+="\t" + df.format(contingencyTable[a][b]);
}
contingency+="\n";
}
retstr+=contingency;
returnData(retstr);
image1.close();
image2.close();
}
catch ( OutOfMemoryError oe) {
myHost.showFeedback("An out-of-memory error has occurred during operation.");
}
catch ( Exception e) {
myHost.showFeedback("An error has occurred during operation. See log file for details.");
myHost.logException("Error in " + getDescriptiveName(),e);
}
finally {
updateProgress("Progress: ",0);
amIActive=false;
myHost.pluginComplete();
}
}
| Used to execute this plugin tool. |
void remove(String key){
map.remove(key);
}
| Remove a session attribute from the map. |
public static Map<String,Object> findProductById(DispatchContext ctx,Map<String,Object> context){
Delegator delegator=ctx.getDelegator();
String idToFind=(String)context.get("idToFind");
String goodIdentificationTypeId=(String)context.get("goodIdentificationTypeId");
String searchProductFirstContext=(String)context.get("searchProductFirst");
String searchAllIdContext=(String)context.get("searchAllId");
boolean searchProductFirst=UtilValidate.isNotEmpty(searchProductFirstContext) && "N".equals(searchProductFirstContext) ? false : true;
boolean searchAllId=UtilValidate.isNotEmpty(searchAllIdContext) && "Y".equals(searchAllIdContext) ? true : false;
GenericValue product=null;
List<GenericValue> productsFound=null;
try {
productsFound=ProductWorker.findProductsById(delegator,idToFind,goodIdentificationTypeId,searchProductFirst,searchAllId);
}
catch ( GenericEntityException e) {
Debug.logError(e,module);
return ServiceUtil.returnError(e.getMessage());
}
if (UtilValidate.isNotEmpty(productsFound)) {
product=EntityUtil.getFirst(productsFound);
productsFound.remove(0);
}
Map<String,Object> result=ServiceUtil.returnSuccess();
result.put("product",product);
result.put("productsList",productsFound);
return result;
}
| Finds productId(s) corresponding to a product reference, productId or a GoodIdentification idValue |
@Override public void writeExternal(ObjectOutput out) throws IOException {
super.writeExternal(out);
out.writeDouble(knnDistance);
}
| Calls the super method and writes the knn distance of this entry to the specified stream. |
public Number parse(String text,ParsePosition parsePosition){
String s=text.substring(parsePosition.getIndex());
long tot=0, max=0;
char ch[]=s.toUpperCase().toCharArray();
int i, p;
for (p=ch.length - 1; p >= 0; p--) {
for (i=0; i < syms.length; i++) {
if (syms[i].symbol == ch[p]) {
if (syms[i].value >= max) tot+=(max=syms[i].value);
else tot-=syms[i].value;
}
}
}
parsePosition.setIndex(s.length());
return new Long(tot);
}
| This method converts a Roman Numeral string to a long integer. It does not check that the string is in the correct format - for some incorrectly formatted numbers, i.e. iix, it will produce a number. For others, it will throw an exception. |
public static String encodeWithinQuery(final String unescaped) throws URIException {
return encodeWithinQuery(unescaped,URI.getDefaultProtocolCharset());
}
| Escape and encode a string regarded as within the query component of an URI with the default protocol charset. When a query comprise the name and value pairs, it is used in order to encode each name and value string. The reserved special characters within a query component are being included in encoding the query. |
protected void removeValues() throws Exception {
int i, j;
int flag, count;
count=m_vals.size();
j=0;
for (i=0; i < count; i++) {
flag=m_editFlags.get(j);
if ((flag == FolderEditFlag.NONE) || (flag == FolderEditFlag.UPDATE)) {
flag=FolderEditFlag.REMOVE;
m_editFlags.set(j,flag);
j=j + 1;
}
else if (flag == FolderEditFlag.NEW) {
m_editFlags.remove(j);
m_vals.remove(j);
}
}
}
| Elimina todos los valores asociados al campo multivalor |
public boolean equals(Object obj){
if (this == obj) {
return true;
}
if (obj instanceof AttributeSet) {
AttributeSet attrs=(AttributeSet)obj;
return isEqual(attrs);
}
return false;
}
| Compares this object to the specified object. The result is <code>true</code> if the object is an equivalent set of attributes. |
protected void reset(int linksSize,int varArraySize){
_frameTop=0;
_linksTop=0;
if (_links == null) {
_links=new int[linksSize];
}
_links[_linksTop++]=0;
_stackFrames=new XObject[varArraySize];
}
| Reset the stack to a start position. |
public SimpleDateFormat(){
super();
}
| Construct a SimpleDateFormat with no pattern. |
private static double[][] powerSymmMatrix(double[][] inMatrix,double power){
EigenValueDecompositionSymm eigenDeco=new EigenValueDecompositionSymm(inMatrix);
int m=Matrix.getNumOfRows(inMatrix);
double[][] eigenVectors=eigenDeco.getV();
double[] eigenValues=eigenDeco.getRealEigenvalues();
for (int i=0; i < m; ++i) {
eigenValues[i]=Math.pow(eigenValues[i],power);
}
return (Matrix.mult(Matrix.mult(eigenVectors,Matrix.diag(eigenValues)),Matrix.transpose(eigenVectors)));
}
| Calculates the power of a symmetric matrix. |
public boolean isValid(){
if (!_parameters.hasParameter("required") && !_parameters.hasParameter("if_available")) {
_log.warn("One of 'required' or 'if_available' parameters must be present.");
return false;
}
if (!_parameters.hasParameter("mode") || !"fetch_request".equals(_parameters.getParameterValue("mode"))) {
_log.warn("Invalid mode value in fetch_request: " + _parameters.getParameterValue("mode"));
return false;
}
if (_parameters.hasParameter("required")) {
String[] aliases=_parameters.getParameterValue("required").split(",");
for (int i=0; i < aliases.length; i++) {
String alias=aliases[i];
if (!_parameters.hasParameter("type." + alias)) {
_log.warn("Type missing for attribute alias: " + alias);
return false;
}
if (!checkCount(alias)) return false;
}
}
if (_parameters.hasParameter("if_available")) {
String[] aliases=_parameters.getParameterValue("if_available").split(",");
for (int i=0; i < aliases.length; i++) {
String alias=aliases[i];
if (!_parameters.hasParameter("type." + alias)) {
_log.warn("Type missing for attribute alias: " + alias);
return false;
}
if (!checkCount(alias)) return false;
}
}
Iterator it=_parameters.getParameters().iterator();
while (it.hasNext()) {
String paramName=((Parameter)it.next()).getKey();
if (!paramName.equals("mode") && !paramName.startsWith("type.") && !paramName.startsWith("count.")&& !paramName.equals("required")&& !paramName.equals("if_available")&& !paramName.equals("update_url")) {
_log.warn("Invalid parameter name in fetch request: " + paramName);
}
}
return true;
}
| Checks the validity of the extension. <p> Used when constructing a extension from a parameter list. |
private void breakBarrier(){
generation.broken=true;
count=parties;
trip.signalAll();
}
| Sets current barrier generation as broken and wakes up everyone. Called only while holding lock. |
@RequestMapping(value="/foos/{id}",method=RequestMethod.DELETE,produces=MediaType.APPLICATION_JSON_VALUE) @Timed public ResponseEntity<Void> deleteFoo(@PathVariable Long id){
log.debug("REST request to delete Foo : {}",id);
fooRepository.delete(id);
return ResponseEntity.ok().headers(HeaderUtil.createEntityDeletionAlert("foo",id.toString())).build();
}
| DELETE /foos/:id -> delete the "id" foo. |
private static boolean isViewDescendantOf(View child,View parent){
if (child == parent) {
return true;
}
final ViewParent theParent=child.getParent();
return (theParent instanceof ViewGroup) && isViewDescendantOf((View)theParent,parent);
}
| Return true if child is a descendant of parent, (or equal to the parent). |
protected RrdNioBackend(String path,boolean readOnly,int syncPeriod) throws IOException {
super(path,readOnly);
try {
mapFile();
if (!readOnly) {
fileSyncTimer.schedule(syncTask,syncPeriod * 1000L,syncPeriod * 1000L);
}
}
catch ( final IOException ioe) {
super.close();
throw ioe;
}
}
| Creates RrdFileBackend object for the given file path, backed by java.nio.* classes. |
private static Device findAvailableDevice(){
Device device=Display.getCurrent();
if (device == null) {
device=Display.getDefault();
}
if (device == null) throw new IllegalStateException("No display available");
return device;
}
| Find an available device to create image with. |
public static final int max(int a,int b,int c){
return (a > b) ? ((a > c) ? a : c) : ((b > c) ? b : c);
}
| Returns the maximum value of three ints. |
public void commit() throws IOException {
if (hasErrors) {
completeEdit(this,false);
remove(entry.key);
}
else {
completeEdit(this,true);
}
}
| Commits this edit so it is visible to readers. This releases the edit lock so another edit may be started on the same key. |
public void updateOwners(Property property,BasicProperty basicProp,Address ownerAddress){
int orderNo=0;
basicProp.getPropertyOwnerInfo().clear();
for ( final PropertyOwnerInfo ownerInfo : property.getBasicProperty().getPropertyOwnerInfoProxy()) {
if (ownerInfo != null) {
User user=null;
if (StringUtils.isNotBlank(ownerInfo.getOwner().getAadhaarNumber())) user=userService.getUserByAadhaarNumber(ownerInfo.getOwner().getAadhaarNumber());
else user=(User)find("From User where name = ? and mobileNumber = ? and gender = ? ",ownerInfo.getOwner().getName(),ownerInfo.getOwner().getMobileNumber(),ownerInfo.getOwner().getGender());
if (user == null) {
orderNo++;
final Citizen newOwner=new Citizen();
newOwner.setAadhaarNumber(ownerInfo.getOwner().getAadhaarNumber());
newOwner.setMobileNumber(ownerInfo.getOwner().getMobileNumber());
newOwner.setEmailId(ownerInfo.getOwner().getEmailId());
newOwner.setGender(ownerInfo.getOwner().getGender());
newOwner.setGuardian(ownerInfo.getOwner().getGuardian());
newOwner.setGuardianRelation(ownerInfo.getOwner().getGuardianRelation());
newOwner.setName(ownerInfo.getOwner().getName());
newOwner.setSalutation(ownerInfo.getOwner().getSalutation());
newOwner.setPassword("NOT SET");
newOwner.setUsername(propertyTaxUtil.generateUserName(ownerInfo.getOwner().getName()));
userService.createUser(newOwner);
ownerInfo.setBasicProperty(basicProp);
ownerInfo.setOwner(newOwner);
ownerInfo.setOrderNo(orderNo);
LOGGER.debug("createOwners: OwnerAddress: " + ownerAddress);
ownerInfo.getOwner().addAddress(ownerAddress);
}
else {
user.setAadhaarNumber(ownerInfo.getOwner().getAadhaarNumber());
user.setMobileNumber(ownerInfo.getOwner().getMobileNumber());
user.setName(ownerInfo.getOwner().getName());
user.setGender(ownerInfo.getOwner().getGender());
user.setEmailId(ownerInfo.getOwner().getEmailId());
user.setGuardian(ownerInfo.getOwner().getGuardian());
user.setGuardianRelation(ownerInfo.getOwner().getGuardianRelation());
ownerInfo.setOwner(user);
ownerInfo.setBasicProperty(basicProp);
}
}
basicProp.addPropertyOwners(ownerInfo);
}
}
| Update the owners for a property |
public Object runSafely(Catbert.FastStack stack) throws Exception {
MediaFile mf=getMediaFile(stack);
return Boolean.valueOf(mf != null && mf.isPicture());
}
| Returns true if this MediaFile's content represents a picture file |
@Override protected EClass eStaticClass(){
return StextPackage.Literals.EXIT_EVENT;
}
| <!-- begin-user-doc --> <!-- end-user-doc --> |
public String globalInfo(){
return "Class for visualizing class probability estimates.\n\n" + "For more information, see\n\n" + getTechnicalInformation().toString();
}
| Returns a string describing this tool |
public void write(Out out,int value) throws IOException {
int code=codes[value];
int bitCount=30 - Integer.numberOfLeadingZeros(code);
Node n=tree;
for (int i=bitCount; i >= 0; i--) {
boolean goRight=((code >> i) & 1) == 1;
int prob=(int)((long)MAX_PROBABILITY * n.right.frequency / n.frequency);
out.writeBit(goRight,prob);
n=goRight ? n.right : n.left;
}
}
| Write a value. |
public TreeRTGAcaciaAbyssinica(){
super();
this.logBlock=Blocks.LOG2.getDefaultState();
this.leavesBlock=Blocks.LEAVES2.getDefaultState();
this.trunkSize=12;
}
| <b>Acacia Abyssinica (Flat-top Acacia)</b><br><br> <u>Relevant variables:</u><br> logBlock, logMeta, leavesBlock, leavesMeta, trunkSize, <s>crownSize</s>, noLeaves<br><br> <u>DecoTree example:</u><br> DecoTree decoTree = new DecoTree(new TreeRTGAcaciaAbyssinica());<br> decoTree.treeType = DecoTree.TreeType.RTG_TREE;<br> decoTree.treeCondition = DecoTree.TreeCondition.NOISE_GREATER_AND_RANDOM_CHANCE;<br> decoTree.distribution = new DecoTree.Distribution(100f, 6f, 0.8f);<br> decoTree.treeConditionNoise = 0f;<br> decoTree.treeConditionChance = 4;<br> decoTree.logBlock = Blocks.LOG2;<br> decoTree.logMeta = (byte)0;<br> decoTree.leavesBlock = Blocks.LEAVES2;<br> decoTree.leavesMeta = (byte)0;<br> decoTree.minTrunkSize = 6;<br> decoTree.maxTrunkSize = 16;<br> decoTree.noLeaves = false;<br> this.addDeco(decoTree); <br><br> <a href="http://i.imgur.com/aPVtMV2.png"><img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAADaCAIAAAAHaYMlAAAAB3RJTUUH4AUBBi0uUr1ypQAAAAlwSFlzAAAewQAAHsEBw2lUUwAAAARnQU1BAACxjwv8YQUAAQLFSURBVHja7L0HuF1XeSa811q7nnq7uizJNu42BhfMYAxj0w1hbCYkgUAKISQZ0iY9GZwECCnzD/MTEhISSAKTQskQHBJKsDGm2djYlrtlW/1KuvXcU3ff63+/b517LXfJllX49/fouTr33F1Xedf71SV+97PaKqWUUko5EcQ+1g9QSimllPLEIh73TQlYpZRSyvEi4ukOKAGrlFJKOdrytMD0ZFICVinPuTzj0VkK5PvDxnykxoBdDqZSSjmepZyhB4s81g9QSimllHKoUqqEpZRSyokgTDVLwCqllFKOG3k6BbgErFJKKeXYyWGa6ErAKuWoSGk6PhT5/vAIPl6OXO/b5UgqpZTjRcrJ+HRSeglLKaWUE0ZKwCqllFJODBGlDauUUko5PuUJ9eMSsEoppZRjJodrtSsBq5RSSjlK8uydCmUuYSmllHLCSGl0L6WUUk4YKQGrlFJKOWGkBKxSSinlhJESsEoppZQTRkrAKqWUUk4YKcMaSimllONSxBN8UQJWKaWUcuxEPMVvTyAlYJVSSilHRQ4Tm55QyvIypTyNlAOklONHykj3Ukop5YSR0ktYSimlnDBSAlYppZRywkgJWKWUUsoJIyVglVJKKSeMlGENpZRSynEkT+0GLAGrlFJKOQbyDOOwyrCGUkop5fiVRyNUybBKKaWUYy2HzJtKwCqllFKeYyl3fi6llFL+fyglwyqllFKOd1mhVSVglVJKKcdSDkvHKwGrlFJKORpyRIxPZVhDKaWUcsJImZpTSimlnDBSqoSllFLKcSlPpP2VgFVKKaUcdRHP8I9lHFYppZRytOUZo05pdC+llFJOGCmN7qWUUsoJI6UNq5RSSjkBxOiCJWCVUkopx4UcinmqBKxSSinlaMhhmMuf/NDS6F5KKaUcFTkSWFOGNZRSSiknjJQqYSmllHLs5RCJUwlYpZRSynMuR0qRK21YpZRSyokgDFUlwyqllFKOhRwaV3rMUaXRvZRSSjk28gywp1QJSymllBNGSpWwlFJKOd6l3ISilFJKOWYiDumrJ5BSJSzlcVKOiVKOVymN7qWUUsrxK4/zEpZSSimlPPdSbvNVSimlfL/IIdqwSpWwlFJKOSZSxmGVUkop389S1nQvpZRSThixRUmxSimllBNESoZVSimlnDBS2rBKKaWUE0ZKL2EppZRywkjJsEoppZQTRkqjeymllHLCSGl0L6WUUk4YKRlWKaWUcsJIacMqpZRSThgpGVYppZTynEsUtga9GSFEGhdCWrqwlC2kwhdWEtE3B3bf3e9OBzXl+GppJrZdUWQWvl+14ZxNz7t85TpleZlSSinlyEuWRbsfvHH3A7eH4YHpnTf2u3OW6ACetLbcQNqOjMO8v5Q5rgBCCaHxE1iGf1KKatPOUo3DgGXnibc/CrBKhlVKKaUcrkSDpbC/+OBdXx30Zmf23rE4f1Ohw347A9bgr3mm27OxcoWUVlC3s7gAADme7LbS0dWeUqK7kNiudDwRdnO/Zidh0ZmPcACBVJgrR+Sp7iwkRa7jQX4wRpWAVUoppTy9JHF3Zs+du7bdDOVuxwNf6Szsj6IF6HQ617YHKqQBJNURO6irhb2hcqVbkYN2VmmosJv1FtP6uOPXVHXEgSbYb6e4oHJkddQJaoXjizQp8NdK3fHrarCU4dzOXOK4EgfjIo8CrDKuoZRSvp8kzzPQnx0PfNUNVNTL6Jss27ntukrTAVtJohxAIKQQ0nJ91WsRdri+POeiH9l48sukfMRGlKbh9vu/3J6f37v9m7P771ia35cmfaCMVFYaFSBBoD+WpqJWg0629tRq2MkdX7bnEnwHoBFCAcvyzAIeeQEZq9KwiLI87GfNSbfIRNwn6oSL9A5AMZS6sABkeVbg2TrzKUAQMJUm2q/lcdjCL3lu4XjxF1/Vx7qFSymllMOWxdkd0ztv7XV3QrcCZED5UracPbB1/85ti/P3AYMAK5j2wALJ5u2wkwFfQF6kFEVhAcvws1JXABfgAmDoze/89zXrL1m5/teu/cA3v/R+RjAoaEWhKYsPkAHlTnFwAeCpyK0i03x9Aqk01gCjsEecCFCIW2cJAZBXUWRfpytZWaJxgF9VWlu1EQcX6cwnpDC6EvQKx0OdxOf2bIJf8Wp4TrzX2Bp/ZkcfOmOpEpZSyokhmMphv7Vz27d2bLtu17Yb24t7bS+DMqWU8KoK3AfYAZICqkLW66gYWQUio4EL3fkEkOEGBFUAC2BHnurxdb5hQ5aE2pU6niA7U5Gu3E7Z2nbpyCzNARy4SxYX0pZKFzbolSboKfLCq9i4Bz6DRgV1uTAd2o4EXNZHHcDbwnTkBcA1uhSOAb/DBSsNG1/GYYEHwI2aq1zwL0Ae7l+p272lFBBWadojq7z2XFxpOADLA9v7zSkPB4uPXl8yrFJKOX6lKIrbv/PRB26/YWbfd/vdOV1omrGsiwGVRld7wCyyJRUW/gR6gumNz4IIF2GEX1PgR6A5OA1gASjh83FZbXQ6OtIBEaOAA6kkLg3eBGQJajaAA2QH1wSaGHKEU4QSQVUZWmf0yhQwRJAk+620OmL7VTAu6Ik5bgEAwgMM2hlUyIW9cZYWjXEHEIkj8bQTGwGiAjQQUAi6111IcHBzwoXqCgjG9dsziVdTwNYe/lQn27wtS4ZVSinHq8RRd8/2m//1k78CjQ/zH8AEiIFeBDCKB4XjK0AADoMmBbzQWuBX4BfQx/VIC3M8q79E+pfjKaiE0L/Cbg7MgraFyZ+GFAAltbADEBzZXYjBa8CPgEpgZIA5QNugm9ls81JkhiJyBDTEuQCvoG4Dj0DZCtw6KcJ2hrOAod2FEOACYIKG2JhwWvvjQTcHg6uNOUBDPAkROl/hqYCMaZjTdTWhZGPcBYLO7Y6Chh2HhH3KFZWa3dof4ZjuQkrxECVglVLKcSh33vpPN13/lwf23pnGMduwieOA7NCHnD6Aodi+BGlKE2hkhRsATZywk2JGe74CrgE78hzfE4jgeHAWAJZLhie9NMNKYkUSjVpIwG46+6PmlAu0SqLCIa9fTrTIFsCdJAZ5I8s66A/gCQeMr/WBhiBN+DXq58zRhBNIXJOgM9OuJ/FUeNT2fOJWcKgAU1vcFxsL/egqH6pr1M+qtsO8Kcfj+RWwOAvgaBPXywGIti1Gpjy8Jl4ePC4vNDOs0k1YSinHnxzYfc++nbdC1SJulRfKJmwC4gARvIAs1kAHcrG1UtsRdkUBVqBJVUcdKFk4BRAAShI0FKABqMRsS2DCU5STLUbXeKA2gBJjiQfcgP4AFHAF/CMwsoEREqoi8AiqYqXp+FULwGGT8qhA8eIeoQyRIFvURp2F6QjP3JlLQMGAm64n3IoNPtWeBRqSWxAPjH84GASt10qAejgLD4PnJ6pVWCCGeLWAbVjVpgPOBTie2x2SzhsX/SXQK1UyrFJKOe6E4hLCpfkD22jSugK4AN4BrPFrdpEVgANMYKAJFCsABw4gHS3KgTiAKiAajmzPp2TYriooZYwROkt1d7HwqoQvOAVIAWDqdzK2MTHHSTWUR1IJXYrezFm1NLcGfiWkuFngRD5Zr+iCYFUjq11iagFUUTJyAd3wPZ6tAOSNOL39kU1+w8LYsByynWnzPBnzRGCQ2egLWir+j/u5+ayUxLPh88LeCG+EW+CvwNbGeK3ISsAq5TmQ+dmHdJFqst9aRpdZ+VAQZVBTa0471s/49DI3cz9bptPt275GliMlwHdo/oMs5FBhahs2v7g5st7z60fwplkaf+yDP7D9/m+aQIEsLUBqoh4ZnvA5w/yv2pq8ahYYB45PAG+kDyp24Yl+O/Mrstq0yTpOza6BI4ab4ODW/pjdhfbidFwfczqLCauK0tICaiMwDshSY46WFhbuSxaxuDBuPvL0URCWsc2L7mIah+Qu7CykdiejYIUOASjuIrUVLRDipLiuJQaLOamURlirpQ/mC0H/rQQq4K3qjclqYxwf1mw4e3R8Pb5cv+n8+sgqfFi78dyg0hT/8O3SS1jK4cmgv/itG/6ou5i0l3bO7dvmsVdI5yYwR2NlbremMcDxJYa4ReF/RZ7o+rjTZ7MI5kOlsq5gq8oVr3/vmee+4eg89u4dNw26bUyq7Q/cmOeRkBT6SLFCKVGJLFvavf0W8yXmIVShQThNDx8XzDIIcwmzMtLONAmFIL3lp//xeWe+5kg94Rc+/Vtbv/vZ9uI+6GgWmdK1SVJRtoUHw0Pi1ngGl2hU7vgEWINOBjaEL0GO8JmsSDEpVsCpuV0DHJPTO1IGjEl8AfahC3BNYAc6gtcSbQIdcC/bE8ZgRHau2RjtgD+ZJGRobYQy7GIsGDMUBaI7+OCj46FEKuVquiRYHB7zwNK+yCLYwrG51l6NzGrUbIXlePaWU16OW2/YTGCEVx2f2jy1ltawoDoKVHqKJrLLUPdSDpYo7Nx+y6ezJHl42w2YGBjumJbdzvT+vfdiWKYhZi0tiZi3fkWRQ12KQagpcppDCilCp6DJTBCGlbZPbB9/wrlLswkmDAUgWrrX3wuS0unqxQMP2c9/Dl/nwftu+Pw//dpS60HMRgCTS+bkggKmFYcxDtd2/EeWXTyb+cI8OdQfc0BBFAFYjBej+WxpDgiwBCAg7M2LIoGadESedtCb7yztZx5qmdgligWXHFIQE0c1FiiKX8c3HGCZRgQKeHKwJ3xIewUeOW7n/BqsZ9G59JtJLebXGfKanDQ7weBLRIzM2VpAU4ucjKINHPJIFkSIhDlFr/AkoJJ0Rr0p26Ymchwny0iVC3wvSTPf89IstVcpN6QnB3HDRXAFE3FKkRBu8LO/+S/PrIkAi8/hcCnlhJM4WvzCZ3+FUiUoMpCWbow5pSiuL09z25MmDsiDDkKWCNFbSit1m2dR7tcUZg7UClAnDFMs2rogPQUrMmDC4/kfMxBEg1wyim297VNx0sZYP+v5V67f+MIj/jrf/tpHZ/bdH9SIMlBEZaINh8Ij2ZxcwiFLPIGlxfkfmmOaKHwJuOBVbHaZFSrANCO2gldmxRAITczxXz718zd+9YPnvOANr3r97z6b59z50PduvvHv7r/ri1gJbDYGadJGCWXoRrE1pCccrqkZOZLwEU0L0rScgdAVt0I8yfUrQYUgmOlIJ2y3ui2AiHlNyyC10cwKok6S673E4JIOA3cGajQENTEEdfofYwD9q4jNAf4dGxilJKAqimL8vVLx8RkSRmSAd6tUj8F1qfXQ4/GAUpopqCKQ41Njzxh2SoZVyqNESVpUhW+F3axSd4zxwrh4IJRHlhHvx0TCTE7jHOoD/mzyPPAr1JY6BeAUIWY7hT4rfJOnVmPCxjxP2TdE5hVervEnoMn0zvtwqclVmzZtOpKAdf89N/z75645sO8uL5BJXHi+zEDueLTjvoAwEyOuiTAKBgi8PK3/NEl5AhvaSMqg1hTwnRDlAaPB0xq+AFULR7ZaO5cW9j7LeTS7/+7v3Pg3GTPWghsKHDAPi5WW5z5Y5jhGI7OEy+8TCPAW5ThVHwDiENdzPRcf8BvBnmVN1CdBnWaXZvgsx7VdKHF4dNeBykfqra1kC8wq6RKgW0SLJOOUtC0KHCWzo8Cz4XsTR4qxIXNRq+JPhTAi6bPvullGwfUgWbunY5DouJejAQdLKbW9tM6+8Pz779g6MrZ26y2fytn1yQ9orVl3xroN5x1KQ4HTHcFBUsqJKmkaXfelD+HDnbf9q80mD7awWqBLkukVLbyYSJpCDQuiGOSZInWAUjq0X6f4GJxlzK6sNpETvSAiQ4Oyu5gSVRkQ+Oncqo5S/CFWXay9uUuuJUHT5oi9ThT1rv/3D07v3UpZb6QVEY8AAAFliGJoqz2XSLamDS042bI1nbWkIiNimEZWEQpMqigCO0kPvj5PUatSbazbdPLpZ7/klDMueZYPb9t0a4cILGGTGxBXzTPL+MQ4TJTadmhIYvwCSFFkupQDNJ1U5L2zjHZLPwxakU5XAJdlza/5kz4Ohl5s4ChJ0ka17rluyq/W6XfoxKFKbJlw+kDX3MJT0oZ4oG4UXkp4Pr1/e05sNKdkH/qAZyUlNE4SHEFPXuTNCUco1ijpGSywLRy7e/s91VFn947bdu34GYIqNh2gLRuN1fXGuhdc9MbLLv+5p2kopyzhVwrZxeMvXfsHZGPKiPNrFyODUsygGWHoYpSCpIDSG9gylmDMLhArSmEddcNOinFHZQBs0llwGNEQqA8WYQFWWuNp4tRVoTwRdXNiPdArEz1g5/oX/u81X/7CH2Kq/e4H7nAc/1m+zvbdd9yz9XrBGhB7/Qs292qbgEh5jh8o6cTS9YJCiU5/CepQLRixfEc5cv/iPqHInT/hrms26piT+/s74zzEfDv1jBf95M/+3Ypf3XbcWn38iLT/5OTGF1585V23Xx+nA2iFhbFBFfyTogGIW7H5T0D9DoQbeE3Hth3HqVUrCWBCqsWlNtvEKb8vB0oVpLAZ0xIOA+IkaYqlJ7Wzfj8EVOC9FMEN9YjmiE1JiX1iqClr0vprVsNRbpplylK1oGbsWGmaTWwcLULHSQRhqiCaJws8d4tM+KDnGDlKg63imuDc+AnqvZwvTVX6QPMsRisq+UDujqK1sG9paf/Gk84BdwdLfIqGOrEDRxfnp9MsZL6qTfIU6+S8ilpibHzdsx/6FnuaFxf2kuFDDBcEWjfYljy1+mTxfZE+Dk3Q9kjRw6vlbNmJB5SfATRBq5IGlFAFSEYfWlEp5FpSNixGdq+VmYs4y0MtzdlcYgnHdmgOWIL859qCkmDsLpIIhQg7ORcD0OSwbyw5XjeJwdr0sx+Tnu9Prd7Sae9L4ghMEPNfYbXXIrWKSjAyXp/wPDeKE8xYqBgj1RFwrcEg9H0POu1obSylcyzHcTkbBlN3VdWVL3zRq089/UXjE2uei/Y/+7yX4x8+bH/we73u0pMNqaDSOOX0C2f2PvzHv/w6PJvr0hqimdqQuZBS/jBE2bMhBKgToCrnjEFmZAKNH8cppe2hC8C2MtBnVWicSCVAg7q9TEWJo3lV2w0dcuqBvdl2HCdRHLPyJ91iDChWSKxDPvDL87zMCgdpi1Q8xnqotNUROxrQrU3FGNBYIGBnPjEGuNqIQ9FhbFK0uDZWlubfuOHjD2674SUv/aktz7tg85YLn7AFTlR+9ad/9CMLrQdarX2WiKN+jmatNBQXzaCiPFglFqbjiakNGLhYUj3KTsjZ5kKdNTV1+ur1G2f2b1tc2I3WRD/hgph1tVGbyhtSNQw60irIEYN2H3TDPdt3NCZcVuOp1AZH31Gqwdr1p2KQcPye5IgVlYT5medcQR4XYW3afEFjdBwz9OTnXRhUjmS0zhEXIPsPXPW+e7fe8MC9N/eWFow1ur+UGQXEIUuOyCO7WmvSaM7ypXgRA68JcuVQDn2r08qLbMP4JouNU3OdmX7Uw582TW2mmJ1Bd8/cbnMjY/TVnLtrqnrjF9cjKITa5frqiMD/llMu+OM/2zo/uweqrskTNpJE4V9c81Z8GJ3auHfnA0UcZUJ41WoK8AKqxREm8KqRNef+p9fFSXrHdZ8ppHX5D//Gi1/5lsN9gHDQ2fHw96xhwSgdhu0dD98ComF7kpx3YVFt2uTgE6LaqG3Z8uLTzryMvXTWllOf3pBHmitghlhUwV5LAqQXX371A3fetLR4gBGBeBbQioa7Zg1XkcWqPxjQSazK4X9gTZJmQL0iyw8yUxpDHmX24C5AK65vpVzXBUcDvoO1ZWmGDzb5YujuuGBSZGzWpCRpo9smIdnjhuY2Sn5U0BrJbJ+zN1aRRxKrCGdWk6dSUd61NT+383Of+a1Xv/5Xv98AK9WLM/sfyqiOD0X3YnZ1FlIThksW3y7F1y7M7TGunPqYQ/EpLR33KRNq3+5t4jaKWwEkJUkh57CsWMqV83OUI04DYt4KOxkQClA4vZsKnnGQsSZHWJUr+3AqJpBudvYhdAxADT1EyvyihqZzgB6sMLMxJ6MJdCXnnT//Vxe86OpDf8G//eg7t95+rbGqkBVYEnoS35agD7VNm16EMXXZFT+OETA2trFSpdAVHLz1tn/bdv8NxigzzD5LcDotepVgcv2G87acesH6jWc9wThwvCte/XP4l2XDNRCyZ9fdt930L53OIl6n323t3nbHRGUEo7zX74/6Lg5rYJWQGIiYFqpQGusomTMsvW5ifWP9Fs/zF7bfn2d51a+dvekco56EaQjOg4tPbHzexKqTrGUI27DpLCwwFg3uIxMiQLfgCz5q2CTxhS+7CsRq+4N3hVHse5QyYiUppmKjViPdqNBnnnfZeS967d9/+DdUEODFoDa2lw6Qdsao11qc3rPz7vvu/lqWkhXM89Xu7ffP7N+OAYADKNgyIXt5EtK0BnHA23GFFlrMzJJJiS8cg2oK3RkF8C0/9sH9e7e3lnZKDgfxK8HJp1x60SU/ZNtPoB+BZ130n69WeSZJxMTazePrTt56038szE1DDURvkEHddcCwiEYRt1XQu0wcL4EIm+DQj4EvjMOBVEjySlIlBqxVlapNmNKvBNQCZEpXjl0N/P4gpK4m6jzEF4ZFMqApy1bCTgbDsg1ZwjogbpVx+Ct4Vl5wxHzBCTpW1M2HEfxRjqPcAFw+xSwTrJy63pMqRuKr956QgaOf/8z7v/C5P0ITgExhKbCsYZUMYz3Fr4N2hlECTEkZUFiDI+Nxezbhw2g1oEFGlJVK+Zj4QIuSA7LamBP3c6MDGkAEVJGSz/QVLAzfAJ/CfobD0NaVpgIuuMTLdNTNjLmB0jgdAg4MRwyFn/6lj19y6Q8e4tt9+u9/7ds3fjLLIhOSYwYxWavZQ1dQlAC6mQIIHZ9K0Pp1O+NUrOqIQ5HE7Pgm8gLNLsptjkI06t4P/ugfvOr1735mbX7nTV/6/MfeQybhyuhvfOgrg97S//zFVyZJguF6+Zt+/vkvfs0fvOulFveEVwne/HP/T6Va+6vff7tFCqDCEDSk4PKrfualr3/HsR4+1l+87x0P3PEN16GsYug7mL3VamBCsX71f/8HUPvDv/NDi63phf6sX6umRYe5gGVSiEGiLUpGkQGHcaBhAUDAacfEfJDSy2m6jmDGYeF4TVU9lfE54jomNrUo2CJusyFJGFtVwSsfhYzhv//5Z7v94FCJ+V++7x133fo14EiSpIHvN+pVY8MyF5f0OYNaRz+T1GiII416zsZySDudH+SdLMWqYzHlsWr22ER9ikzy2hofH4HKNrewyBoh1k5jbgfyDiMb8NNz3X1z+23pcDMOvYdVgJ1UFBsmhXJcu1pP2SkAxbbeGDdegpM2nzs2sZZHDplZMH+nVp/qedUnfM0ThmFhGUqSULMHhCoBpQnAaNDJCJIwFXONZRNjAgSKUJ97HT+5qjTtwEHlwZKC8kWhOQ9yrgpEg6bfyWpNWsQwRChelxQEBVUIGIflgiqaMa03mSVUdqNKDBmX0pKGpuRELVPasbeYNSbdwVKqjTUx1zGjZ0rZqlIemqkLPf2B333J/PzDaZIYGycWPc2Pp3PQQGFKsvlVm3PxdcHOI0rLkIRroOYWeb4sU4dkWBpJDPNO8b633PRZDLUXX/Yj1dro4XbBhpPPecOPv8cifWfwmb/4bbROFHG8OK3PutacGF936vz+7RbV/8bD6w2nnKeVl6LXMug+6nnnvcQPqpNrtxzrocTvsuWsPdtuoSknFbQbzHDboeltakTd/q1/S+NuhhGXxXk/ATCxzZLLQpHyIswqYnJTzBIiyZcmuI6K1EAJKbhiFKXsUvAaR35gVGCsBjVKDKAoVioOw6ZolwgXrXlcLgaEhzRHLI1xn8k11LHgad+IkZI0QaI7aZKFMmePIU4umAKZsgesodJkwSMBuRyHAu2wlLz1p/7X2Re9wlzq/nu+mcT9bbd/a/vWb6NNfM/r9QeSWJvLk8+CdomW6He7MRFFMqWpah2N8IILX3XvHd+goa5oVJCJjfikDKCcar3ljAt/9Ff+/Fl23AkDWODhf/h7lxl2Q5uaKeFWFNAK/ALr3vi6YGE6nN0VUpJXncwRFGgiZLVJ5Qqh32Gg1EadXiutjbo0t2n2ysX98ciUi5FEmeWaIk1wIgYTpZIQ7FCta6rKCjBqpehzO6BkhMXFxGTMu1z41atQMcbFAzG6iUo7AtFyC8+AUyg62aJxDBjdetsXFxf24vlHxsde9sqfeLLX3L/vvv3T99EnSSQ7S4nDm5pHlokYorWddIpMWAxelA1rnPGOicYrTMCONuYDQ69IQ2SyvfPh27Zvu+3U0y95BoA1OrkO//ChNTf9r3/3fn4SWl0LQfdiwy0PaFJDKPBQ4XfPjeMBvhyE4Svf/Eur1h0XaAUZGV/FKYGZIlYEJU6mpME5gJrFmd07tt++NJgPrS5WOyqVyQueZt8ZUSdP1ho2PofAIEW5Muig5SAPAhqcohwKVUWn+BVgEBEu7gsaTqQKORSrilNMIFI0yDk2DboCxdyypZoWm9/5lTNw8AsuvvIdP/N/DqV31m44FZp7u72QS9XP8lqlAiymbbUce9Dr4/Hr9Zr5BoNq34E5NnUR/qLvDuy8R1kFVGOQTar3gLljexQqpSTaJ4szybkLQeAnBHN2kmYJjznHImN/bXT12OqT2q15ygrg1Rk/JldtPOO8S8l9HFQwUCdWb3z2HXfCABbTHwKCfisdWeVhEMRhDhIESHIDuTAdEV2vkBUwT/L+gHcTcoQpyUpsi0tH18cxlCzet4Pq3leb9jBlXGu/JkGsTFhjc9Jtz8ajfBeA19Jsgm+gRYLQpTwufcqDLzwxDIzscw4XTuR0drJngf5Qzpdxq2laQr9z46dvsj6NBWnVmi1PAVg+NJDK2tl9u4zFpGBnnC+Dhh+IxImTvEjTTtwytM8FZlaCtIPlviDDkMC7kwHFk5VmpRknSTdqZ3kqxLD+5IaTLgr80c2nnD82seHQW97i+gF4c01ZhK12a3+nNWd0CqOoYs4maWgyPCiUgbjeMCopzUjjMK6lYz2CHiXnXvzKqdUnfexPfi4DHcoK8mRaImRH4T988Ge3zzwUZT2MGcANvWNMpU54+SFi5UP3TygAXVIMP+chmegAyzIVYLAsmSRKfJtwqDqGBxUv1lg7c4CgxVZzwgWbyRrnElBYpkeOI9sxEGmIG+f9HYK8+V3vxc+brvvs33/419mMBVVXObYNGpVmWZRlFd8H0HAfFVlWZGlaqxJxI8Au9J3f+eK226/v9vqERxQDka1fu2p8dKTV7hi9EkehcXCFKAKvKihAtNDVWsUEhk3vfmj3jgc0raoWWtPzwAD0+Ze98fI3vvPIdtwJA1gm5BqgVRuhQGr0IvgCOWIlFBBNNMehyoRkhaRIG3DsIo5II3OpVFCKmUwF+T1KarVMtUMOZgPbZ29rCtXbpb09KGYHy6THBYYMVaGUukybgmSVptNbSonBudK4FKnbCPjItQ9KD5CiurRsvKeB65KaCbAzahqFWeZPNf7GJ076ww/dffA34aD9jx/6xbk92/r9EHwGI+HN73xPUG/qzHpo67d23n1Tp9sH+Xvzr7zfcfzVa08bn9xw7cd/77ZvXivz6F3v+duzLnj5wVc7OAhjxbhOGrXOlxPozdR7xLOG70FQ0zSChtJemimK1K/W3viO3xoste7betP9W7+tbPWlf/p/r/vsn+EczA6HTWif+OC7MQ2q9dFXXPUzqzacgjkxMr76WA+iR6Q+MoF/UFgw8aDymPhuITW6p0itian1YTowVlE0R+ASw8rj9qCz5Gg5gBru+EHg2Vq0ZpcqXqXuUJ25pcVerBObUostx5Gu7ToF9EZFph7bHnNUf9DBepgsUsAaOfpJMfN1YYLryTcHNDzjrIvrzTFjrBQUli43bDrn0N+LItfJu515LvkTiOpamDUKSAOs4dQZECjFlnK5EiAqeUlhjZh+BcDhG8/zkrSnyc8ISsiF2/Pcs0i5w+kFB4ml4YBN5gGnEtH0JMwSVn10EnepVBtHvONOGMCyaJ3XXEvMzmLiHdEga4x78SBLwhz4Qu7VzBLopoK9MBll7VIoozXclQjEJx7QygMcIRch57tSvoVDiyiOoSR1Nktx4qvNG36QrXr42TKWb1pFmdWTzTvu5wEnzZnEBdYQQb4yUl3JcjEMCjfh1OjRPNL2xNMYsx4T2FWpjrzoird0WzNf+cyHsHLaUu65796rfvI9S/P7d971PShkgOb66tqdW79g0fUzKyqW9u/Nw7Ax3rzp239/34NfsWXg+gHo+0te/rZ6YznQUbPFg9Xg1uJ0GHbIXgaVF3OUHNb28sMoP6jX6hNeUKsUoyMja6HidlqzkxMnN8dWDaL4gTu/QxZoqcxIxXqRkvPb4ToAutOa33DqeSefceSTBI+I/ML7P/Wtr/zjrV/7DF740it/4htf+Hg18DeeduHV7/7fjz+4211YWjiAD/t2bfvUh3+z6dfQOq+48he+fu3HAt9DR1z9pv+eJsm3v/iJaiXA3O71+s3RervT8zzSlClPOFc5OaQ1GrlWqwALrnz7b7/wpf/lCL6RNsSNVHVeJDWZrwrO2zZBCYTKFPyZsl9Q8+LE/kq2oqPnEwp8JxtckiaEdzSqwSgz0hKJSmdoqyRJCraxkv/bccCjcUGO87KMH+Nnr/nk+KrDY/GHKMcpYPV6i5//7DU5EWNFQbmC0iguf/W7MDlbC9OUHyLUyNiakzafL9kpiLa7+47rstPSFRvzo3rxFGvvg1vD7qLIrZzjUPJ5StTwhYjCsNvBzFVnX3i551ejfnv/Q3dxpKPodHtkg5cyb+U+J84TAMXFRIUmdBQn8SAGfEw1Tptcu4nWG3lwZZ9hESiLXdd4vk2nntdsrsYfgqB6uK1x1oVkDb35y38TxxQfuPfhu6Z33KsIaHVOcQS6sWpsaXEaPCjvZtkSlT3TrldZNQ7leHZ/WKlVvagJSnDzNz99xWt/5uArSy5cUqtPApLiqM/u8CBNIsf1OcVDcMLHMFOWUQkQT39FIybRAH8Pqk3eTbNI4j7NgSQaliwpMlp7wVrVcTrGIKs3nFJtjHHsJTkNyHwOXtAce8KD6/XxOse161wH1YZfqaHFqrURy6xkRVGvjyVxxCFOhbE25ly5An1kjNzGC2Y7nh/U0B1srn6U/x7f9Lut5ZIRJkxfm0gra+WzKS4mV3J0HjXkTj3n4je98z3DbSqE+OxHfx/XhIpXqfiVgBRAYBaYXbvTrVYqBcWaktsBh599yauXFhfuvfVr5GQMfDzzgQPzYFI4y8Re4efr3vqbp57/8j/+5de35vaZhB7iaPR29MTkGVfQRfKgUl2xCRxxOU7DGr547R+FgwE3pbDJfinYNtmrN0c8v6FsSSimnI2bz9205fxDueAn/tfPP3D71w1aGXJrsZrpujbH2enf/NCXJ9actOehOz/+ATIwAQf6g9DicYAV0la2yep0cYIiiylWTsOcX/PDv/TKq991FNpk3457ZvY+9K1r/3Rxqbdq7UZLqNkDe5Oo1+32N5x8dsV3+p1FPFoaR9XRdZhRQX3klDMvXlrYf+6LX/cU1u5hZjOIZ9jP0gRgBOJlOy6oGz4/3vaEY/I0CQc93MLxPDM077v9G3/+ez+m2ShLHkklTRmQ8/7TlT/4rvcfhcZ5xvKlz/zZVz79p/Va9eyLXnHxFT9MHsNqc3TqkNjB773r5a6IAAAbTnnBrp0Pz+/fAT0Rr49GwDhrLXWotpRLWiVwC8NpbLSJ9rzgZVe/9i2/vnKRxfm9H/ng27gnKMPloQduXYYqiwwdNpsjopwNGlKbAB4uy2WCMPKUwlnMpfyKbXGmJ47HY5CxbH7M+EZGm01wuoxyFEjrGwwGpiYMG99oFe84e1UauGmTIJXiPMhy1qiBLAac6EPyAz9+zTmXvHbv9nta8/s/+oF3kZmMlF0y8/UH5Ea85PI34V9zfPX46ueEXlnHLcN6zRt+/THfhP3Otq3fHF990votZz2DCxoCbFK90zQbBrzxUqYNERpW0aAjgU0AJsGfTRQLeppSEHyPIK/IXYAo6DFFGhRHLTVn7eazyEBH2laxOLuHynrEiYkCBOEaHxvBkKJVFMPIq3rVEfzfWjiwbvPZT+2b40UbFAk6rJ/zRk6OFwD1/GrtCY8nVyCYVRxBzXzk3ZkEmHpReZ5hSS/YGH+IwRzHXKjuTdjdeOohFQx49InEKeqjE97MzPArTdHhEa+Lyx6JlILCOcyIgjnFo9aAOB48vO27ph84W3MYjmR0MY6nI8ev2cjLnIohaHMWnqJgHZNrzqVgmNaA0Sd6GEuFHsjTzPUcxesHVDnPcbkKBSDPbFdDVixDu5SWOjE9SLjmBz4hFwW2c/qH6/ImYBYmYLU+aiygZj0zvYzhN4ahdtaFh9F8hy9HFbBAob/1jb+jPs0tw5BNkqdp7pXc2mI5gd6cZbax5kgiOb9tz0MPf4cjX8hMWKuNvfDiQ6xXOawihM4YVvnRJurX4jgUvTC7Fy2+OLvPeGTNRBtmVhDfLzhALjUdD/ziEPTiaLYeZPVJZ2w448WD730Vq3dA40lhMDXqNeAnSP7mk9ZjGRfe6IZTzmkvztVGJ8684PL1m884pEtzm5IPX4LPZm5QeYpjAZomgmFFRifWvuzKH0ObPHz3TaCBGONnX3A5ltkNz2h1OcqCpQvr0AUvO9Sw3hV56y/8CVDku1/753u+9w3HFiPNOtofYM3mQRozvu9haLmOEzj26kblsrf+DhTPxtgqc/rM/oc/+de/CIZlUdwJ27ATbZwzfk2ZcBaK4LHJ/JqnOsk4kJBDxlOu50d7wacU12JqkJkpY0IrqMBDmJNJnwI3CuCOrz3SJ9nOSI4UHtL8O+kTwqHgLZ/qAuYOl53J0gzqoe8PAU4s59lYy7W5WM+lTET86W0//8fN8TWTa45A4MJTy9EDrF5v8YF7v/a5T/82ZXJk1kqRHZP0AFSi/H40QErBUBznSTGTtLl2gJ6wOE9daRNO5DtgNpZW9ebkvr33X3nVrz4tzbnqJ96DpYwT0/VDd9987d+933ATZdMIiNP0w+95m8WeYKwknOVPfQlKjD7q98MoiiiPNM9BYRwucEHxRxykd+rZFx+1NoRMrNkSnXZB9/ZvmRpseCSbXoGA1SzpI+Or52emN532/AsufUOldqhuGmHClgFDpEHYTxuF8JgGX73+5De943/gw//50K/O7H0YA/38l77x3IsuP5ot84yFxlWhJ9acdLgnnnzGBfh5/9Zv9TrzI80GDQxhVSo+xQ0weECjikFqiJuo2Pa2nHFRfXRq5fQo6t5759eG7UllyHj9ppVbmirMJscen8Hn4z6FMQc8Iygh2aWdk40dC5hVG7WzjDw/JkzPBEuDLvWtxYoexfP0en38qcLJOFxsL5ibb0GBlRxxAgVWtEcchjNojlAvJPMsx3Uvv/rdrGfQQ6466fTh01p8FhFq/mnpzWe88OgE2R09wOq2Zx647+uXvORHV1Tu2X3bd267Hc29bvOZm08/2+QVm0j2HffdMn9g1/otz1+1fksSLW278yaoaSOja8dXrdl+391XvOKnN245i4IlyXNxSOa9xtgjA6U1u8eYFcgapTWTXkJEinlTyve8KI4xgjHycl4nTfoCDsPIDio+rTyk4RPgYlC53tNHIR9BufgVb8G/2d+5amF2GlAVxXpxqbNh3epaNQhGN73zfR/GGLr2k39Sb04cOlqtiFI2j/hnbjE1NuATq4IFa6/iGZtyoSKd/5IfEEWy9aav8BJCVoKxihcNoBcWy9m/DhaSg9EKsnHTuR/9h0WL/I/z133xr9qtGabsWjqyNb9j90O3VysuIOysC6644zv/7kowotjKZK0+GoVLCWVr2FjUKZnYUnnMicRxYXtQ21SRamCOTkVlslkskG6I6SPY4h7HieNQiRiyVSmqc0aBC1iqhUOmEiurVqTvUUkZGwxBqosu/6HHv7LrV/xKI6R68rnkRJyj1llHD7DWrDvjR97+oYO/2bv9nvvvuHF6x339bmssOGXTaS844/xLzZ/++a+uuXnfP59+ymWv+q//7auf/dMZe1eYxfWs9ryNL3nDVddMrdvybIofsH7HuQPs3BEmAoemK3HflMHLZv8up26Qlz9jc6Wm5N6clUphlibS6o/F5JxcdyoAy3ijFLultLQn124xmtq6Tac/98ajJ7m+NqV1TyTAksYG9ExPP/fiV+Lf/l0P3HTDtaMjzTRNq9UKKMyWRnN+oVWvNTB+1m466wd//sOPOREjyPTX6NjaN73lmoP/9K0v/+P0ndvHxkcxxK5+8/vuvv6boG+TDTIavvuaz7/vZy8HNXISsqGEMvKwaHIpBc9NLC28jC1WmT7t4ktf96O/dc07LzWQ5LoOZSDzuFVsX2RfYsG8iuIWLR72VLwBi3SWS6MGPpFU6yNjk2umd7Y1D0EO1TpKvrtjaXTH0oR/O+7/3nWf+8v/+L8fmVq75bZvfuGlr33bhpPP2rfrfmjsi7PTn/noNQ/c8Y3Lrvyxr//bJ4LxdWdd/Or1W858lvddvfG0//KO30MT33Prdffcer3J1TQmLnCtTqeHbjT5B4I9MmZpomIEGB9hzEmIzrkveg0gTFKYwtA4XVDwcGiZ2LtlGbRnBu3FysiqSuPRzvLH9K8YVosc/iKMwirNZ4ONw5K9LFe/6w/f+1MXFeyxDnwPy6Yd1K58228cfMVj0qdmiOdD2+SJIc+SYS2/uHS9iuNS5ori5CRp8qgkBTEdbndc9PKrTjn74o+854c8x/rGtR8Jggr7OsiffeCur3NtVHNxUbMFEblh/ASl75nQ+02nnj82ueHuW64zJWjIyR4nddvmiqDsYcwyaXaxob0oTLoyKSwm0p0yGZR6ih0fDKviMkHksD9qS9Sx9xJuPv2F//Wn3/v1L/zt1z7/11imzr34FQCsscl1+3Y/uGPb1m57ERr1jgfvesdvfCSoNY+Ingxyfv5LXm+xHf6u715nbOqmeJCJeOAFhvqeg0vJmgP10CInS9rr97lMgvX2X/6gRZasOBwstBa3Z0m4uPfuKO6I4WIDTZNKcNjaiuPcOeDglzwFiYMG6YKqeY5DBTipMpotybsjScFlY6cyhWmYw3EMFLkG8dN1KsqUjKBSkfZZF75q0G+DooZRdulr3hrUjkzpy2cpphiTes7CcJ6lpHGYpWFOhQcLizOL4qht8i57nX2OLx5ZNCyxslcD5yERIfK8Bg0JabvuY4PpVm849b1/8118+PP/8YNRd8aTLkaLCRl96RveufnMFx3Wczqu1++0BoN+ZXxs2+1ff9XVP3nZG//b3/zJu+++5auf/PgHHD9IuOICgZTjFpSxVZgNbKIortXwbNq15aYzX/SxD7yzWqu4jtMYW3P1T/3+tZ/4473b76ZhKcWakYape6WU108ypeiNCq5LtXbLuWtOOsPiCP0ne8IVKycapjk6Nfrc1DV8vBxjwDKTuzE69bq3/PfRyXVAjP/47J/928feizElKB28BXad5foH3vZrU2s3meMH/VYc9yxTaYxxPUujNO2bC3KyPdhvDcud59VsEwBpWZ3WniyPeWgaZwfBQa89Q+Uu2S1iIrOMixD8gLix4yQpFZ+VSpmkOYoqUFRqFqvSbbf+Tbe7L4lCbVGmDnW8FFmUe7yJHec4FMqiGo9Zpr0YSxYF1EjtKM8VGmuXH/i+5Fx2zTRdsefbSlJOE7SSLLdcg3jStb0iF06tITkqn8rkKHXOS/7z3B5A+jcHcXTKOReOTa5vz++ivCQJ5k8p/3meHEIHoMXSdmvXAPPW0p0996VFmIuUrLBUyUnWR0+qTQxTamxwCKdeH12Pu1CpmywRjyKGREctNsSafLVDeoCDBE/SXdxLT16kHGuiV7KFuKy4p5S/HMjKUawrWzJQ4JKinY65miAk7i1mWcTPQPuUcVhLziF4WZYmRRpnuAWWlDzpt6YJj6SY233HYGkn55YYTovGd00UMhWBYnbDUeHa8aqV8XVP9hZ5Hit+NspfKahmqePZY4cf9r3h5LOv+slrTOB4r7P4r5/4wIE9D2ApFQKDIedRLThzU5ocTqHsWnOiNX9AsfO7022zI5ti2bHENRojYAZY8jkNSye6UE7VURRvhWGXWVAUvDhJFMdknXTGRZe+9seeprOW7VYUnOj5R82Se1QBKwxbaRLedes/79t1Z68b014drfmFhfswpTHbgSfkYu2KMKP1WXnADHHJVS/vdWe//o33SiYccRzG0cC0l6Zeo1US8yqP9Kmbz69WRqVvEw1h05Oq+sod1j8rwkjmmqLCwacpnILqnywsbhMOtCouosbprBS6UhQeYEQXWMSM643qK/oeVxfKWNkhI+bNN/+5ndiOolqm2mj7mGWxWnXyKaTApUUWpq6NIWthWqe+g3e0bSfPrEo1iIuiGnhL7aLikf+IBiGVOqCKEWTCZFblkF9aZspRropSspTFrRalW1A0BnF1zKcommdVVi8sPBzrxZVFD0jaH6h77hyYKW24GjsoHsvbO9P3h+FSKjITrY1mxZNbyziACd7u7Lb24tVoMaa0HVWtrztNOdSqw5CQR+sC7c5eE0EyvfcWrxEe/CdH+L5TlVQUWfBAz1kdSdIcfCcfglPBtU64hNhBarPgKiVKD7PuFGcNu0py9ZJhBc6MUnppTBTL51CxZb6RpTjkPNNYBTXlCmIcZHmapVTZKY2HRex6XepvWZgneQQNhzRbrDxKolVvbo+2l/MPrYO2Mrb0+LpVs7vCXn9gU04MJU7dd/1nosHi6uedflBj0Lm2dHy71hg/yXYroDmPaUmQrBddMYy0+PaX//6mr35qYmzE93wMQvS957rojqWlDp4Tizov5KHtJONjI4CtbrsFBeXzH/31VVPjL339Oy959dvNddgAi3FONIrKVJEuKFNOPDShoTZTqkMhyKwBCHY9qeJoGbCo0R5vLduz53ZwloO/abX2zszc//iTuT6GyHl/WlPhRDnDObNn9239/sJjju/1ZpK4T4X1uIYUxS6k2mydIrlmD2aMM0XZIvggFCXg3Pj1j8fDzThpZHKgCvHzqJdzsprFpaBo+RvdUG2HjhVaTyYUTGEee/FAEnWLIu32kuedH3Q7sZOoh7ZFJrzE8SjODj032+lTTpBSw4JkFONHmwG4jrt6wrVnkvZ8a6Ie9HqRqCjpiSTJhRL92fZw5NLD4ZTElF6huBVLDsIIl0NLVQKfTf60TW6l7lOAslyuUSsdcENzEd/3lodamiTEK/Mwl54sMMdD8APfJOU/vPM6e59TrBSWYZCabVNOpdkb5slMDAJ6aVrYHEoCrRSzWahh8jNVxxeWHdF2fVRBtyIFFW+S8zt24YOBPoZXKinhujYVwBVqsHjATIPO9AMzVo82BCZ9VutUeJNTqhIMYx+H7AmgCIYKGM50YUJwiTgAXlagVWY8GpyhWZzJD72Strk+rwmy1Mv1dPJCDjcbpibQylpW7Cx8X6R4RM1VgwkNKSIk1UnUp1s7dph1RFZQbjB3N5pFmhA8oVPa0MHURacbSYvnM9MtKgWrMWW5EqRLe76fvHb9/K493V7fpMLg5ntmDyzd+K/Pj/ZxarISHu/4DrUMXd1sTs9u5diF4PF9hHfzpM/7JS6df8mlM/d8D6stBYXyE5522gvvu+eOXreNXwdUQSHHaPE9b3L1hqV2O0kSSmnkahkHz/FhAWVN8b1D27sQxmJrQiMNPXwKI3rUby/NPZQmfd6jkBs0i/ftvNmUoAChVcudh350/WqlOlGrr+aF6kgA1l//+Y/Pzz+0f+92KjIdU6gz1ckjK47mCpy0Z6TZ9wnIggcKasrsj0I1oaoUaQjYwq+U104vQ9sKDDUFqlJG5bpxBVw55n0fTd0CYJDjy6GtRlDIVQ5q6mRU9G6hAGe3HSokxNtzF2GPrm9q0VnWcCMmnsNUykdxVU886v59d5oqJurROy4d1PgUZWc2xSt4a1yR6vYc6ZKhR2s9g4UEmUryIiI9kSu6Ebd3eMsVuo7rulAzZqPu/HyIxWr3Esf1FUoPOM8r0+AjbMjkfesocUUMK7Es77JrYla7XItwGJ26SN/TVnQ8l6mSbFTwznRWUHgXbt5Y2LRjntVPfa0W+oP6qB9RjSWdEJhSC7Zb23SSV10n7CWeb1tUTEJF3dQtgIxeP0qV7+B2rsOVUV0HLVyhTcapXWKqb+yEolCBDZaChdtgScb1vLMhXGq7Jzn/m/bAy/CTgw8LDiZMRZH6quBac1kRm2S6VjqrkozgJDYvaekDDzJ75M21mLXQKsWFBdFpktDeZmvdsHKBqZm33IXDHFGqYEDl4Wh2kRsEEw8qeE5RKkMENGGNiqORwXGUMIqqxR4VWwtFdep1jPYCKcuhIHbMrg1hd07kPQoKNJdiczKIMrUTVanmMpvOsGJ1lg4xmzpOkeoJhpT2cptKjGrZiOy25D0gbN6YC32fHYh3mlhlnbAfpeB1YVYzRzQlR6lpbH41SamDPIekghrujU5tOOPk+2+/xQ0Ch/etSdJ0x923yCzDLbr9viQTpwPW1A/D6YfvWhtYxcjE6vPOxkP28p3fvXlYNu+cy87cvu3WXqvtulavH+JcStvmkPdTL3q+JI6vHdcVjdZ3b/7IwZOoWl21Yt6DkhR1ZtOUNn8xNi983r39mxabwCi1kAPiBWUIZRRkIeXU8y5Vw+1gdK263raHGZQc++cdHmDdc++11I4OuABFmWM82B7F45iarcZOxAV/hQ0NB23iDtcsj0oF6e5CyrXNLMm7BFMN9Qi4QNCGRdsUPKByZdCWBlxCiDe2IUebO1z2JaOSTdvb0cqX837ieTbcooZr2lsmhJeigTVVtsIHnOX6kqpHY8IJgob779iFcxuj1Y2nrsoiaIkYlYVIOC4m1pJDTyUxGk6NABYHAv/EON2DMs9FQsYsaYJKNAfOaWO34p+kD6KDwzAmc5Vlu1WV53z3XA/aqanVbd4lCankKRV+oxoP2uyIZy2bcBl5aWdwU7PYrZArMOzQGxJMVykKFMvDEN0qWXdUD/dG90WUZf6qoL2QaDRFrKuOu8g+yca8aDuFIK1TAt00KZdFXrUSqTMrKVwMKwI3vGUuCihShdR9NuvjCR1bdZg7UGZlLAeZSVcTGP8Jwyvtluqo2AAuwCLFWJSA+CwsAmknWRF4boFupaAQiWXNrOFifgnankelKoYgUjjaBmJIK/Ul8R2cgothKXKMM5Tg7xADepb3LeYmTSzTVstKKucJpcZboofJCo+c8Ej6ApMvq1d0zCCcLw64aCl0TW5wkukVWmA5GYPKgGTDSVukhZeZA6gIXgh23e9nfmF5xBO9uq5vKnbc0oYSh4On1jr1RpzumVaOlw3rITONFWJhfm4QdlOn8KueS1tg5bbwHc8mrjDMKBa2X7H6EnNK1nKAnUqp5HA/yztmIxwoK0lar9eCgBI/5+cXi3rVkhVfWYlNtSXmlvbPLdGCVy2qvggcjh9k40bBSc5c2Upbk9UqFuYhsk/vjdnPq8kDSMx/IB5a6UeziFAGI4cHUax7mvZ3PURpQLZmvacY9hCDPn52btpBVR6FtWKXNP85dtXzxkyxgsmTrhhZ9fynB6z2bGKIAKk/tMu1TAeYiXppJnEDUwqBLNmm1Odw/0gutxh1odsNqQu+DGo2VSlbysJ+ZvO+dcRHfFooQBaSmCvA8MBMU6rnCxJBs9qh/ax9ziowNVjYKWMFdSrmSdtbg0PZVNUTqwfVxuax5hI7k4NOVmRs3M6pbDYjms6XcnF/jMkrA2nRTNBOwxV1zGk1XCGUWFkbzcMnCdlhTeAJ4CYVVEbSJLKPsXrYTkD66FWFm6dWWKgUN4oW0izWJnnC8CaMQbSY2UmU0XY5/8ei/fiojiBX+KfGoVxuQnPSoM3MElzrAVpXQvsJoxck19jN0vzO7+1YU2msmxzDbWJNO4AnDqiXEmtk1IOGRla8Xh3TX7bDeMz2OgeiZtOn6jphHlh24WOeWW7B7mchoepD/4xt0CfeXqmAzjVMpcRqRbBlWxk4hYOpUQwZqmetfKYfwTB4RwdWJKgw68AKyTNO+2xaicq4NWTHH9g+MxZygZJGRjTT4Q5MGcETWpFFImQMUOCMTWPW5pVSMN0YNqweQo+TqGEPav4ThgzgtlC0GZ6lk8A2RQx4CBGBI8PCIwFWhEMy105ixf6KSUrrxS4XYCncXYu+I9tR7GHkKN4LXhXatQZQgLnYv2CDJm/KapHF01tOBgAE55kVaDuwV9S6grPP2OZtRX5SBGawdR8z/YA2Tt9yIivwirGa3+rlvaQtXFWv+Vh7sBiESdpRC/W6C264cVzMzmZLXW2zR8AobjzMJCW6upQj06jXquOyNpI5RR7P7jYb5LiRcK1Kfyxs+yrMoDzQ2HaYkqRZxnVD7Xt3XC5UxVouFLGsgdOMfcREd5BmGSe3KdUzGaNpXrtv/2uUnFn5KwMbFKzcC9SyVwZDLX9ErTg48I0+RWr/5yYmdztu0KxvLvIm/yG2nQfU8p7aSgWjI+fSzjFo1147qzRp4x5gRBoW0SDH3CMtZCmjSaio0jlwARMbwMQjwiIdPOGdfrlWr+BCsabsFHgHHc/FNs0G316gzJZ2oG+AJ8WcCxTDkBHctDOXVkbQEaLasHG7Xis1eBI07MYEVQFtz6VUVC/MCW2oZFVm6uqhzwkWOUq7WldTJ42KkUCyHd2EHYOJgCDgsChMrcgSZHBRYNat+VCGzMuxqIbUFzkX9jXFNPAr2LLwsCQCUpck21azopt5XdpjsmI0l2Hml8klwjemzDwagdDZlAHhSSi4GFvOlY5TDsqh8vAV4iRUuDEnhlip232uaBr3Ca/xJLgUOhYccY9uj5w1RkaaEI9VZIu57hbjkd/tsv8KrKdPVXdzpWOgie90q2YUuL3l8ePkdg9QQrgjIusR9KFNRsVw43hSB7SkLfxM6wntp1Tby/EUZ+3mQaI4MM2Kksx3bNA9TFEMQhWLOMuNLX02tozJz27V7bzB6CNykFeLCtXZlqQCeS7U2Y1aV6keWZzTuM9rQnaFiPLi5NinUACiYMZSJDOvsr3IcHBPVIYTiBLQ0ZhA+2ykKCZd7w7wyby/WuuGtHtusI9hRVu8+7xpA0ftt71HGTjBkqDfhiqBEgPuPDcChIVyW/RID5BZL1NYFeh0aYYihbq0M7fpYMpjfVDFI3GVTvWJDDRDBYJMg0/GF+SUY02RBwN6yQI0k1GptC8GOgVvYCOClSonF5WUiKrIZBRlzP/J9mQMT2RUde0oinzPI9e250DzGQHgYsCi+z3SNNpeNgPldr6Zpc00eRhLGbTlwjBhy2wVpA8cMD6Zg8o2ioOTB6lRVmKksfwC6KhsDgdqYd4cmKlD29Ncw0+qJWm3/MoeXDaW9ztmR2rZUs4c2tBxn9iYFUV5f/qrKyHZT8qwWEMRZgtSKvsLUKCuoNmFbvNryiSORz2CMOAOVzrSZvMFSTvW5JWmY9fobYdV6/LlDEyPzhK0xxTRJZv3F6G8zaQgU5eiY8C2aNMRW7AFraB6e5TZRHVmqeqeSxsRU/4BVRESw/1jKc+AeIrKwaKIPK/dNEourEIUUSEWrWIhWlWv7Z8fGLyQmahXyQ5YsBOOopoAwVr4NceqW6Ku0iTpLgx0iwCLWPHyZt+u6+YckgeaBTIpcUNBz2ZTnT9e8APe2cmVZk8twv2lLCfeRDlGQ4bFl0rDnDHabJdCyiBZkYBKkngWTqctEUOq5mwyK41yrbnA0KgbUPn4XaRch7qoB26SWNKz+yNWCoRvgVpYLVk0JsHWZErr/dCERz7RXEsfaqFuF7GXqzhM3cDW7RxsKvAdGv1Z0ZQe0ROLKIPKLEwI0MtYF4m9cSAC6MVJj3aoD+VmIaiEE/0NwFfoODvN6ikDjYS/wcO4Zze7ybL24OnnogviJohASn9eHqJ+7UFTiEBae803LhW97wOPlN2XKras7U9dLcyE5T5JBPb2Jzie7G2PKrIKsDReC8HJ9sIVRKjJf8xp7dP4gxbQLapUquVR+JNbo/Oq2nM6cdHKQm8EEKHiKC1q0mk4RZwBFCXGi5JRO87ZyWms41kKziqZZdO1HzMbUwAmeThpwBhGZlXAxEKTcqwCmsEHVGreoTZh+YS6qdMT7T0ij021GNr4hyxKFpWTLJqazAgHPzmnJzruHBTEAyLi6vu20TJs3naQJqz/ELngDspSkPac6y9kyWgaDzOK/MqDtqNNkHVvpm3SCUljsQf1yY84/qLiVxMALEW6jzFmYalb2YzyydCKbjeXZQuY2DpHY/mSCpADbR2qsLLi+yLAIgcf71BkcUmKzBi8l3ffo808CNNFdYRstLQ/YkQwEHYoO7zo581JL+xlaajz3CRwFsAvs5te2M1oa3JFBTxp0HLGOZtCqUo/V+mkeU7bAlkiGQg3IFc+9CxMqqxvVR2PCC30sNhqQt+sOzgFB4xXK1EI3ueMVoP5dt+x5aiuzHf7eSAwYmgRr6muU6jAo3hMLlVsiLgSvsXBx1DjMiJMvEOkK+ce7izN94QP9R6dVBTgEayIFLTxnGNyBtkhAgUwdwJl24LtdMQNvZpKBgWQ2jJoOLSYyCJlG1aam53XAPSm2r/Z3In2XgVlyyS7L3C0aoAVQgXu5w3fF1XyNijbqm72sJDnVWKBAzPysHhZhdQuW6HZtcaqVh7lUGSzfq4y6taGdlpLYU05GfAocKIcPEarwE9AkjIRRVUh14cD2SdLjzWTnUH9lehigDc+BZ0sLWNMjbB8Kn+3rUJOc0UDSi0jb3InWV/UYKxy/cHrMU6iAtPdQU7PKpqrrm+uOlR7qlLxk8ITO4hXcOcJoco4NNI9kZpyJWtqj6QbKNZOaN90K8c4xODnA6T3CGpkee46jpmn9oijZ8CkC8B7UrHsUcepO0MnkiuizRQEAI7s9l0nxHrn4sGLXl5bRM94YtnNOd+JhbG6UqCACmZl0NWVht3ppJkoxsZqiQTPJ4115kBv9ZpGInLafwAomlHyYRoCvZgAymHpGMwR6B0W+zugH9OfnEK6oAiFqYZMaczkw8jSWj+MilrHI4pgK6OnA/psv0NPRlF6loypHintXu/YeBnNASbN0b+i6nPA6rq33KV6xdBOhmDiErQyGavuvDPArB/a18XArz9gytQs451Y4bZqKU95rKomSAsbkZ/IZy1HyS6sQ3B+aBK51SIzLJVIUHniEUdNA8sBQgCJgD5kpQpzNzUAaQVV263IpQPkkgcXAH7Fg4w3N6ZN7qAnkrU4UKBFcUiVhYFNhEG8YwK/EteK1lxan37SA0Gbo1LWNlua2Dxcq/trqI6G2wsDp+n2eoOcg4Cw+lVch7L5ssT2reaYPbLOxlwJ45RsbcC1NC8qcoHewo+zYl8W2+s9jsiisHIs2lCO1Igdt5JikQyKdSCkZy+2wnoFZM9anAlXNapRnA3CdGyi3kpkB+tGnapTJ9B5RUVyiHmE0UUbrimzISX1k4pd3i/T4vxtDCGigTbZ0R1XVSyMbSfW0JaCPJZFkm/aYPUikVlmx9Z0MIh83wVfy0XRiQc1uzrcbUkna0+qPqYXaRICvtEz/bQCVhVBNbPDuaiqXKzHHuuwvXYiJEXGul1RPQC9TMReYRdjB0Qt85y2c2rWS6dTkaRrdFIv+qOWrsqhy2tYzNv12tLu2u68O9KiqVscqDYfMtUybXdBqvQQEedgg4TWlj5SgTnLmzYfzJIei2jW0LbibPDzTkq2OY4ku/CsV3z7ji9xWhwHMmQ6xQpKZfCUKWFkHnLQ07YMiB23YukxuZ60BHo+4kiWXmJD22UVgba2ckVKCqsSDRVBi7E4ciu3Ywojy4abGgFVJpxiMbfmNNmktc6q4HRQbQV0NivNoAHXcq5OlYnKkuQMdUNt7ChJyV9V8FBnl6TF4Q/gDL5Lj43lmayO4PF4qtxq21krHZZSwEyrYinenodx3FjtgR7WQCQd4YCFOERlaWdr2iglK/QwTp02izdGLtdp7M0UG90yriAP3sdp2FgqqFxE3kqrWL1HnNb+PhCv0fQFExSTA0ArAtb6ugrbieSgBtJZV5gaVHbopk87gioK1FKMHNS5FHBDfeT1CivKsUKI2LKBVmZ7ZLZki0E3G5lygT79FhmJwJ7MXn6MNbTn9aBDm/qBs/F2WMS5iECRd0yv5FVScCNxXx33i4D25JNRLxtpVprrqPBdfbRC6qcuxiUV0M1yK9xmqlURH84ojFJEcbK64Y417e4gmao6Tp9sud3ZxCvUSMNj+yx7lH3d6WXhUjI2UgXAobfn20m14tWh+Ajd6hQRWzrsCYnfPei4GfpPBlNehP4rbLuQfbdIBgBQy+zKCyqkEvJCop2qFT+OE1MZ2djoa6ohMzezQ1b7hRNhIBe1qlo7NU6BWoVO4gT00pVuJ+3STKs0KwOs1OGgsBzhra3YGNQDSqmmyrMYdnGRrD+7giepJDIM06ifjjk+Bqvv2kmSNXI3TIt+nI02glaWBtUgS1RoU52+broJQ7DvVXVItd9m4/MXu28gr01PpqRte0SIFMVHShUG1b3aBR61hNNyvDnMsKA+1J6ETKU8snl/ehi6cZgieO81KNR6mBbDXz5u43rqhpwN+Tmh2GMIV76Y2YUrJqyzNrz4wtOvSNL41nuvBychSoKTyJBahP20oOQrdtcACTCqq5R5EMeFzamjtMOgT/ubrKRScMCGCSE20cUrHseVp3+kACQlfdoidDigjOFAj6hBU4fkbiT/9DxFuA1RVm0MZrPCzYfOy5y2jaAlP89tzhZQbCal08C/SHcVBa4HuoM/uYX2lqTcQ6Up2cZayIDYH1UJYm+/yoUvbHAbJxFWj25XoaJzKuYNywqKWiuGO7hCwW/oXHI6Yjcx7Yy5mqecaGhlIIaxlYhuqgNiaenynkncLHS0Gwqw+xzLsyb3tGFez1IEuL6zjGXWMALcBmZAo+F8FOqPSt2OegWUtUpDdZme0LZ9PgDTkRRCl0+NjnAPWnbhZTpWFsXBRRxxg3bAcNED7XmUSBXYtqa4YfIxO04RZHKiLfG+q4rKvXNgZs6Akoop0mR+cR7MGWQ74DhJinZDx+fC0TJouIWyMnb7eA1XVkTLy82IdiNGxoZyJvwubkV6m6Um/UEgQztXiZVM2naF5ncPD1Cx8theBFuhoCrR6oWjIxUrzFrzg43jk2NuHSvm6KrKwkJvBzt0SUtNeEtUXiTJFujqRmUEnE9YI0spVb+l95WyKWlP8NzxwAc5yFFztB6HR/QV6GYnyaIobjTqGReuGfQHtSqld4XgeGl6UuTM99JqLnQkMFIyBxizqu85YWJ33fFUqL48aS4fj8PE6p/MOa/L3QlGmO2wxS0WWXZHHdmRbugGFGgeNLZT6IGz6Cyb3Y+acFKLyIvDZli1lrAHoj8hASJVxx7IPJVPdJFimW09kTEEtPrKy98FLbDT7bcWF6L5nrOQW7zpLZZkdjGQIVEkNGNtck5qRR5BjBWQacG16Dh4HcMm1wclm3PF2oymM83h3OS3aFPW7vHgTIHNixZtL8pEptuKZJxzDiibpRxyAXPNMQZc3wqXjdsMVcPIX0blIcXEl7wFJVm7KGKfmoG8pKkHEmSZvWwxQZd8GrGiprbL0ERQmtuRsubQ7pkg6clDVLCBAt2ZH3ENXo6yWGVTaX7ap1GbjZ3CXkLVd9N8pXi8SbZdIv9J0cfsLTC8uWypJdOGBagSvu0cubGE/q/ndiKKUHElCaz6GjwOgGPlGAQTtQrBU5yNTAQjo5V9c33bpV3HwVKJEyYUqD1SV2MjI5hpFuO/kPU0SWmACrJbpEVmmcgps3cQuU5VjdulWyinIpy1TuHLmSAv+lJ3oEzZ3AoUtBXnCfsl2BQI2gJSvcaK1qosspaKzKsSI4KmP+ilFp6wQq71pEph2VFcxO3UbnjKJXs/2Ja7KEYaQa8bRb1kQ7PZ11l3Pp6crLf7RQ9Er+FS1EbfanSxJDlg7l4kwNOLhkgCbU95emYgeCPJQRjxWMnXnVvxarR/BemE7by/mPo+GSzCKMpyvb+Tg2dtACeSOrWtJTbMYYUZd+ywlbCeIGuuvdrOFygGmFTLOEmoAFFwhluZekCuTtx0XwLtcrzIJuxIpmndbtkpBYVJUzuNg5TIbed5i0HzHmF3hlv4ZPvCaera5qobRtZ9+8gNlWcuQ6P44afud5vaauoiAk2QbYui5lbsVgcbzh/PuQ4WNeLccNen4zQcrY6tba2b7e1QUx7jnvaYAuW9rEjMvKOHTHs5qH4e53k/TzqZ03SscdsmLzaVdQTdM9jEGZekRXJ0YWEKZ5MVmDfmsgjOTHArLfkm1C7PcIBjjOhJSJvEW8s7ANJZDBgUT+ByqrvNw+KRaBvabIw0WbN51kG4bYDShJjzAYU7ZVw5hIh4GDK+Kw7JZkzkvhBG/82SIqFUDWEqe3uez3HqmlHQCvvaqUvFYd6CaKYolE6XyNQMZSnaG6dZAXDTS2SftuNCkbpWmGLOWNoX9/dth99Bcpkmc3dMBKpDT9DxDMYSrg6d9+BfQQTsDXK8GNWNKnRkudgdiBFlV6GwOJiSUUjeQArw1TLT5IAiwtjtWwZudRHgqV1grHJdnA3siC2eoP1B1KiTtyctyIiEswDk1Ya0x8nJGM6HVqyyzMQuCY76I2q6ftQfm3BAd6NEjNa8ADrPfqs1H6f9fHKc3IdgKwcWQxw5Oi7NpiFkGw6JSddi6SoORMRcdml/OUV39KFDCixCm70lt8ipMFHQqnBtDsufl5oDL2Tbz5OBpaDh+zrqZlR/g2q+57ayORWsaPYsJxadVrq26nUGSR4C4NUjLl7eIsm2wJBEpIDxhLzVagVLT7dH6Qu0r0G9sT+Oe/12jar6++1uD2tbvfETFLg4rzmgOc1T5bih58/Wmg/isfz6Lm3FXOWjL2UCVc5EMHAl1OH26ElXD5jCUrpwspy8raSUhw8YR06K4mlVwmGIz2Nie6xH26oeASn7MF6nm1BC2EIv3j877VSkCTdbgVB77FEMwH/qay0rehTuRxhEyhd+0r4Paa6XeYdpc9IVmDQZD7IJasnZAeESV6ro5cSpPB8CH+Mgl43IyE9jkj2BlexAtw0FMw8yZDcEiGx9y83z5EU+jE0oChOiwIhGdjvy+9PYA7GqSLdqy0Fe+/+Ie7NeS7LsPGwPEXGGO+RYVVnV7CLFltnstkFCpDjA4IPpBwOCbcjmqwG9CwIE+C/45xgwBL4ZAvwoELIAW6RlUc2hq4vd1TVkVuYdzxARe2/vtb611o5zM6ubtEg7Wcy+ee+550Ts2HsN3/rWtw6DH9zLYQxjYOk3ZodU7x3JqgxH51+N225Vv3dWE6KY+2qS78ruSBfy6raeJLL8EzUYxFSfyCbVuKce/mrQaizx5ac3Xk3kQHT/mrtRPDmcU3K4Pu/7bde5+B8j01YNVo22Ove9Vc3Y67ruKFUmJe+68V+lap7K4ydhvHXl1ape6OE4JhrEQC3BdSF/+cPna1++eH1Tr7hbx3oIyZreShcSFpr46+ypJlZ+jdf+8/99qqft/v5Yn8whFZqezfsbYfV3fum8vuyuGvSLun7d3PFzf953H3Vfb+R5+BekAPKSejFks5dc17u7rulRIki+Zqh1P72Jc42QD9fTYXe4uFilXb55tXv/8Xmpu+2qXF8f+y5enPevf7rvsn/6ePv6euySf3oxuJvqiGbpca9OrLqurtv752X1tXvR/7R/tFu/mKYwfb31VGf5UxrKNtHm/fE9MWVrLmw68SiyEMc2CDBHJfVx6td+8ziuL/zZ038Zutt+8znX+ceSh9jfxo7G6tal44GB/MUhJ21IRrdm13P/12Gm5kK/5Znpo389849i3SgdO7dCHOhUMobd01R0YlTx5f2tQAzv/MN5TuYW8Z+RHGgTzeLP4EhEnC6b6BnMzMynm5v/NaxXv/Tiu5+/+avbmyt7CwKz+tYuzZPeU/Ud9W9CG/lBMGmAWAVUy54KvXk5gaHe/lOP+vjmsK5RUA7HMg8ljONclzcdmLmW3e4wd+c1jEpjmkMKeceNrlRrlgCK2kZJV4rrkl2wFnTPPG0pK2eBSNuEXWmOdJZy8vl4d0Ny1l9Hs3rGlJRZqgpkvsZ0/On+o3F7saKWqO5YParnTmf+AL6GGm6cv6xWc1hRU2QYaDn7muPtN5RyUjbc+alu8FB2sSDuGxI+PcuKuw4N7MS9OlBYVPcezQDd00fc30x10/Z93JwRhYAnFlN0+f8C6+w2Uzju5ppAuc4/8avNun/zZn88TP3sf+HxxesYv6IuXcKVagZEA/zYj9TDsSNOIy3mQKr4HEJntOP5vqOhWHRjE4pRZbjM8f1+/0NSBSBRBi4ikgwLV3G6ob/4oP/6g8xLUC1Fv89un1OgCnuoEfWYph4aBZ0/HtL+OD7pyIxevzmsYnhyubm+3h9fH58/OfOkgHx4sl2vh+71LdmeanbjPuwn3/fEnyRC5jgGT/TttDqbV/71ur+fn+/C85fr6ntW/us/itzuBWXk+tQ/f/3fxbuP6BlMmGxUA7gU47/y3Z97JdfVG6r7oVrEK+7reXN9U+/s8aOLGmrd3e+vrm/OttsaXV3d3G76+J3fBZH33UkcHiL3HsRqgFBeYTDYI1kAc4c3NHnx2FO7BHcvkf2vWQlz6Dwf4MJjV8T1UUsTxQJ/h1PjMZgDg2EkmeHydFGTI9w0jkradi1u/XUebiIVds7D4TjltZ/XuRqJYbOa+5RuU+Rm5svD+T/4+B/99vfdD37yb3762V/e/PTHx3mmjsobevdqsY+Oymf1CqrBi8nPNTsgKmycaxx+yH4Ih1j3z7T6uJ5FogITCYtaeYhE6jvizbqh2pgSX/nh5fz0bmARO8/kcLc7MgN+jtx+F/Lt9Pgu3Bbqd6p7lZzDTJW4SPSg8ZCIt3KTxu2TdTznoTiEl5EFqcfg/Mm64w6TeqHENIph4AP8Nz3CGoWxH2KpBfsRPfqNrzs9PRvGn5TrbV2QUD4Rdhif1wyItgzh/nndSSkPuW6Vepq7voBUwSXluJm3a1IUymccFSLenLk7Rae7ON6fC95JESuMHBatHbfjkQC+e9oe5D4JmO4pk6U9Cv7jz7n/7snruDvmcl+v0eVNjaCpO3QbB/8oHM79vE/lyomhp55yajGvzzBdva4ZWEeBmP/6vqaONDUoslupOU+9VJqrTjQ6bu04D5vHXc8pN9ogkKhP89St/Le/t/WT++CXL/Y3x2PNyI75/Y8ur7/e766PH2zP6ol9fTWVqTyvEREdQn9/zNf36fyxq1HS4XXpzx1VAPfdcZVniEY8j1dnNfB+fz4rY42o3LOw/qh+5Gf3x1C+RwIE1fDs3+9314fDex1plfgpkWehOiNd5L+OnKUiVaMm2/5Vvxq2j/4CUo399tMYj/P+Ztr56b6U637ou2maD4kqeh0vkWPwoh+6iasscJ6FZ5lwS/nP3oJhUDIRNwl7pjXSrVU3wERTiMy44SJ0T+f6Kb4elwCpQae9appPhf+PBYuFtFTt5v5uotYlamlITPoW9SwhKvCohXp5w6qjKnO1F9QdkfvbuhM7IuNcUw4yRHeY6oYmP0GqituZQtrrcDn/vf3ukL74yTlBAI6Xmf5w/gUCEXUxE+kjdPk4DShDHsul717t3dMfxbFGnaRMQKeyWsr9cSa5msHd7o9nq9XGRWrJf9QduA2VmcFlf+C2Tu5sp0TuwA0AmK5Fg5Aj0W5nqjKVeogcDePpd+68PqwrFjxi3Yvs4tV+v70b6tvEobtLx/B0+PBbF1OgNqm6fVIfdleksbTe9kAAkExSY0B1ReWva9Xokqm9pKxvwtinN+OBkCkSfCAq5VAjHNHSqt8Yhw9PiAeoOdjj6jizrr/xzg+CMEDSCBHhnnPSnabYHMbNNikCMQOJ+BbVUFIqQISRWD0HxcLp3ffYffktntRRVqRIFf3XNYL+cI0jdVfTxkflKStZPi59cf3+x305UPT0yZcvBxa9o47HDHWQapsjGylCf6A1Xl9ZX7CZ/O4n+Trlm7sdHCwR+1n4aN11j6ori/HJj9zqGK/3NMHt7Cs/HoNbr1LvhqGeyT734SU5Q7KYu7sX19vz+02fJ39/9h1qx61R7qGaq1/sKY0kSzO/Sq5cVsM6szcYeAYJyw9Qf25kWzQMu2H9Z+hFpSJLt1uff1Gf5GdXI8fLIqtQr+fZx3+4efTwUQ01e34W96983jkPq8CDLXoexny+WT1Z9zO6XLn6+/6vcZuhf8QDUX4WLM04aA2UqEAj4CvjgHBTLFBBR70j5S8Ks0n+i+LBjArdz9nFRdEj/1ZWdrLZ3/q9omdAp7mcpFSyL+W26pXeXR0OR8dtCYxSq++lrDbI7ucuDDdydrGvN3U+1W+sVxQnrG/dMJHjoFnem8CVKoqVDqu765uvtpsnwzDkTbx9Tu8dx7x71G5OdvboSGuCOIEj18ECo/fki+bbalPcaj3klCA5UO3dZrtikQ33/tn5MeXduhzXfnc26Wog8+KZvlzIp+GAT8KYqCeEda/45wSrU6sWYQA1+t25uO4TyXeRpiOh1APlZXHvq4G73Kxqwlj95tnoLiY30JxMEp7dHadNjl/udquncX3BFK2xHFg0rkzpdkXtQZsaqG/j8foYh9htuunA4HGNObo8hL6GosR1eDVTf2jvDm5c74knJY8PuldgXTGDtC7mg8cd4t/AydFz5J6tv5U/JbV96VeewIHSLqYrHfZh+xYyO2pJOeup3S9N3OHvN5c1o6rJPNHhwHZF61B1oswSCz3PY6yxBvfiFSovcsB5Q8XWiQuohWdeAwjNNYzrqlP9xf6Qn3w6E0HgWJOx3Xc/G9NwGadDf7z9xcKczHF3ltMHHcPJGLoz9mKMOgrp66ffrocDserqLa1/UsIdES/ImNJ23l58KuSgcDtsXv685Z+L4q2EKp4KCMzTqZ5AdJv3iKOSb+oeoSbEO2b+XV6c3zsqkgbAE7yT2awXljMQ98V5H2lOLEElz1Ua/g3OnCI1OcGA0sJH1KeQAuhvFQL+T6zM0hj502/asfZqhpx7+Lv6GvKcM5S/CRGjbt0poX/IL8sOQ0CRKNcwqJ/qrx9HJKnqqIPcY+yhAE4RFnekUsiJoZOoKyWKq/z9I7cTnYSTaez1tP/pH/3LIW67zcWb+ev7M17M83fc97hB7mnCmMA9+Z/n3RcE1TYC2vKVpP9w+rnSVyeJD0pvdCumskmo2ZjLwl5SVXHOda0IpJ8Ld8Z2AHvIgz7bHIqfCIXONRWsHxjWfkI3VkndNu53aUhhtXdrIiHQ726rq8r++n4cvzg+Oe8fXaxvd4dLxsoO/bSZS7cajtNY09luKHfTsXfdikMIyn/79bwKx/PEY6ITTS2hq0sDiSAGoKv/fw0BeMefRWLI+BHvn0jrl4+lyyGNL+fDfozsW6orv7olqPZsjE+fDjXbu72rMa5/vBnWgz/c7if6lX67Wdf/Xl/dOHKJ1Cny9MnjugqHw7g/kOQKZI9YUi1DoYKGCOWyfvRfxeHJ+blLxxdxeFbz9p9+mefjI5pM2EdUkSlU6cLMBGWumRxZ6SRsz/8qxH3c/BCAZog33fpzAbnjLsTDf8wqLdaLEgTHhAYkMceak8QEjgxRDbUnFNGMP6tXM/S7Ffsu0SJhNd66LahimLupv0yvPrt1ojfnQcnhI0rh0jSyvY8eY3vA06lm+p0R+CLSWXwX/1wEbsW3Y+YfvOztvenf/U+ehE7lsONh5jy0kJwOTFhGb3mRGlmPwkk5TMfuwqHa5Ryq7J5bQbnrEAkgC4gO6w7dYDzTWDoE7e5OLmfxz/qCcXM1u+vD/Pm1P/rl3TVFZfzr5Bf9chXeii0ffITSRd3yevy7ok5lmVczEd/+6drUVFgJLqe3Ylpf1k8Iov88zqzzITOcC/Xcb44j9WyQ6gSRr/xqzDU4qGlEyiQnvaW2m7rMvmPZxZBqgEW4ej6mNYm5EfGKBtavV/Udbi9ZzqRmsgnzBFW7pOuY3fq3SJ/6O/lT2L/QOr//l/3Lq2NMNWj15ySyGO93x1U9NDUO31AtpW5G17urdV5Xm//E9YdVOXbv9U/rqbq927PgdZFWLI53XNPY40aFeuBHCrpq/khsz/VvbTYfu3CTVrRqfThuz36cqyWiPHnuN58UyK23PvgfiL4FRzx/h2iMfghFhYkiQRaTpBCy77tBsmTX8MXCbas1dzvWYzu5Lb388dM4nFGo6QNpLu+uZx4HkPoiG8LGizQWNaZec+jklU9on7U8Mw8SyQffeceRe2DUFi9bnsmHy1AELWflHIoa6m1ysZySO3qsbKSod4+DTdL/OtBWomEaLFbHFa2IyJRIjpSs1F/i8llkUV3SpPcob/Vc2RQ1HgHAxN+/+1EH9yqM7p0vOP2Ot9tcKGHxF+Wt77xjid7++u0/bxtWUE8WP1XEju49Pnimy+d4csFgcnR+PKuxl8V9hRzy886Xrn7xcp9YgDFR7EG/L5xXiRVi2KU0VnsZcNbbPRZJCklyHiQMFK9dWdisb1iZh+v2Ta9/5+/+Lf3p9k9K2fbzUMb58pP8mMRDzt8jetPd34u3dOc1xZl3351f5tWatBCn/QdPh3/R+R+yxN0c4rOhv1mvV9c3d6isMY+UFVSwMvqH+GNd+OA7/8v6bD1svvybX+rfmW706WNIrBYvJpOj5XomD/eSPiTUjPnvojP4KBt6lGtqQzxADp3oB2vSxjGsB6RB+xywkN1bbvxkG5zalLdNzAMj9U2/8vafdwYUrAWUiGHENWnksYyaU2EI8DkYSVgHYUhOGPdU5i48OXQrahivljseJ8IK/eDTypU91R18tU3UssWnpetqvlSdZE2WamxfvWPv+zzM3UVHolUpRVdNGkkWx1UsBOFRSWc+5CCVBb36yFlnF1SXj/FaBzwR2kFkJWuc2G87Uoh0rOAxUzXz29/6+13oP7/6tJpcMq+kuUK/RR0dwIBYyZ2V0YK0joG8+E37qPysp/nwIZaH33Tf5D8efJ+/Tlu7ELsgnbtFFYLUjKDtbl4hGefFVSV6rCmthoE0+n37xBP787Zx1y9OPOhbV/jOw/WNVuyvZ+NqDNn9+dV/O+6ez+OTGu50nkZXz6zYT9EX6eD6kWWh66MMhJ4OXTzcl3+03v5w7qZn3yl+ft0f/8/6C6/fXBMhngvnmGhS14PUeOfy9Bc226fdxfMVyRUM185du7+NP8uiQ1hiQLZAP9vwv7WIDA/zXFXZoI6NbLy9Ovg+Fy3NI6PhYTosit15/oJ4gwLEAAJTjXa8P7GZvwFrf/BNgxPKMqdbfPHuZ7kMncrpLZ+87l3fQNqiqvzHHeua1/AoFZErZoIFFQGikYYC921QFVztGj2Q+rJqkjb3gWaZBZJYnm8p6ogHYuESVdoRxXegUSB9NUPbIY5z7ge/Geg7AOLHHNc0LqbcHmoSNG+7eH/M4dyNg59flHDejTdj3bq+9/lu2ryKU5nOhyH5fL9K3VUOFyFvgjtWF9KRHPu+PL2jPplpnKoZrVez2nQHn59fPv3t3/uDr978qK+7fvb//v/4V599/oOyy90qvLnfdTXGWZV6+V21tGfd4Xiotzb4bp+O1c7e3B/cNmwfram+mWZ3bJW7JVfj3Wv+Mw8nB7PN2GCAyElEZtnuaQpsn86dI99wZGTSBG3RmcWUdG5zsKvCfniHJXrwhRcj6N4GKN65vX8+lfitdTv9Hh2o7Lp8+5t1Y0aOFOjQrd505dBtPu/7O5RUfbjrN5913TGuXs77b3frn/hFu+x0E+5+RNNimYGGTQv8hI76NFMZ8fzp8PTb7yYVt9aTdz1RxKuQ82ZyMLF7oSqF38XJ5CEqYjKYM6lRuDvxG+15l5MvHGu9I/Hh9xSYjylhFBCwHHOHo0sHkmMjnK2AyYGMGb9tLNo/RY98ufxvfWF7dPnrC0T8Z6Unyhl/uDn8N77Y0WSeGkqQUmjaUxUZcFJN3LeXsXreaoMGfWiUGB5JrNErbkU54zHVF4C1wCJ/NTan1/rJxQM119TYaCLRGb5xzwFP59Z957jDedV3x0IMvsfbdd0n3oVtT34u1fjLBWj+DY7EMOsGeFZfk/z1m/Hitlt19SLrS+Lt3f58Qy6C6oejO++H9V2NpZz/OpMoB7HBIiWg7HQz0R7DtuspIjz6p6vV9V/85d2vXT+7/DbXbsqZO/v1X/n99z7+le355b/+X//n1z/54TAG1ulw5aYMU7zcrqopOMvrevfhLl75aftBta3janQvwzFv3dnFJi61rt4RLklI/s6DwAEsWQ9GS7O2FMKAmNILpSlBZkc4EFBzbhspsQgaIf2JQ1lNKHHKSNGf5m+CVqrFlaA4HLdtL82lQwHdWwOrfYzsop8byy/u/eF3aBdFnqpXMvrqaqRco+nAsouJcttQb2bYDKQpsOlr6FtdSPfs2/+i335iHxnivQ/zN31qv/30wXfCKm+/5eYb9+zp4+owr65voUsfikx1D0TI80iI0JFQitqaxSPk6BvcSLKjVHZhkJIm7KCkwU0M67PeDBwRefrQr7pgyCcs/TdgBG+v7CIqAXjk2CQl0nLp687OKHJdPFmvL5hFE/2J8zm1O61mZmahhUjlRBzWDBk7DeBND3f5EiB/u4bzIH70J7/6zu0itaDF5ddgN+7K7qMaVHt5P6+KQKuuX7VfqM8iLuimYqRY8KQaevqRdIfwZazd/oKgSC628eg2VrZnCqu7D3OkXlwal1Xf8X6YA0+3YDmQzILIrtvzZiYCQECf7219QNWUXedY87fJEf7i8uPzVfJ+vyLiJw3vc6kQ3ZG4TnGkfe+pOay+c7l9TP6HOKLFo/B7W1Ifr3708v/+zvDrn7364QdPvp3WXb998vLHn66ff3hTt95ZuS8zzawpub8v6832yAPB6sZI01ivbTvG7U3ZVKPqyv3VOK/y7ZNdvOy2G+Y3ueZ4Fk/JN46/b9tGird0QNgxszlBhRoemqRrrDJLV1TqAR73x83FmidIkgiM60pcd9M89dUo179jX600Delg44eOSBKmgviPp95sskTM8hvHfHMzXT46P1wd1s/W8+vD+9PZ67SLF0P8avTnq5q495uOuCDB72nmClHWqG3jg/Xtl7eri7MxHYfYzYGkuuuPS3WFvku7efV4fbw/9P1Qr7Ze8+HusLnczJ6exZSmgXqlffVMm7E7fLUPF6t0e3ixO//66m6zIW2tuZ7K1TzcpNX5sCev5rvN43/r/kZ/2igpPpB1mS5y2vsawieepIIfRhZ3IDmMkm5e72dSIpDIyKNpITBOxNWx4CXcQaMmcq4VK2Sz2aKjQNR+lSu0k+/eMu1LEOek3KMbBSyFJWLNhTmKzvDPOck4P3SuUjMfzQ2Ky5hM4j42N6DekboO6t3BmTsEso7Y0z7RgiBIL7S6ntpuk2dp7ss2uaxPy3vLEmh4kG2c3KN76Np9zXby8bHLY/GuRXMLIKa9Ka1AH4vOn6tPxMQkCbHSk2l+CKezpNa46zX+xg8jNwlRkynNgGTGW6Q9jo9Nl0VUXAwwLlwi2sYroRxM3Mxff5SOK7X4bDJ1nWXC0rJtkVpWF3b9WMonP/6/xjf7f/PT/+33/pP/+qa///aLZ7F86/7+vjxZveoh2sHv8J4j8StZYP5i6tavSA6Xp7qTdkA8hovPy/QqhffT+WU8PnHHl7tDcvG871ktE9fWnJ36LcRAVDgewvqsG6lHmXLe1dDvd4fy0tWNeYBq5zjNNckuU011Dz/ZP0pDf5aIykCSbNWUhikf+po7V6tds/e162nioB8PpEyTGRAsnWeOvuOIF4AKzR+vp7T/0Xw+jN1c/FfjsK+ByPw4D5u76r7O3E0cp7AZwjiXejHd/tjRpKNynEL/xXRRHdRXpV4ZiVOQ3m1/d3dfw15CvH23O+y2Q9cNaU+FpbTdx9V52B/oKa4nf/ae/+rV7Wa1vnDzcAj5p/VeBtenbT2NE52uGr36Y+i787Kbh0zN5N07CDun/nxpFzKb+/GQRFEoFeW1zu485mNeP6u729GShbTmSQIUlMY8Hjlx0xYqVO4DvuD4NurZfhAQdf1DXri2WT20VmXhuE5+auGPpmbtXnU0lM3JBC5mgwhtWiSyUQbpEtzgPCa0pLaONmEGO9g+kv4KAVbJ8sLl1S5yvWakFsbLm43LC9JmC7hwBNS0tPzxQZq5sGEnnIb6zFgj0wASI0CocGZbvaUmn2fJc5mGg9TYaYDmmqmd53yytfiMkP1htKemkJZT+EVV9MTuLtcHnb2RGtT1OWZxAIslWxoCp17KO4GRH0Sg9aF/+fWPb15/7Xv3Z//hj+pZH47+LDy7fPJ8d/gMi6/v0N5N96U/vIik5kFZr/PP1/GrqbxKw5Qu3vj+zg2fpfdWZz9+fbtf7faPw+r5cPlsM5GOU+B5jyzCwxUqCiO7OI7H7Xq9+/Pby7ue9JJrYt2n1d4f74nfX8Z63Kv7H3aU3IaBCoOR9MQP85o4cNSGTGduruEDjRpd1WM/uakGPIcaKca+i6RlWvPe2b3hZ0DNQ1zHoPA55bXz52Goj6yGuWVXNuttDKUb+jTPLF1DRm5i4b9Cc7q2I+mU5hWVd33N8feH42boQB2v0eCTi+1u5JEfnjLQniein6HVbLMpVJGkCY6pBiW37jKvz3I31nXbro/E2shXYR7WNfuee+ptoHDAD2kk3WNSGOzekUi8K2aRVI47g7ilUuwCU0JyCWPu6m3lvitZOjCZWESkAC+AdBCsGhQk0I4ACT2wR4t/nMCKerBPThe9IjQjBU6jW4RXJ2ZXUzOja8PtZyhB8+6v6cYEOhUXiWuisrumsm+WFvksYoOL8ybdMDZdmZorA1fWHN8pX3m2y5XuGYW6qRNw6fm9lzyhge4Ly1ssstIDZKZwidPhfx4eUTuEtrxFMMSiMaDTftolHLb0IuYYBMjzQlBY+jkYNe9Orsqdmmynz2sZhS2ioeWzk+vh0y3R78mesZ+Wxe+ao11UtU6sYaGOkHsa1eBedq/rlfzg039XA55NWV+dXS9GLsiLF3GurZ6+Ye/dtwb3XilfTnlXtitqNqxxhUtus4tl59zV/OQYX9/tu/Mh3NfPoKCpn93qbKDm0K1b++7RX+VHx23dP9f7A/U1Ek1/M7r7wmMmCA7mexsiV0a77rji6Sox7tmg7DO1FtX3JCCl1BeR7HLH453nAnSDZLxrJshnWeJdTyrpkZL+la8XQTMXSpo24/y8fvPo2p0iricnVA1tdyxocanZ71U+xieBtFfoNYntYBl2uYYix6kuRTdShhTmekPTuFnPNG+4Wq49VWMnHzfn62ka04vui2o9Qq7n7LjyHEG7Vuv0AKno77/WONYijbYFNX6Gk6RZBHGWtIajVFQoHxRUKIIkSfBQaAYr9IOccgxtPjlmuqU0cjixVnZmWuFsGQ1Ih7syeXStYUML+MccGybtyXQ6NNBMId0dASjUV0RrlvP97ewPBQlR8Dr53Yt5gv0Va6VMdA6vRAdGzluAMfXNmOL6gxgRC8TsZCxL4MWdhI0LWyBRlySbhm0pnHcCutEFlfLW7D9IpwNiacf51OLTjSxGki8gOXUhD7aLPzFhS2P3IPIti4DIqyMCTJBFzllvR0vuZqCbGeW/mn33XlUQ2nLJoMLy8Hps9abzIxFT3dFS43YLQW1WaY/vIa44+PDt4TC7r3LiTXWMcchfjkTpHGN5OT91q23ujnOp2c2Rus+IWzXXfO1lHphYG9b90fG4k1Jj+Xk1lFuaEOKnCZadHGjhwXLUj0GdXqwL2GOc7vJyOPnlLYeOLhockogGTG1JnENQocyzeBRZoPn1OUl562nN/nYikgA128lWd7yTC9uM3MsZm0jI36OVQ7Z2oXk/hw1n087dEw0PS13vwd8DH0emz4OoHHh6pNFZk3SEzPJGcjryCV/kxGAhjHJagAPXBsQcfIHiAoSBeC2yGRcSvR+oOQMdrcxO4gFyJCfGCSDbr1YSXKDjDze3qdBqJKKTMvU4OCRDoqilfrUoyM1fspYV93kVlE6aBpti/3IxvrWVMz0y0OA5PXTV/8zjTMFvzd7VJAFl85zJmpHCF6B0L21KC0+8oVQO3ctOD1KRvg7fioqnoaIvDy2Ivqc/ibAW1HZJIYOSp2GYzA+0j5bjugi+ytuAV2lO4CSSOsnErNDg5EhrJFRMaVrQHH0bNZ5t3sGD9M3M9fJznWsey4yVObDMzQgn2MJbtltC1AfJRHvPhXldWES75ROKicHn0MCiwdsSAPsP+vBel75M/g2Nj6pnYCKpNeKpU1LNugc1SJlImGh14w+HzXh/QUeZfWq4L/msbOru7afMLT4ZR1JEtVArJ/UOzY6XqKdrF2zXz+o3lJPWQ8kqdfX4z8SUDuX29p4IzNBBJQvFiT9L8dHMlBgwgZj4Q+A5q0oE5Bp8g12Llb9KbhdwsnWxTbJ9XU5fcwLawM04uMwaWY7HWaIkLaYyOZCWgOUTlUCg9QwOmhzsOisLhNjLAebmZ80k9EgrAVPR4kV8cbKa3umZUO+1+BEsIwgp9iMs0SJ/8Rz40XPlR1gMaJM6bubACgTOLDQrKSfzcEZY4Ri2qObiMUzzfEbDFqPdTuDHhjZAImF1onjrmR1ezfoij/MwCthLuH72G2oAnPl8RZ+CPGYXLO9zbzO/5d303peVhBODEpCKSuyi9kJs3MK84JDLNx+EDuoJWtDE1pb+kbOaRd9ud5nPWp20LYhGTI1jyTfRwha5HayLb3V3O35elmiJDZLKVdbrlzUUG7pMt8tiPReVjGavT21W8RbzLd5BXmOn0Z7jae5sVxw/7OYP+y9rBDbO1VrwJLDA6RWwwdR34Srtp5WYbykGBoAd3DG6ctxgvXC6iUdRa4qjqY9mzEn4vWJMbVcEAJ+ewRx6ESHhNcAa/Oasl7OQ8L4L0RhVheQSmciZ4ix0hGZGDlBkHVn3AD6SWrnbHhb4wmKQhfUqp7749GE1AIR1Krr766MEFwidirzQy2cLE9JaRiiMigKZo0ub3bgZkKUBav/kRl51zyewQoElkp+E9uvLvMl+tNxP9jboMMgq5MgTW3XNi9P/2CJPWR4zP488SwGZR5k54bY4Sp2HjrRBitDEgl2TpLKCWknsU+0UFSI03rSTCVQFhNIQW9hepP54WtODAbKIDFVI+dHCBMD609XbdCKLE806CPit0668XVVRK6X5VIFRU9xMDACdhzaBwVr8PE9b1oqcehR7sgjojDdn6k5qN82A8Aer2VruUj555meXF1Ba9ORbMmkRojm/op+7xA3CSdxkMaDXTej0cSymHC9CllLMnzT3YZ5f70d3riIS5rmzhmRTL7fBNBLJWCkVpaa25iDmGZrxjvRAeWd6TfhBfZA4CyKo7aZkJASSxxNYUyPBYEUtNjjV1tScLPCIbDRpCDyycPCQDKE4IGHdMzQ2uJmX2/Spa7upPIPNB9i6TWaVzP/UkovIpa6coiVOi+lFrdwyqu2aMYZVQuDnvSU+USJDyW/f5jo2h6zpRqut6MNebPpTdNb5Jvf80Ei9ZWWXWaPEnGSVpmOeKUt1kFtseaugHj5rH4mHUBVYc4Ae4edsj3lf83matly/6kq/yf2ZDysHOSrms9HkSKxemtJxL9w85NstzsD+oKoCGdPAnQP0DnhNkd2TjYTVlCcZPw6AHhYWvAUXGo8hErHHvFgle9oWYWlYJ6cwaxpoXzsFskNQgokuSlttBb/FXFh4pWEInjLejbsF9SwV355mm6Iht1YWz5SMW3C5FShsZNGS6mEhdtt3LKwKc+bFRIr8opjpxb34FlTKevp8YnbRRerUd9tl8D0Gv7hivEzNuTNX0e63IDk1I6gUnuIEE1guMqniTZzQsqXAO4iQfCpL+160zaOIgrPsdgWULbYS447NWQrwJvld77QEmNJKgyY0NsBy5aSmk6elGdvOVFJLQhk8+0mkR7CxDRfyHIVJgBZOV0YCHbf0Wm/l6Lx7SvP03bDuDDkWk+QbwiqZ6kOAaeHQlv1TC5OytCzO7Nei5vXANvnTH+l3Guhjp3QJ/GK3KKzIMbNu2a5HexD5K8cDlxAbC1rE8MoCc9XtWu/9fGRjPXd4hKYHpwtNbdwHCqeC3atf7AxV+HaguqTqhMrMCnacNkqSqHq+Wn7xttftLHlLc+yjvcYFVtFf1Bkaq0BLoRrXsNmyGGf5nu1rPKCgSDasUvG6tx5cRjG/Z2ZXXoMZXCdmyLckbjH1p+2B037gXE5+sVkD7yx2gzVUfNNM52JfJHxnmS36lg82y7KIszSjdLpEils3LwSjsCjjFs0n7Z2hlrUM0nDv7cgV8wEnl0EfCh05wl5pgGjQijwkMZwJHwvcKUqexVo+krRqyMNiECOAo0NpB3/46tKP94U7JeXhsn3pyEYydBsKl17YmUFuG10cHGrJJ86jwNnqL9q2dEz5xtvStEKqUdLfjG5rXhKWpkI3j5M42lCJlqQt9l53/nh9YlZaVcu3NMS/bZga2mroxLLm8vBPQ53KO+1dKSdv66V01Up++hFmbB3QEMDnPKfbQ2jL0kNO1PWJygaT/xf1fq/+Mkg4GdRIMe64UJginZzCA1fywna45dJ6lYiBiltk+SO6DMLFAmJ7x0IFhoK3h0SRRWDyl9fgS82OrsPSpuPcsoDPMphq84qWVskZaCgImn7hGqIpuYwi/QigHvxZlA4kkiJbcCrG0joo7QJON09Z9KC9808Dhb5hvmFY9NY9KERIkIW0VN8Oyaleg33tNcmURcCaL6/ZGUJmHkJMV1EbxBebFbExc7/4LXMt+ibyD+W0iu2TyR2e9551btIsgEIyobBEbOyzytRIoMTiiJgUa7iVN8SGP6vrYr8S/fhuyJtnMU+ULcx5R6aflqCMxxkgBuALXCeRxQyG7/zAosYS5gM15khQZgs5iC9bJOhhaoERU54zS7r2INnC4cyutExQjxVjEIvtVyMsv8jveT3KEnR0xTUvsqghmYuwSLosAFGUwHJLR2UrlOZf1EGJfWz2SMo9rj3aJTrW3LVn8nNgpd2eVB9J6EfBODxLdOTi03AxiLnqN0iIqoMB8YomKm7ITyvPEmXj5MyTtcJrOpZaqI/yyiKsFE4/bT5Cyog62zGJNLOSFNiwUkEwsGnxdQl60dzhyfFRMVYtDE0TFw1cQS7SQoDBdqfHDKNcFFTK7WHRmG6hZbYjTRuRreHSZCxiARk+JundAoYXX2QFQ6/H0qp8QeyvGrhWZHm7NClE3KXZNfO6YKhZZORtIkNunFuxTaTjCHCtZbjydUenDvvRB9dw76AJicawzuJZ1/yoxVtOw9Wl2ZLWj5OGvlYhoRsUi+Pt0ctQNwIxCg2eoUo3cZwCV+3rpRI+E/mJzTnwdHnabDTGuDgBHxX2lZkgrtW+gh+cnALug04SQ2Q3T9ixgW/Ei2PA4nByF2Y/h1ZJY7kRCgkDDhLAfuI2qd3Rp29PByUv7GQ1BRq8hoUP04i1QYTFFtZ3EsYt8vWTfM6LCTRXs8SwbANZZG7O3HQ6JVl1GuEY30j5issPVMxPN43Xmpory+q73SSKu0AfGb1yMsptIR299MxMROARJlFYYCIFG7jeSbOsBZVnnFaSPtqUUY5lTiCeQPC/HR4m62PEvUrxqaC11SvYSkaZBKVYsh3IZH3gXjsWZayubO5yGihJxQXdFXIw2JI/CJqMj1C8gnp6UyfRSkGIF5RtkXNT9eYZlHIwLQzx7c3YyCopw4IUDhwye1Q1dthlLMPK3Fp97otNAO0TSayWhsl6BpoJk8ckRz345v+N3IVXRak2Fr14BbwgXi5Hy/B7hjj19gFZluXXTnJmff76jGA0DR9cRFtefrR0ISUVC9L1KSivhcEZknjVu5sxdgRGQUaQOLTcUju6dSl62Bpn1kcCrsgygCy2Q7rA1I1jNcFiAxAXnETNPrwAb0p3YDtF7+xlYZmALTs/EeC7RA/ESvDXdGQWtEqJxXSzWTiifmIJGbX174xCYp9j/+u4bu3arpBvt8eQF/VAUV/xFiUZBv8gPnL62a7Rcyxybg23Lbp2un3VluWlsJz2uCO4EqxdLSyyg7oaPY9+gBGxPl5YFoeJuzmzteKojc5S6TpFVfXo0hWw2pwZbt8Ijc08wcKCmQUoirSjpceoaG89VsbjzYkXbs3DC76ChJM4qPp9fYCNm2YJINycZJfL3Kd4W41WDsyAfs3uFWCXLfXWkSinXzsGermdUE0GD+lBS1MxBVHHq1GEA+F0sJW4IyUENqSiWYqFD1vUUmmhIEjbvFAWohks7yK5U415lFjkADRijT1Tr4EAdmCaYZpV1Jzme+cWREny7gWx1to3ZhRlhUexK3JeHE4h3WoglRsqrFtIDra6BEoCaiRe7RTpZLiw6oI0WrjQ88pTOsZPIUaENhyXabSGKIar+YRCJI6aWBOJvG/mH8F9SufZlPW8arzvvIJNNpheDHVRFiHvZic50eIhqhlRZFdQ47JMmtpjtNxC069lPgcsEotP+kXcS9+CeSszwgDApZj5swi5nVjDI9rQJr8M9xd+RmdMKhFBt4vdlIw5864lrpJEODHhQuGpL6B4GC6RpL81mPfVNCDWLIpN0DDy3lkwJQwDGtWXEZWgKYeYVetWv7fbk3rKaWYE5l4jH7HeproRhFSiNtMJp9/iDs8BS4sxxVjk0kKnVJy2VcuyZ827pHRVwkJsq+X01KhNsThbDUzKbKcEiYYwUSxidRqC8R8ayhKDWYEGNRR58wJ7QZ1soWiTAKyVM7IHYF9p+fZOmQx0Douh8XZoi+ZW+s/scEuwQSKfYnt7cVqQ5XHugWvLTj9B16eYFSO4TS/eI33iYpxF+tQEkHFfS6oHsVKKEwQAqy1bV+l1BPHPypbUc+MWf8xhwDXqc3d6CDUEowfE8EKQeJAS9hDW2wBYdjzMLLjGuRUNpHJDF9FVRlJrgwed3T5XBqkJiucg38aHxzVtW5pbF9zguvOA4zARdlbcgj1OU99JzY3VS/n6qbGxZ/IAHlmz5wvKngK77XqWEtjL3N+RDZVW+WZ/2tc4AvwpvuPCpGEJ2Epq6KRvplkdzVlwKQ/1SpopU607i5J4IxpuUJY0H7dwCF4LbfDcspN04yYeDodaSaJShc0c90igENl6kBei+BMEEaI7zuk34K2AA9Ohv1o8r0yLau7UQZpDYtWgrdH0nYJgTeI11h2VrFA1lLE1cwJCS9sa1CqvsCvOqSDlvn2yW6RCbBFoGDXi1oC6lRe4rYhJko0CI+JltU+ei2HPDIGaVyC7gJlOmSVhBWVcNPogVwpRgC0OJEMTjSg6gV3Gkbm8aFfXvQRbGaRQIE4ZyKZk6AnDtKjQUTgO42MVYBeEOZHFlHB2qPCZxJ1ydwXHPilpA0uaELMEYqUEmN0ojylrIZWtsOdnBMAZAK6cdkOjbP6V1KiXestZCG7Ww2DQJE+UgQFqVRoYU8SBIFgJxQdAMHYL7pE3x/qsJ1oyHdq6gXlcbSpwkJiuVLyOrlkeaHpzsr6EgBEEJk4yQXLDu2PG2ODGPwiDFyyMGDmsIFijuZSow4+B+dyRlYQp6Ho5WQ7UNA0V1UicJPXO0FJeTonfxBPbQppLs4foNep3nWg8uYUBklEvLSxaGibZKE5JiYojtp86wSybtoeX4lCDhDStxdMt+vhdcwjCnTGMNvGxn3kkcmKuCtPNi4ECxoGQHsYIdT2asoPeAgXR5KNIvt/LXhHksm6F2NIEHPmu7rOwmO5H2zrWJ1RY9svOnnpzwT5yc7kFQ65YTq6BVos0Gecf+KTWWRzKlCQJ4td+WMeJt1XapZCkUE1XPheLI4C8SwOwoZX8EdSaz0qKstpB6RcAzTM98QKdNqucFgQuTtHoFvNKFKZ+z5J6CzDtSLu2JYUqDW5JEPYdm78gAisCSqBTjkdvBbEXWCZttVE5DSGFkPSBeEGa78vmhmT7mOKb0ZlEvsSz0IjktjC+dOXeCQ21SPgjUTlhQ6URuA19hyx9KVZHYuBc6498YzSThrSsCtkOrZOADSf7jRwj7JA4J2PhCjUzFYXI+NflyunNVpseySCN8EA8WiOvY9IUlby4MHj0pPNNxSJoGA5XDUSJIUg/nXFlNJ8CWaG3Bp3gBUhsDRX8GisaoDstoH2HyKIIo5wHKu9lbwQpqZj30gx9AX1YhMD3CkrEYhR2URiQBkxr/61mhVkrX+10idVfdmCcpJohNIMloe+Clr2EWqzGaLucMZ3WySLb0TDpsPxIJ3II67ikI3EII/EXOK5W93XsUZEcmbppXYsOblTfRPuHGj9ba7HmJzVb0YwcVUUQESC3gE3jdcwErl8+XTPZ+rH7ebx4vpnux25LHbCrYVUOdEZpSId3qnTj85QP++l4M16+6reP/evrvf+VTXAyUdnAL8+DwBDEBadZnm4CmD8GLASKr5sZ04yUMi7OzDyEJ69Al422cDVhCK/IhiBpEoC2SEqLaJ8GduUWO2uOJ08vJWsvL5q9FnTp4ukoMfq0nwPpZJHRJAYkB4ST0fhldFw7BnrkpoLor0MESR8AYD7n9HnNrGxge0DMP1NkcKiyzjPHQkhSTH7RSawdwOGQpSdL19BihNWSFwsaUCSjdE5biNTrMatQSDZsoXitODaU4JHSahekjuE4NqJ5qynJDuyHamo7oU/zfwFD9ej8N5BBzCi7FssNC+sXAClLbnHvvFGKkrG9pDJuPs7FCck89kFShKBIGW8JVkWPy4+wgwwnbRUJ7xuPGtBUAxkXzbDdsuXFsgA5xl5wFoDcXuWADdNZtLAxddPMk2CPOPbFtoJzjXSnlRSvWJnTwEFsV9bsTGpzbYKxonlFInAsTSdot8tWQVuU4Rgv9BK2qj3FZauOApROm6EXu8OuRtCfoIgSbiFKV7xCSwLlFrF9OXM+SoeKrcF4SDRX/ct0/vXm+jCNYe6PedX1bpt2Ma/PurSf6ouP6Xjx9NHd6+v0Mg9f50eP4mYaLn5tdT/vwgU1bh3G43az2V/vz56f3766L6NAjd6Z0SFhfsNrcIUCTiurc2GdG9CDVlBOMQr8PwxdTllMnjBSObAwoWp9IphEaLaPkfWCkGSZVKIfM2tbpblZWI0YBZcUw0RBi6TVhemLUgGAJdTeI+E0Rq+mR+IxYmPW450kci+g4KuFLTyITIJZmpPkIWbvQyPi4HQhMs+zsD0Cs2qyFjK9NplJbKt5KwoFQLucIAkyMWARo4XmgaDPqmdnTlaJxFIvPGjgmV1ygiiwhROKRPSR00RTnebFXE2Dld0JWAETj0Ftfs3YRRLRcBRkZIcTwBdhBPFoSKQzgUdK4w7x5iIqhQILJ7PhQFOT6QphhXmOLssEBLlyZ8e6JdHFlrQNjkbGo6+2OobldZJvWChbSivwLRA1RMUL9Nd0+BDdiYFQCPaEkciZMGqLzth4Gh01NqNOVm7FTuQvCvcHeG95q0UhyTByPhty6zkjsAfdVLIAlHLcQsRWsq0ETjBY44yWaAyoSLfWoYOab1LmTcdx8jt3dt6ndT7fbq++uhm/Sumr6fGw7t381J/Fue4KmnbWjWfr/X28Dl1YJRfHQwmvxsuw/eJ2lzqCMurGOP+zXFPDN+Nd9aFnY1k9msevx/uP7/wQXCcZJ+88Cab6GLMaVgeQCDMEkQfxgljDfVD+J0pdbNNpZgzCTIRdaL6tmwwhQ5Hg35UFmMVQFPxT0fq6ONCuD1p7EmDIKpjYl+JssrI0uM7ntFCjIEjBnsZG57J6AMgICIZUTKdszi9ywMVWkm6TRAdVfktpt2zI6kMmkSYPM63bT/ZJXpAGomyboOUL3uxdSNzxTqaH3zYbx8KhXaEIdOiw1QW4lCRGQUDMQEO8lVkQPMRWZS8WKChBDKcMZWgsqUUGeBAkID4IYN9eoKDvTOYQQavT+gwhXI7R3hoW9esIiQg8nZoAUPxFtocm/xU+vNlLiCh6UzMz87228XkuIAkYEtHhSNo1HIVJvMYPLnJPtdFjYL5sCpmUYlG7t/qq6KkbH8JUUDQjUyMgPbpmEc0o5sZsMG6iLXRbd/HbTjKmRdTnG4ij8Rej4LLEEk7zG6VctMjcWI4IuxgU8x6uQ8+k5HhqhbP0afE/s9kfLWpFRF96zVpYwf4LykHHG2el2iJmqTHUeEz3n91vxtULP1xebu7u7rp++sivv7w5Jipvkidc92Uqcbta7Xb7GMbYDZ3L+9nFQq5q04e63zwNm/PurOz4fMxPXT7bENzg41jv8b2tX5QIka8ycTRxGJmNiyDpGLv9NOvVqmIEZFQDZMgDxSMzVWANAYMEGBlBDMhZ7BPhEKiJb00hghCJwwDjkV1DJ9g5n3ykQkgrxc+jWMFoSMBqA6ys3r6B6GxZEBUqIo74InMrL8AB+k3QfZFow5oj2WRDlsXh8cp4zlkwus3rjACyVnPhsSac9HEPAyyZTnL3GDhg1RNZagfeAL1iPmZbMXyxHLzSTpnGMkGKgx5lAcM3QpSKCjyuJJUKvQmbTA5XQGGKVpU/CEElreqCTADSDShUiKrs8WlDXoir4NcevqocahZDSnd8kqjXh3GrKFICvMjsEkz6JSEl5LC3LvgsvrNjISZkAIGoW7QtvVgx8Dnw3LHvDLCHuehagqDmRr4WMFKawCTAMZMWxAo0ct0Cbyql5Z8Wj2BDGKdDgYrFYvHDmBd8FYSswp/k/b9MazUAk0iqsaW8mpsggZjZXd6CevHONxKzljIlwlpw3Pke+OAxYJBSaRmWM+SNA3iXpznffHL9+LiNu/5sHedY4/ZjPQtnfZjq1ZUdY1o5bd1dTpuZwvqa4x2ntFqtDofpYj3c7dPZZnUcx7NNTNU1/cJq/zTsQ+EAybW+h4WiPB9Ra2uopzEC9tbg30tBp0g0Lp7WMPWGYdOtAAp0CjkxRzyI1bPzz4ek65E5yu2TAyQSk2sxeJaKG7R3lG2EcWcSf1hjtBwSJp3Nwm+C5prM0xZIKPEkZHfi/2BHqmXhFjy0+BZDnTCzWkgSMuVErRLPNMTmmQVswgezg5u02oDwRCkgEeFqaK1MqJxQuhoC7AhX/Fm0fsBoYSlHOCW+KRivD9QvXItU8ema57EgsQJjGcRDS/AlYbBq2qL6FE0bBP0MQZQtkFvId/TFPMqbqSGaWyTpeJMIoV78atObGgoTuArmwjgnAv9EbU08zTEq6l1aEGCBWHXUoGvwUWA4cZaIjMHEMjGcT3LE7CoM34YR7U4eoQHnQYcpFH0iRFxKSilCOKONZ04r5dIXUtDipudd/cai+0QJ8d42q0a28mAs65TqSRCqBJIR511YcPkl+LJkW/F12jEkbGPYHEfaiBAXfLJFJVV8mu4mQeLIIuD+agBSlEvttORfCo0fncv9p3f9GN4bN/XnR++nKW1WNICg6/rDsRqg1ZTy6v1NfhGuNrSAd1SagTRlvdqpbo/ru7F/EnYUJsW7Msb3No4LzPQSAilosLbscpTDI1asIDAx0ia2JmiNBD9FAQQb10kQQGc1VmxxMm1O8AHO/vIS5G6BMDnfoH6rxabYQpguBSoTP6Yi+BEatpL4QB6YXszVgSQFsD9EMbIekueKTzMFt/UqWa+FdNvxXaVZ7rKAXpP0zVlYOE+SluJw0rYFCEfTkoR1MUNriKslGLUp/4RNYAsYBNl0NsI6sS62rQ87tgInLQ7AKM1+QTth3xPUJbQtzVg4W0D+aVatSscCR0HZZCzapgIbymrLKgkJbytFAJhLBfvEGAmUpjUBrelrgOKVMgb3TzX0IeBBzzMmeHqoMwHzshgF4nqzpudaoONHzoB9YjeEGJcid7YPln7CuIPEq+2Nagr++3/6DyQqaUwI3dNqUhRpbtZKLYWRQgW0lhBNikEZqQSHbCcvK9rX1piNdp5gNNQetbJjElcjGV4ylKRduNPDZk+XCKIASkGs8NJLKLavFAtSlrG6sL2zssM0GHFajTKRkIlbJu4+uXm8W3elZnW02/vo+y4cyrx+sdkMnY89adOmvFvlchaXq2c3KExF1d2yyoY9BkvuGpCn4K4mSrJKXj2n1/Ya809LFEnjZae12WLMX2PqGqVT0vNZxqYiVKEsIygxQmiZDgianiW9HbZ3S/OHPFGi2wYwwOdZVU5r4erw9NMF6lEiYrFHhn1Tt/s0MlwSxaaIQQlAvjOqCmqs5ZmK5dVtADMh7++WVlWX3Sp3iQv8rv0hF9KJl6RrmLi4H4yjJFcL4gVycPyiQUyoVtlxQz6YhXPvtbKhZWuLA0Bi4Dey7hTZIV5zYS4gogNZ4uKUF87bMm4h/SJQ1dqrQJ9iFjUexfvDbOWsVCRoCuZiqrJuYUacawwP29IhynXzSC3M1hJzaXIyHbrqhNUZBFSQFEoNs6V4ZjhsdSzAecCHkhu2J7p8nuKv5HGKAeZgOGo7hS60lDPAHDDYyACvotQ+jY6Ar1EAguc9Q+0oK2nHHi0uUY3F4sgzD6WPORuJQ3eylcv5iR7yVE/F4Se7fOOelH4zhP001X2wHmp6nnbPuv79Ver9La3AqGluRF5mhkOEXwwQElxQThp/FjEJwmlLiqp9Fr/AdKPXdpwkrZtYPq2yC0PAaTccHjr0Y1ERrgkdJkcUln62JhXHXA1Cc/ogISeuPBWFhfQpccGLjSag7iC4MlctseR5URNksQchYRO9yzp4Wp2aZmpKyM/vDGGZ0Ic8Gz4l1CqwEWk1JtVH4s8EbIcYnC2BAzVPDifzrQDtQ10TWA+CTQb1CXYB+Tt2gnh3qzhNWUnClp/K3he8iZHQ+YiyEo/l5QZGaWeRjvUyZxu14E0We4lzYRmrnSFJPNQWOeYsCR+NB4QBMVIWUAS55KRmnTM+kjvnC4MEID/WLHQTzeWt6d+QEwltYAeBLRW/EFfw0hflZd4wd6SSz+h6kfZMPFO9PgiJocTMwQQoZAHbAioGVE8id49pxR+v6VJS9NrbrRbDNEpaWA2UlqIU8rB78OHGM3Je2w/VwElOXrRuKPPirDvEm/n2znrNhYWhHrqIybOupCKZv2RAYnTEnvHbFsPqWuzFRRwm9UhI1bSxNMxAEDeNM6ykoSHqG+k1Iyf4N39xc3nYnB+6gZKUbj/O2/VwTPP4xHUvtiuuzgg7RmNJ2sFStBI4w3OcGHrnVt4dimTNzA8oWrbDQgmlS4OmNBWcLnoKHC9k7aeJQwQMzLvQo5omPff43OIAPwHW5X40nNugTVplHgUQZB0luk6kUZk9AGUrYwrozPBKIRDLwV4vCBjKdyqGwCnwDKxX2L8Mh2dNslyx5hWHIp0Ua5NkMYl7hkU4jnsA8NSyymyi15qCrGPxilXX7wyrDtp41NQJ18AWzSMJNSiWcRivCj/YlmnMGqwU5Nd0AQmlLH4oXDREeEs1xGrRek8WjQd0ogjYiZFlshiYcQqfI6UFGx4vBkym6FUpHJySqaXSp9QQvVCT2O5PmmhHja04GdSNb/VK5uI4RWADsf8geYzqMGMIYnMF3VYdLkll+MpFX0CDiOX59UGAYCHlge3Jen716+NhhppmMd/PbBQt4AtahziXFDN51rrV9+il3/+dj1jcVHgTlqo44x/woxUBKV5QkY7WAgdcvdRcyindQTvMAAHwA+D5ySgBdCY47ASwYCTLQkZ9q2LJJqrgSoFFnFwMd3fKynVKNtIERKAoFktSKeTQ3Ff0Xtnb8kqQ0MTbWxrlXDVJ+zcHd+0uJhrPTiN5abYIdQcczsLwy6vwrHedOH7vm6xH0IJXQPe1rQzbka7E49X+4hfOp+PoJRyW37J3QPcGi3BnmABE+0kOMzyVgjv4PtolFUcXphXTmr0aCGQHlMIEUAG0eCQX4KWWHwXe8DwDiQ9McNoS6DVJw3QidSgO17ZIXqTnuSRJQlV3O85zss0AWjzzm5kJDGxLHSfoquiIko0h1TEPMAjDkKhWk+SclyKn1yQAW0ugE9JT10W2aPLOBmDJZ+lVIYrhIyNVLYQzWu+BKi+prEjtMlFk5LhFH7cAyBmyVkXTAq9TqRCZongXpY2cY1VdKMTaXjm0NOJXi+eQWjN8w4m9Lva51vpeXDOOrliRSXybBvrCSjFMACcCsD2HooC6RU0AmxDl5iDi6aepFZ+sjmBdAOTyiYLKafoP8NEH6biQGiXbU6re/ME/+w1j67TjvUiXDHLCuW1CEBoD2zXZj7xvP/LS/5EtiVtksAqHG9IRWoM0Ph0P1TLFFow5A+UXSgOqUy7IpsExwNfASG6UBYlI7TUNX1yI2BSpH0s3jNPuitvDfv7i+MHN5jDO7jL6j/pw1gFt1bqIyulZFobtrdUDnNj65uu9v/gi3BzGm8upf7H25sqYq2LVHPhhReAUdRS0FSGls9gNS40dL5QDjR+tbmvzBItrsarBQ06ZQ/AGwBfAM6JjHDUEVS1dYV1CDlQoJq16xTdiCaOEeI5lEb1qe3s+6hr20oi7mpsvHxZKgYZbcde6x7LUMEFoqwovkrlBF6fYNAY0wa6Iss3gLWx2g9NfRMQq4NecgceXhSSGxEQahQU1XFzXS6Y/JUwx5F+SYRXmbWXb1bZlnVKl7OhhCCYrw4Cv41lASatSCt7hd9tcBd8ed6vGamgvm5N/kNhJWE3GK7EDt5NN9ZSD/Mg0KLod65ZqfWYGcrVjFXzr9BZr5TUV1XzIe2OQGX4umawg10YM5oEJlCp+9x++sOIs8yQNUtFgaoGtGJIiGlUNA5JODlQrwdI0zSnjnZ8kboryQizBCcLg0mx8cwFuAb9IBNeENBfFeCfuSDsWmR3dSW0F/gqVdUHf9ZsSZJkZ0uQdNwZcv8lXZyARZXc47g6j/7wML/Oxi8PHg//W4IegdU88b7qKCM1SVIJkwgWN+a3/c7W761zki3Rxcuexv37hw6Mo6DXcfhYAAiZmnqRSIeKlpekOi4ETYFt+l8+w9QShkxjvKdAUlHC8V/Y5Hmy02j76MbnNkEMJPv/mFZRspXFBxHZXToDVsws31uC0m2BG0tZ8gHREKwXhi3mJyOwEqFBwAfo8Eq8VcfLq8IpywUUhB+QggBVS+CsCbGFEVdG8TxRaRHGI/D9oaJDfgFfnLEkk65wWEBWfkBgE0CRl1pwpz0jimBwPtjWSPmrMVn1OvD8wKcRfQfu6NLhDFMPjrSjTLxZIUl4/RDuauP5lWq35nVyGcie9QQcYkeVKIx7hyHtNZQTd5kX3Qba3RFj8JiItxwVNPKyov4KNjehFeBiakCk2JMaoSS2bdxSerfhXVHIkX6kL8p/+zkdBNq4F/LrFRRJawPilpA+l8Da2i0muXnx1EZkIhWPV+klXJEpvQSU6aV14TFBYiCJ6nYymthjVCqQATb1R9od1kOogRaRFKk7kzTkjo0Z7sMgSqKGGALx+royllN2pumX1YnfzcZry+NPj/Mlhc4jDZT/86sZvo4L6UoVI2h0J+67NwNgcrr7FIafx392fP9vAzM2h3G+rgRFPi31gCanuhoZGM+gQ5O64zQC/BWREgEJPvGRwA6m6zOdLQ+DSCN9z8wB47tzb7OEz+yEmFRjAevDFiHYNMCxxqCGYWxIOurbOmdm1WEN8AEe7Te23qNR1klPkFnRKiXo40leUKhZFXwFLmWQ+Mn0oZ8CnznMZjxPGjCNulYwPN+sa6J64sYFtFllVl3XmjYbbyJLYkUPvn94fisYylJN39bDuiJWmZo5TTm6/VxliSSQh45P4dniLIofFgSrijWg1IYGrUCAa7LNxF5T9w9EuHwp5OvwRaMUXBXAvUapX8oSss1KvhdTt0MWNnLGoiW8oEPqSsjL7xaMrKUofevGLPwL/cxspLg4iBTBnjUCj4ExoM34kY6Kn/6u/9SF2z7JYbtm+5iOyCaSol1GADKEZFy5YoSrECmGUeRFEmnUMO0MqSSvQRcB4I+YtTZtXAEWW1ct5wCpIxKQ4lA7qWK47YbGydl6yGOdaR3REWwCqSHwg5EgXBQ4VHgJXJfRhn8Zpznc/uNm+6jeHfu39uo9p3XXPO+vsYV8gY64dd8Tv8/joxXlyc7yI60erfTiU7G8+vZs+PT5Kfff+KnfVp9Ngy/p3PY8BQSUQXN4aggHl1hLgtTYKa8Uq3YSjQtpJZojwkeZQywNiB0zTnqaXYj9eY2P+0uxwzun4iRYN6rxmVpAxSrjNqy6IrAQCfcxJ9YrUM8HnmS1GdmnN/RjyiOgGkZIXN64nUOMRaSTmPr4FHAHxvMzflM5hAR8EcXdxl+/vjmEIXUf13yRDtETw0wAUVP0DdKMUb4AagV2Strhi9QL48kzRCAWDSYpr0CogxSD5B73MyvpsOCyNDdLpyQ+IjaZCaR5LiuK1NhhbJVViK1w2CFBasiilNK4psjdCPzlSVkuneZkWnSxh8mIHvCFoqGDI1vIAoDXcUxTGRBPViqH+JqvaKClaFecNpunLglmiOabogsF5Ix6iCKs1uHM8B7A26JxrAAFOoaKsjDWtI8qvSlmhuMH38ZE73uwvPriYx5m7R7g5uW86n/hPCBOaeDPkqUOKHLsFayouRgxxmqEpiIuOkAVdweuANvaBkoq2kDWIwVV/yDGLMvewUjEEzZ/JcNy82d381V3+sjw59h3PZ63vO6f5/HJIj4K0Ygh1WFbxwPOyDz+4Pf9yVW6O05spHvvyo33+q7TaxYtCejflaVyddeeX5+O094/cxZPt4XgIiUMDhMEwx+pC8IdMCWdtCcMIhImH2o0rOu4JG8VYWmAPKiQsbasL0MB1q4iyr0SaCPiNohiEOQkxDEV5Jagk6XHPDEklDRbNv9CKKCRAL2wyiPmIyqBymrCMSqQQQiYIzB333EraKGp8puyqWqNeywK80/a7MWiLFh2wVVht+37oLObCcY8x1iCL+xwd4CFYA/SXWE0A7zkeEthA2JCb8z5JpikZUL+KxjfWKpa3hwisnXNDsWsmEIpFA1NEtWUEahRQHGX4BdQrupJRjEuQyDF5mxnqPOeM4jrM/EVtKsIig3i6wH+FCse1SKGhGAKgzoOAIwBCWIqI2NlpDqixv/W644JQZHPGwmc3BsU6ujCogKjuBcxVEJco5AFakz/4Z79hqBgc44nCsY1RUTKb013FAHCx0y7EzuoQrkJ+nE10CdtrwdPz1h4Fc9PAY6fYySLvhcwYtrhXTFcLT63UhYwiLnoLkLOghQ3kXatww5Mb+wNp+Swkb++9LZDTxF7UV+hl93McHWfgOa5j2QScczwex7MLd/vj7s3BX4f35/6jR2eZ5hxMu+NcP2ic05v7qbr4VfWWv7oOk9t+6Uc3v553w8fb7ryXLF5Q5KyIodTdihU/kf01+y1lejwOUBaKBupeBQDgbMNiHAPCLnHLmo9nBsKKBA4etgNib2nKuuYgu5cZQweoFQHxPHXwIdHQFIP6bIcVNE8kMUHXBCAk7QRiEgD1FSG4LBo/BpIlcEVp9BKm0fr3gTr1VBUAzFLwrcfbsXrOYVWNlLwh+ge5rcROLOJ9pjh5gWbQIue9tOsjdfA6ODbxrVmLNVoLhFmiaqVQdHDKL60/GvnRY00S2feA/E4QSXZ1VlEJXtpjndIspETLi9lSMIV46iaphhLUf5j4oJZC2hu0oKR1GLJrYCfoARScGzRRbCoiJSRA2ExDm6hVoBmBzKKSScFyTeEZnUzyzlrNx3mXjM9pvXiRl2gpxuBKAYudMbQVnpvHHL/32x8a99po1lbjkIEZOhAFhtwrUxycGkTpcRM8y6TltVs2mtYPTQoWFh2CjdwEPRxBdXCEWYMbU+0R9EAhfomahOPXI2vXCkIsuIChXZrCWKQq3FzmfSUtlGqTzTzLTyWY50AaIQZOY7Da0xDcOsRt9KvgeoN1pP82cPi2Grrt+frsvbV/r3+zPl7e+Zu7Q8/u5XY3VjdPz7Er6Xlc+/h46tJ6mD70nrZdwUkARqtFBcn8xf9HARcYl20Ch/XPat0JOVupITUDkiy+NGJUlA6SRkDlpCNT/zXExbxsDrxYzB8HU3h2PPuHwWOmXxMenMFU9doGK8zAoCiVui/hDQk4IIVwY3+InULqQbKLpnlr9bss8tDZmFmkvh9gW9n5c+B2W+ZemKvIrImEzS6NuO8BhG8HQ+lsmo6G20xigpfiEmcq/arTcNSBcrksBfZ9dKqqKnI66NMsLATIvwe8DN/B2AgTvRDrnGxWtndWrEwSpBTuk+sJGitIrrteoHfGCnVeQRTiRetRV8F7bFGSm8liw3ISYX6xgAWlQ+j6ZudaWlfUKVoTldXTFK4RkF6gEcaIQV1y2ixpyB0460UrReKFtW9BTBEG9KWsvBMc1UIGSxLdLPWsYmOT9XXGWClajtGyIdA4+vry+ZbUJYayebJOeQ5ZWzwNG7a6Q5Yszys/EKsp1VhxPjZvQvjNDc8z32hYnTfVSsFldE0F05E6q46txm+R5BimFUQF/PTWkIjzlDCpIifRfhKnJwJhCszL+ckWBXD11+fR5dd/ef33L58cOOboh+FwHG/30+b5Kn9nqFlYnPx9nvcvmKiuAFXkABDQD3LzwETwujXBgMcMm/EwSxSpQXt9DXQyXWmpGf2iUcxEmyHD1gdFnWyWDAezSiLhZF5Kvbxi1MrbAcmmR4m5HoCZRf1Z8fXIcZYSDj2UUowNK/IGujFQ9MwLckld7fVZNx2k/QrkgxoraeiBJwtoQ9zbPKYaaNRwr76MVmMdtherGppFgfMky+a7EMo+DnF9wbDuIJcOHiZNip+LqpLKC2n63iTxlEODm7b41U88HiZOoiPjfRnWzZqKQONiqFszIeU1BXUtYMbVVUnJKLuQO6LHNE208gXf1NQLrQiQkYEz81q8hDFNVAeQ3FmQvQBqAi5ekRwn5iwqGG8hEufCUbljCISLk8nSkqMo4t7mEjjumhAD4cQ0e7eIVYvUIsWlae+MxLOYkACbSH4rOC0xU5hSDRajO1oL05DKK6nT0Aqh3qDoCMQuQ7ON3fufpX191KNPh+yTlieyEMBajQBkECk+0v+JILREc6rsz2eVxCwkkdHKiIzJKWbydECpFypgEcpP0BZZBR002MSDyaZbFovG3vRxwQUtupBYYucblp8UhuNjH1lxWAqyGYXwCD2TuoaHaXrzxe34Zn501fVdv133HTWau7F+6rf79KLH6o/1YV3EZUYTVM4NmVpPTUIFMIHXj5arNRCHf4QiN2TSMkMMoOchwak7vijDFigDX6r0oJBZFB5mQSEPDAavKnf1TI7HJE0VBUiwtmFzT0cEMaIXmkiecS/kw1GbKwodgDpYz3/9m6py9QuGwOALOy6WOXTPBLa2yorixg5lMNq4adSLspv2Myyv9gmixJnhw7EHUA4WNU7BR6QRpH4u9+LQe8Mo0+Izrtcqlb1SYYrxg3TAOP+LVXqkUlGEyeEVXvbVP9WbRQaGjY1fZ+UchpYAJjKybkUVRLh41krk8JQDMkseT4FuM0k0gCJvi3+5gowTgQdtdE2nonJaRtQg2HtFJxFrC4Oox2PiUC72Yh1CB56s5EbQyLdSGETS4epCs1YOoHNWhrOFJgJea7OBFXkaPB24SogT2kJZ4T1LbCIYcPRye8yyt7Yvp42px/O6R4KW56RpKHTeMDNheVgiIPCtoOleyUGo7FohXZ6WF3kgfJPKJeixhQPRYrZsZun1598VUUThfyuhKVk4Bjco9CXn7ZE4AzrYOpjhcKKWpWMm+DW4GmAN5JHY9p5tVqt67Y+68cN4vZ53T9z1Wdpdlv7JCkmKCdtzU7u48aKDHlD50g+lnSGyApGSNZPWkEjbYQCUx7ypfsAoAtPelCeFlEqxbVk9RlilyOCVqSwoBs9Ss3iNcxDaTNzXKrI2NIqKNSc8BhEl6WGAhhxHPUl6IXlnU+JpdGr0qGpGKNr2qrFV0x9jABnC+bAFGt50yvPdHDax2j5F+jkFQ+2YfTjHI/RNpGNOmclIZ6iCUSSuRxyHEe11qfFaOq5ObLeVF2VleAuREUmwRF4BHQ+HCspCDeIWzDVAyE77MV1DrItyWcVxO1AC0Q7lpQRMn8uNew5dTTzQlDfqEBufgJwo7QckuXiyRXlkSqGQ0yGObUxsgp02fgvXHAmvWhAFUjWF1wajIIVh5LPGLHPSwwzzipWXiT7qbh3rEoJfxV5H6iLIVaPeMkVW3/utFxzeFdRcxVdw4OekHIfksBEiENDSytbA+/l6SuPmg3Wit9DuIi/7AAI6OCeaTgo0QyySJFPtEsN7zMfnZVXVfSv+wcYhaXdFjZpKNuPIeZtGx1Uww240T9TSLCamLqoeoEdSqKiy2XhaIgHMzoe6/5X9ihRDWibFzDmrRegcJFri/rIrK+Z1sEpyZlOLMp9rTZ31m16Jf6S7KLVzb6VuamYiCdqiHFH+rPkoMsLVTMCsGxYpgRI3eUmc7wVtleCcbVm/jkzLdsFyFIp4JVBnUptQDSJxK3kxMWe8hiFDmI6pnhnh/XJYp8eAn+kszGyxbjqfZmYLCCLVMuIjn+FZvTxIoIHmFTgkE3vB6QV4jLNHTIWpTF+N4VEndpmxTrI42jaIyCsB3goEOdWTOaw6chJjzhqI1etEBxyDJBlxAeBYoONyIkoRsRCEsXyWeraVSXU7JWRm6U6ud9Mr6+dCXNCaw3htMfamBCGdY+nEmNbrBGORnBk2AHuySPJbHEMBZguAED26HeEkNJURvFJ0coLmOl6MLwB4bDw9VvSfNkUFLCl3tsswvdBpxUaEQ9W6ZWeSHih0QsoWj4yJr5KB2jwup3M9VO3Da/6uwKVxmlFV/P7vfBSUIVlEYlkqZNLWVLQ0UNoDg1hHf+23t/72610JrkvR2zg2k+62Hj1o3cOCBN6WOm4TomJey/OwESxNKamfRDo8L97QPgk9YNpDkHLYgt2AukPH8j0A5GgTQL1fDQGehNEy+x7czRIXNC7EQR1ZQB2+oHqy9XProTUkjibTeEnogDXwbhCoG9hEVDhJcT1h5OPWEMxHkZqUoadBlHx9J4QmKWOzUaaE2kpXkul00tAju3+Ce9SCcWgeHiiJTUKjAhxX2RgulYIdWfMOtymSNfVDB4omTEOmCDEoyKSimbesBBe91PslzVCqkYO6PFE6pXsm83BjHBs8BR4PEYAkSjyixVAMm/BaTnD1kr+Y5jM/bDuOBCMAb452KbSRpe6FsCZWhj0fzbgFiOl5Ayg3GiAJeR1OhymcYRAT64lNDu+N9ZyOWevpAFslJ3LcXo7NEySwdVhSZWWLh6hrNXEiDHCmsBbewKUY+O9OOag204GHc/D8G/YE/RCSHRnObwibiwC/5LwUnf7ZGLyKxip7nzVLtYxrKJ5VkzGtHrcj4yl9G15fRDBWwTo+7CADYMKj1gRVWYyxQpEtlR9r9Gz0zNIi0/h9YFhB/JjgPuAE2zwomWAsnTdOKiD12ecpZn/RuSwxfyeD7ZQuIN0MXuXWxFJm7rxGs4XGULx1EGh0Ekaara33i6bceZRcL+ikZIVsnTItjBBIQQzrWhTtQRHKD0rWQCYs5bQlqx+khk/CnBC0CmMdG9hSvKSAjRQmd0q29FbKqaGQSpswLUA1oK2kgLMHqjp04HBTXoUQsZtFTwo0fe68maeCz3WLpr8YpBYjdN8YGH0QhqGMpaMKQERqicQH+SCCSjKCCaOo2Ojw9UDNnbNT0oqgFWQaURQKLxoecCPSALzadi6rSVpoHgUlr+KyCRBkswhNG4YR6K1W6248zjTYysn4a61SZSDrYAhmLvOFr+Z5XcIq8jOlvI+Jk0W47N6KaFgErjyAtyWq3JivF4+EvntUTqVsF1y1GmL1uPCK5h4v0LXkLLK8vOczuRCuG84kYlcvviNPkDl8c6KqrFIDkvgk8XNeMgsBdwLT9KHQHVR1q8aGUFv3AcG6g2F1rnG/uUme8XWOZBFXI2OF20ANCnkGwljOB5FqOOP3zzPU5QP0dkpe2BInlbRsk4SCwH/sofOS6e5cM7heShZCQlhWNjtqXANTJEpbmzIoYbwowkJPgFlmPtlO+cetC0yKsryPBRvq3OwU4i9CNBU4k9+dpslLwVWpbkGtuSZ61pSDPWxJVlaGjhQsQKEaYjP56gCx51BQsD4SnQTH6QlHyPMsxF+nIl8o52FLSZ+JV05TNinbNmFU+sDZafAqBkiUFLAxslnqYEhtZiZ6fTx9H7QWI02aqChHLQbzZSj5iGeIjwcM/qKnw5ZaC9VcoGFOg/Kx2YgPazxsYVHhnckwTQozRwi6ym9RYstAj9BH2Pd2rLDMO4+Wns4qxxeWV2amEUCEANIRaI5blEEKRFqsSohSJm6ThTRFrBIt0FhSxJgZYREjVx0lUEr0VwxOQxLpggic6K1WMX1Rw3KXVqUaOAQgXHdzQKPmUUZVQ5iFwSCP/RkhGM9HXQNJgbiKHgeAXPUp1qtZbTqUVhiSZ1FN1WIGLt4TO4T6ivE0O+48q285DFKNxfbv+44JE9mmPc2MsgGxoHR76HDcIIBRf6t+E1CDfqh2M0p5WWDElkBBoodTOaVcCPmWY17+RC9nEOwQZEXFtB84iPPIDXU2JQ8P9gifU3aq4yI9gLOE1TwnMRUL5wsY6QI6AkA00j9jMtYXHdqMmAWdQEuZ3/2ND+Cb4T9Bs8xSZZAcT88qA0ln3faD1TxO/Yd9dx7TNIUcldobwJuYVc9E6noKhyF9JfciE7OFA11EbhxNqhr7KfIlI1HFomt1s9MxCUWJrFkyQcH+tLmtOHBVJL+DIbbk3HMnGm2RKWHXyaBmBom8tSUqvIp9kBivIfBeI2FjwamDhIa3Y6CkQCaNu0+CMLw1JPKqEVx/ROVwxaFwkfUpwJ1ih2VNmQGyEETSafWHaz0AL5CSAGNmIqVok0O+Tiigc4mi7M61+VXUCLyAC+IRLCTxqNLelEVOU1NCh/DBHorirKCAkZVnHimd22p/pXLEeFDHGRBOnQWePWIZDvllqor19GID1GWvyRTndICHax5H13kz532eLykEFhfCCQuyh6iqA4ZhccxI6FK18kAYZE4HK2eNHGuABiWVqKDkAy/NLKbN4kUKUWZeodvGSUwUlDdAIYNOKtXKBsd6zCwVyMnawgdGl4yCg3ql9yjPOfhdYK+Sg/PVzvXgJZmoNmKVeLfATLC5FHIpugsbjKT0TqDyKTXshf6KNVkOEOELQouHLQ5GP5QUAdGMjin1igVJqqiV6AJeOd+FZEtMG0a2YYwcLLJ3LaAjl/n93/0IDs1LV7SscrEJBQ6QakY0GO+K/3Q+1CN4W8rBsSygtBAra6MR6qqR7jn5N3Jdo1lruGg9Olm5f95kTj0ObTG5DzITtMtFO1HqDnD+nTcAS/ywbnR9ukRNwDtYBITLLrp1GMcR1QfKDTlyRg7SRZYhZVDZaIoE+hyzPIYifEhy1KFl5hK6w+2DFS3y3mxp9ZDU352OM77LZOiC4ZTM9Y9F5l/RXdDUX6iqK5u3XmH9Zr2vavKkgFg4lUDtHAwm0ZYErVn4mU7pdTLQSfevIDXF1X3Pv475oCxmxEJ0CKIRd9P3O0owyfFKCkYAP8yTIrs8WUBLz0R817iVzsMqonhHHpFjuiKsfSlESt2ZZ+3V66m2r97peJhw/XUz5GP2N3nauM3lCuVIKb0TgSug1qnZilAcpPNWFB8ZGeyk5TsKh0DwGj14tFA9+w/wP0HIqGtSjWwnNA5pPrI6NbYKVFmKisMw0d9hY4fOJNtbhxkcG5Bir+Mz6F7MygdxrpldmrQ3sxERNgan3lqLp5UELaMsGFXm6viCmQBo4ZIrxdgb2vmbG1GDN4lqn1nPCWfK4r1AqNQOeRkNbbwHr7I2FjjLeYhAXTwY/1LkKegYJxQofv+3P3IKdjjV1YTtFxyOv8OD3RWPPwt+HYsKdDUZCikVOwyL51qVa2GwoueNGu4kKeMmLPaKHQ6AQE5QqrNuA6daJc4Vc4BaISA/k5NwPrmFuCBV0f7B0hgSlNpE6Pk7lUYEcUaaeBfCUgCJMFxaek01J8ffkTmN8FcgvLFyPJmJkpTJzemGEwhAilxULwNsnEAy0ptlSKXYNA0nrQxk9Fdklevx+O4v/fqUx3k+IjcJrEiLjA/5l5WNKW6fUH71IHMJ2qICeDJ7ivO4yO3BVJHMooXkWMLU5QWbURsDUfSpdkorRJCaCtw2QLESs/ZkxZQYTHgQW0POKQJUa6RvQ/vmtCMalEvlBhG3oA+GPFq2C3Z+v+3KyxrLufgIpjPUkFnlIoQUXT+3xlMwE46TuzQWp5IpTLLzAHoEITIWRZHOpHpV4OviCVoTNeLToOOOiVqoYgFRO4eIU8Ycq3rZE7kWGTqI+i8SEjLHnEJiIrwoGjGKxLs9t4EU8Mpww8zflokPQfIGgrq4hgtVQhOZ4fcP6IsGHRfMXqs8eCeKekDri0me5WLd0TZgQfInVK6x0jrdh0kqgjLB3aIgIJgX+lWleoDpJMKItmgjSAxR7Kyx4iiD7iAvgNEjXAlGNqRxL9OqSY7my7QQLYMPAXDjdQAkebwsu7Co7ppTGW+ngoSihJ9BvNQpLEW0cb0AQ6hrEBMKPkipw7KmSAYFCNCZd/NUQPJkhAJoloLcXJKT7IZRJ9RrMDtX0jHt7vZavqR63BAwjgyJqMmlZpsOsBB7Xm16EcNU/K7+OjMb5TvczlKk/MFvWG+qfnM6JBFW1knaaAuPIFIk/91f/I1//k/+p//m9/+H//J3/rHL3X/44R/X1QMWw35MhgwScAOJEoL5Av864ziIvJykzwwbOcbXinAUhCgbQAe3ATbog1lve655kbuObNqc0vEyczWdbPFGAkhMeTeyMUF1FHnlqGLtCI0z52ggfAK5WJ8NNZIynyTAOQSa52IdjpzPdmEV5y+nMPvjtkYcPUWCPNyhGuusKkX1RgbuXgJjYDxKOQrxFzNjBYXMNvqMnR2AziB6flyFFIU14MSBA+0E4yXTG7nMV22i5JU6l6G+7fEwb856fkPyQnSpKr9jeB9wydW686rrgnFhdTODaFafzvEw0RQlL0kWJhYkHsPlnLZemEym/A0mcIHDCCJoJYPvI1PqxCqJHhlKIgpB6okTQLOLckg1akEDQzC5CA6U0J1T2KwD3yyLjAQ1ZWlLzEqk4rpE/bt6HaJAlqKcXh+/+5svBGUsIh0HJD9r6yP8SYfamSjeNZED3prSqD2BYeSlRqA3JiQLiSCcpHsQG4g9oCiPbl4L1w3c6RTAS9KkIoigjIHyJuSIrnHPo24deCKCz0I5N4MLE2USdea6QRYGOUUoXJYGjI1LlbFmStBHV63JPxCQD01Lry1vjEn3HJ+ThyymFSdkKJAhoDSShaqq8iBFvkk2pT7adYfcBDgRKwhXkx2+/0v/+T/5x//jxdnjaqT++I//5N//27/4h7/xuz/67E9r2EPn3HHnLY+H4jKfQxnLLKmX7NjkHwQ3gb2rW4e7bQifWp/19QRm5aOBl0jFweIE/cnobSRjFzSGMngOLyCLxuVFqUjqsC8rttCbMIkX8NZ0oJrguJ+xkjVBRtQA/0H8eBKS99j0sfNaYxEWaNnncp2nc1o90CwpTesCOBCiUiDUSdpvPTFjfbUpx/1UDbGAhrR0YHsE3OzAz4K7prlOqmgL+gdiAGFNEAxwpMFfz9o/IHPYtE9WOuyQhXGRL4jucKmXcdzPUqvpJBhk8kpESg7tCgjOSO2bjapDdsJoHR0ltqGoFcCQBUbK4FFgQ61PQBjtXqhzbFBwI8VZz2aUYdcW/MJz5FIUSZC0g1179CIGJz/BaTWSBAAZCkHUabXCMccxHBxkTo05iKa6GcYgFmK6Sw4JdrXisqx77c2teZU3bV0Cqlmjqh1yPiGxpE3nnDwjeIaKCDdAMUkkWH2BfTIX1zmkBDIF/1/3hBhpJzx9AeBtbisxHsjH1vNpFAFVsA15tgBVWyg5KKWTichaWo44jFedMLA6tPWELFdU9R8KHqUHnWAmbCysFRzdPMrw7p7JAWDVoziwLETURwKpNtxmByBDEnhn6uzZ6oY9GZT3Lz924/rq6uoP//AP/+RP/uTjjz/+vd/5/d/8z/6Lvut++tUn8zwz75wrWYwoQQJcOTjMzmU4XBhtwYH2wayxNvoJcQTmc9bLINSfmz8GelvKWVBJ5Qo0/ZSi1MOscRDEUkRXCzgUUgAsSD2TeZYcCuMY6q9szgfkO1L4Q+kgU4hxPM71FyPjREmYFmRrqo3rOO8zB1bqkb5Oo8/xrMO9MA+r4BgjVATNGCFz0kiTAlueqSHAcPEaL/w/VZ1pj27XcZ3PPuM79HAHzpQi2ZJNJVRsC5JjO3IM5EN+g3+pPxsGDCTI4MAIDDuWYYoURVLicG8P73TGVK2n9mlGIKjLvt1vn2Hv2lWr1lolAC7nTVOeGyQQbbR/A/Db171ZlOEYy5Gz2sw/YoipOWn1sSmEYSEtcqSvWOH8bECmLv6UycB4QggoyAaNSYCDCG7Om4sxPCuRJUG7TYF4VE/Y4jphQGu9bYVIZo+DYnXf58alqSTvXtmXuUZRd1WhJHa7Mj9QWvRYuRXu8YlaPg9MmQHd6V34phDJZs40TLTxGkRQ0ZFnR3sJYtmo0xrmJY9mWBu04T8ZjIEn88CoJqt1IBd9x2L1nCqY17TiPHA6HLRWTycF6TzTTKqnD0U1RnLlSza8GZKey5p4sceys2A+Ljwhf7IbXHUkxTrrnAuiTuRRMv5nfprRVqy9DMbehmgr88Wy2taTc3jDDkmUWQNQROHAYwU7WBEHEm+3GaliHataCeYx3CJBVFKWFTnoa3XqtwQz64Pf+cP/9Cf/5YsvvrCv/OVf/uWHH3642Wzauvvwhz/9d7/7x1+//vKrV58HBi9UG1esRsUs/XhvfZThEGB/axmNpy1lSTbnx/sctn/kvxpoHEQqS3mAiv0hT1E8+oYRB5uTE3mpjgTHzpnG3HZxANjqt++HX+I4EW4BRVrRmSjJ6zBKBcVYu1olUzmqFTUvSbs4StvrZv7NkKZiep5E2kurbobVS2t/PVbJ1vG9AUxQGyeU57bGlHyNAUFPjnVSPIJ7MvcM1VstRjuEHkAf9uF4mTj8dBwmuCxkzfYIGcdAesvFWCAYxyUjj4HWE4mmPB44vPBVMVGeZ2hiwUvHC0aRgZXF09cpAY4j0x+fRsZRPzZyzpqz9A82smCBKmANrXOP0cK8MPAgXwJcE2ztSVyd10xOz6nsZgguYT2UvRPWpJsuYZGVSfaPrZkom5pIFQkn1Yd/9r4yrnl9u3NMiIvi2X93KArBa5YQUtTZP58CuA4NWmzr7ABTZPkR/KBcvkVoKLOhGm0LOwoyJK+/KtbWQ8KZTvBB1utWKfRiKRrVfDKxG+GVnW8Ee7kUFQANdRxcXomhGV75ChxBPq+5QpwRCY6nnLkTvGKAa4xTFKvmlYES8pckBeJMuZTHLkR8Jkn240spW8qOz85g0IHv3yk/OLsFsnH7ubeff+/9N3/wve997yc/+cmLFy/s3i+XS13XTdPcXD3/6Yd/cb154x9/+d+LFCWn1ybD1GovsVY8CqSUAVTxUbPKNzcNfKOCSiA2XnUntX7csh7CEFWPh3vnhTlNNMx5y5hmBtEp2qYFI/liM8M/ouayp0TO4nJl3T7fZmWpbezLeajCqwRov6DPgC7aj406trTPN7ubylMabhcR36oy5phZguyMUIBMhAHn0xhJxJJxyUDWyrVDGogvDXuhkCzXpisthXNQXzdYZviZptRm21zc6g+2bRXmLZktCbBAPU7/frOtl7wC+Sh7Gn6R/z+tmrBSphA2s5/FQcW0UeXIeWJPjeRE2T1xzsxxGuurq12RlR7r4ZrbG8DhBamco5Dqk2imSXwzFUmRdcEecKfsThHQWBD3anZTuOnHMsiu8/gCKetXPydSEH8valVnJ7hCYKs/Q3hYSOfLLA2n0K3CmzWBN02RyOHNFOUS9gog2YvAIy4CmyFCWBX9xwQ2UeKalPJ4H6R/5dNw40xv5XEzJSkLVvTF1vdMlekIKYYghaCkJBElTvF5+F5isC1OI4VIyKElRonDJ/KvcV49vKir0ZqG8CrRu3VbQUQnmRMQnGNZRIVJUMo2DFOeSrDZtauHAWNBhXpwLrlHSrTMsLsrOSE917PPeb59vytvDofD1dXVdrt9eHgYdHhZ2Prkk0/+6q/+6u///v/cDZ+uLBiQRNiVPHbl3r6YLLeid+k9ivEJrfOSbVq85FFZEX51Ez5TIbfIWUaIWrhNDc4smXKISNhihOUveHLBroLTdBFWFe7+aibYTmO6Z6U2XKXVT6uHqRCV7ID0qKdu1/jvqgMMdZLHwklWzP0y3099MZf7GqDHQ1vvC9HiWifhjn3+7qpF4jeOMamYdN6bd20M9svyoDlQ6xTOM6Uc35d86AKQ2SUFJltBXpmrPPTUor+Ln4Frv9VcfiJP5LOBlj+HwSppsqstg2FfEobABNnGQIGYN6xOBOlbM/5I4qDC4VJvT2PK+kFH8S0nokcf2m8Sg1BKWRi0sgC53mqpUjNmmDJ5itRJsvyw6FqtEJ+o/JNXvnUdLQWUkhhzplw6rXKUpP5mphNGZkCL07fSh3/6XriUqe2qfRvoGuETqCKc/xs60dJY1lm8llKmbs7kZRopsE58IQ1Z/JoVy+eA0oOHksK/ETpAsfJQSgY35cRHB04qoQWKiinYJWWJ8oy1+Ur8JRGquzB5UAEfgB9yMxo30JosHYO4MGdhbVAZ0tqLKBD0r2p+sjzRnWaCMhXuolJi/JYXSgzs0ZbzzelTWhlDW8JFiBM3TMES/id2MdtdkxU/lLrFuy+//94bv2t//eWXX97d3XG733zzzd/+7d/+zd/8zevXry0pO5SfdV19Pg6iXARhkiiQa4FIwjMtK1u246ItqieYQllGWdo0MCcmwrdcQPNQFDXmq0DZGetAuVRRmK+yXiq4lXCE6TCVWtWWa1HjWeEl+Jpx3qiojMGrddWfRqXHifSKihVufdGk8itLWYv6zQagY3SRczUJ5fE/bwRNSOcIslGHu3E9CZHRuFPPu0eJNOz2PSCm4nwYtletc0ouU7CLg08bF5CtMuKy4QlSK1xOgydcQjmo7JQCQ9CLxy7wmNYX5D7MfMJqjfZuzFW2pyE+Bzz1lNuaLq5uo8bk20AwRafIpUxmt1T5K6x2PoUaC4XcJNkWps+4SoCTlGLV4Kg1fEt9Ad3a45dQuap+CprRauRNxeyPZRWxRJs4V/dY4KfoBmR6ar0yxovqx3/2foztVpsgy9CWMlOrsHFZsp0mKZiWYxE0k9DTeCu0yq0iyH5arOElqKaMsjaBeSmtmJS/SD/qM7VyAeLRuRp9/T5A4iKmAEQUSPl4IalWtzGb5z9N6MrGhnoK9jpt5YXIQIkS696DdVuuuzRzslPEOL3XVmkOxknQuKC8e2zNhugAZDRcuHcYehSkKzBHz0H7s4wPzOJ+138oVNGnC3KAYsrbz7//3bd/T3vbws30m9/85p//+Z//+q//2v6gpoftzPFh/oz+QNtGq25Qe6iUW4DXceOyTuJBa5IXbqTSpMz5HyGpQ5i2pXU8uB6s7X9/caQDorN1G0/cLIEa3BcYHckkKCpHxlwGDrIkhM5e5z7jemH0GZ1FIecsW4OebpyiUes82znILjk6KF+2v72by7447+xnaxZtu61JD5XV+luYhBlnryFPhxXLal5W8Ncwk4isu1CrwYPLdt/ioGA/u7/uen9HYkvgVeDWpr4mLALaFy+n0X57ypbia11GaaYj1t97L02FfY7do0VGe6ore3O18UEhj6w90tis9kdYKpuHOWQ6alDaDm1aFWvy6knKbcucxayW1q5yZwUKME15UmeVW+0QtkW/CLlezuOy/rEE2/XFsL1uvRoblux5GcYhvW/wRA9aRg6Zyof8aPTUrw5Zbgw0ACNGTMab8lr1Rz97J+SDORzaowyWfSbdp2ycSG88JHWBXpVFzhfKMpOGczWEBo18dQ7VblTjcxbK4p1WhDggojiUpWmao9uSwl2A0ibl8a7+II4jyfO3Td8V2minZJMD5ZlwTMBoIfhgIAc7YVknnWSKf6MzbS0Zwr6iCFa9nDQSOXy2gguBcVliRBkoT6ZEeoSyRVxmD3gRIByuUsbqZ3t/CWbTk8t1ZnjZ9b/74vtvXH/Hqqy+75umsXrw448/Ph6PS57Qsdtv7qZP5pwMZjprRXRecgu10wajN8pRT6qyu27tUbB7bWd6mjaHwALcYXfVAKgVwgRorslpN1k0oe0AgyYeL0UZpOdUsqZd+6IwR83iDLW67E8DFV8QVsonx04ZNuTHu4QBdBUvInjVxD4LcNNlSY/T1C0Y5Lvw5TyOGTnKzfsSe7UW4+OyIK0gOgN10QLa7BsnlHhGExfGyUp3lYLAIr6+mCjeK0TUx9HiTvWsap5Vk62vcWpumrIr52auOgtn3oucxyfXKvjuZKDhKbREjxinWdZ2t6nId6A6ElvH3GClAY0LRZFrKKJY9lDLrTKht9GGzqBq+a05RpjMOKrYT6GRSkFDo96SgG+9/myXUjwNNCzzE0b9UqzWV0BK2fBLifboOvnMHeP6gZjGPF4gJGUWQ37vJ2+nbFvOqTUo24Stiz4gstO5WGE2YrMfdEVk18B4iNhA3VYhQngMZk5z05TRSVztiwO0DqsAHhbxKGZza3e13tJaedUFvYIWzDLg3rAFIjepsvGxRCrJhS/Cy7JJnp88yi+eyBBljjW0KiZ/FNPKKhAlwnsu9oHwD/TahNQqHRCzJgpbBIBFNqW0b9ts69UaIUwXligVueb1WIMEZ3djUUDnR1iD/vabT9954/u3Vy/HkfxlsdzKakPH79v25z//+U9/+rN//OX/uIwnuzxANy36yNFSNkQsRH3yteKNP7h1MfvTXo3fyBC6CqI8gcZWVe+wVIN1geJdzUJXlWHp2xiMgSkYuVvxubIbtbhsMvVv9YHJJW9jWrQwQrXjwdQfu7PSa85RCdnCs4kek0CfiXNiDNKcN0ZB4sevJncrvbZVUXgIHqNnKheKedW9O17mnK+wbHSDvcyVwbcgvDSENpB1Ktcr6K4C/G/2nr71yrmUQUMiDUTfkpL9fjfa8fLr81SMb/3Oy+vb/auvXo1XU70080XA4jxnVTzRvFKrfaJKwGBnDlISJsvR7PbcDSGdPkTFs2wVgi4vitlxsFUXDUF9TuY2JxTgddjkJ5YK7DCeABpPkLXQvZRx6vs51EbPJOggjG7T0vLN0j+VtHST5HNp0byK4kOz1ISfzhnhFT0t64VbkelkVBX2HmGu98FP3+EQ47+Bzebs0Bw1qhbZFBBsKDa8ih7CArHIAulUhDvaUxNQ2a9SLUFbYo2kaKuvUy0zAyrlNqISJcdK9ETWibgqBtfhgwnDaXwO6ASTbXoGMc04YzxVu7pUy4qbps5ei35SjUMuAwXfuJ4Gy4EiQIowz2yrlhImYzdVAwXEE4cyBGLr4PsShgdbHdMlqx9HnJWSb8sB0wK1Pzx+aVcgN5lkjuz4txO7prVX5JXgPH7njd+3JMvSK/vy559/fjqd7NM/+OCDH//4x/Z7P/78F1+++qxkVMQSQ4kA4WdxqVx810+2mnuZ2MGuRKVxOQ0aUEoNmzPlPBM7E8f8fVGJw1FmBkRIkV0VOIv/6aWNJ4YiB7DgGv06rJ8dp8/2AzRhYCo5JL9pMkEP6JCenZN7OeqqrHUFspQKolCG2M2WN3wxLJe5f2O5fn9X2P6yf6o5WTg4u1FLvfH3dX4YtCw9AAEY5XkZajjmOU+oVYhBNLLt0W2uWntQMi9V+6wM2rOyOX+wS07n2k1z/+lj8dnY/Gqa7sbDV6fh1Vz903n61dhWzdyGK9EkKajkOJ5ol8VK4i+A7RsBKQBtOatdcq/NL3WzayWHCFp1kZFK5DWIIWm/erNFORG0MlY586hB6+1KLLPeXndBOwDlGDFcDpphyu7nK/aKhozG8WonGd8gp8DVQSTA0AWsKQioRaKNjlYPmceSKfvzKkSxeOee7qt7gQw0oDKXVCiBmbWh/yKQsYJCAR8sypj1aj8LrwR3JwiKyAWqFfZPROga18qok0schVI2zQm0NeX4VWRPy9wUJhAV4iimTnRENCX8vEjtyYfcqNVIagrxN2Newd6wtN9x3GwSFo5imZr/5BRTLBcdyFWeITS67DkIDRzdTRc9JvsDod+fwAqrF08efiRuc8wKRd2GZ3wqYhJ1JJJ+lNEFF4Z9uhz+7Xf/ZLu1I96qlfHrr7+2kvD58+c/+MEPbm9vLXj98rN/+uru1wDqtrx8woKqGMrLQaXN6rQjjHYeIEz5kIWSarfKlu2oF1dTcBYGvQV4AM5d8BmMWVmm1e/rdcpFh2pD1U0zDGaEAbT/hO7PHqE8//LXVKr3j7aR80Bchzp71PiqhQRPsu2H0GlsBKrS3q1O03yauxdtl+r92/v+1/bXU7lPb33v5bAdhnaYu7nsfYEEDKKzUrlD4aIZL4L8VaKFsP8cM42oVOOCGg0Cj6cM6AryGGT7WXBSUTrdbLaY0+6c2rHcHMvqsd2X5S419Yv2VOTeQsgzmZSj0RJTyKFIDlwJgDyjDiEXCX67rdfkC4SB2a5CnUpofc6eP0/ikYbTCwa/5Dv8uhWlWgvSUGKklHKTSnhrgvGvEC12MVTSb9n7tbIVwXf3CaJSBCCJQw8ftukhf4p2HLkIfRtsdmgDrpimsz2cOJrt5XCSVQfdO9+hq6Q8DnFfeIAwfoP8Hz6U7F/D+xxqbJEdbbxcl3NQoGhK83wdjHmAh72SfsytpafBVZwPtZDpcJ6OBvOyDoYkSF9OU+5axpkzStYv0+fQuLHf8GkLZlOJWFfUpNzRJzq1qMCUpNAi0OC2YrtrzsexzG3E0XsiBX33Oo+l43C2RaZaL2a7Ex24EvHrKk6zOlipJZNmEIVNQ4BKFBrK7BzDcgZwMabD+PjJR1W363ZXlmF99dVX2xfLWy/e70+Pn/3f//UvH//vY3EqJa4GUA8YKENCvH7oIDhAoUMK+6oqnbX/6eWDXyzhugVnZ6IiYKUhiANDXG9KZVTJqMdViw8Z7XIO1/DcJx3L7L2Vsjkahbk0MbGHg0GW83G7HIsscIYtV7Ws4fQ4rCi1a5Ie5uL12Dxclb+6P1rZ+gtp8O7n7rP08Kv78l+ncV9btstmBgqYYq6UvybHGaSfp9fuKJskX/b9g/LoFc3s5cxBkWh/OB8G50yoAUqnwg+JNKe2fKvc2k9958X2cOl3m+a8K5adr9+2Q8BUZd374gRjMelClihhNo3LSIjEOUAbTxNwkN6bczRlTzTPKIunOSzB/5xj1WEAn0TSXoqVpZQ4UWDSA3hj8To4QTcUThUSgtrzDPtOhwLLSMCVwaScxAT466jleZT+yd+gOrAhtREWESaIpETZYyG4U4guaH264ceP/+P7KTuLBu9ePYi16YZWqM6AS8qDfbpNBcFktRItA3siAwzfRdAxdjtpf/i9yopPNGvqHRkYaJyB9wu0sVes1DLwIjhWc1jW5QGoczYUJK1r5Ja3fMv0B8Vy7psswT1pmcgUlYh9s62zYAAFYzAsKGnE0qtajdYwjRLGIDjfsdvFMggywUy/8isfmB+VqVj2bbRLaLqpYzU/RfZs8y54gg60r6G8KxYItPen3+4ebb+d9y/f/bu/+7u786df9v+SXt+9+ugX8/nRHsOr6rVFcK/I0LJMs0qwAASXPOyryPMbFX8rufeV2HJZzsIwLsn3/Jvt+YSsqgiEe8p5Jat8FbVmgogSNOgjSpY9kz1PEFBFf6/RA9XSUTucFCZTgBoM75NXp1Iz8noaLILY/K/o3kjXnZT9+dlWbarpN+NVZ0do/8bVvnxol2N/+ayvvpqGQ/NyqLupelUOzbbqpBMkyCIXE2zkeJaHgNaxc5YNCnkyL9xQITA0mV0F+SjTj0tI86scoryuXh/O+7G6P/ZvP99/c3+6XBWnZcrQWBn7C2F8XW6v2yUb1wkTKEJNGSqxtNnWgE37245MJzR3KBAsWg3eoM9K7NXBaZmza/MSBRB9tGL1mRB9d4lpRtLYMmGM1VjLVtCCrC/dgE3kJUcPoXLgLCBm6GZKbvzp1dEqreoyD91xs8Mn4MhVUAvNrpFutUt2amf8OtbcUN5ZhvVukR1Ha3/fNQ1B7KtWuD1C5rIaMEWFmSJpjHqwzNaaT7xQxeM8wKqAHFjRjdbx7hpxCd/sD46bokcfMQMKI6SKKUzZsYuaMA90ie1HEZFdLMIPBMMzx9G9aU18DESolpywLIOzezoMtQSiIBFlGcNpkK0U2YrUHkWr8sRpBz2StyWLLej011Sdu32MHV5dyYPSpe+xgBI2L6I1QPC1BWGXEVzH/D+qRXsy2VM3WaC4Gq+Wy/mjX3780S/+sXjzrt4s8+l8m66vr29e3z1+evwNx+mgVC5MuKZMVbc0Qag5BJxliRFhhbwM1wl0aq4vO+/cjyWM39IbOlCQ6gwb2Y/Y7h1zTs0FuwDb85f2dOjbbM9EYUVWstk2SkDwSCjwNkDpki1Y/aOun28sn2VTUWaWedAe5hmaJ5h6pR4MiPbkdFONX4+bVF1tm9v9xm6vSfMP3nthu+Ptm9byiedXm68eDvXLNi3hQsGZBI3WeXnDHB6Qer+NkjhKfk0tmpjDWK7Gbdm26fpZBwPOUX+P8h04nQuPX7Rvddv+wUvZafviMT1a0Rpu16p2gcl4irK4iCbXRlWqQ/KY96cY5ihCGU6KT5ZNFi84yO0TnJ27hC8+RtUO221rW2O2hoF0YqDk8sSI5IDHte3bxpkYRvYuGODIryNGR14cQT+MlYQOh0OR4oiFnjAXmpaVZZ1J6WhUlrbVnKTsLITFm7p/OhKY0vLDP3ybDguZJHj5mB0gscSA/qfEuIpJuWXAHFRkYP5Lnv64ktAKQjtkhSp8C4gvVOyCTmbCmbSpYQ6NwxS1AHtjCg+/gOEd2d00oXGJBsqidD16opAwcD6SOjcDq1lB6nZ3GpSkeSSK911dZiopgJp7LE5LtmGL+QW4etqPiyA6U9KSyOyvO3JXVCZ0vi30y7IqYgFK+hmJ/yTKVcxG9tc5Zw4eDLrx4gvXIoKVPCJDaAR8sXz+6lV/ml999fV9utu/4wK9YZpPX84P4/HL8su+7AslmN22ApIAmRoEabGF4qTxDlolZsNELU+zeRxiFCBaELdJmQPU09adW9HNg8+9yLx0Scj3r242VhkBJ9vd2fZAdbzENBrBQzobUqB1y1mcBh4m64HQxkAgxKceiZRbKdt1TeAgBTLgqcCvgGI9CbrMxcNsKcLrx/PpdLx7OB9736VHef5dxqk/TceruXEKkpctj68vmy00COiLMbWAhWTf4ymnDv9MUlmQ9DuV5KrBW8KTCx3J8xDuQwh35EHoG/V8XUz343Sc3rupj9tlbO2Y7OEHIJFZI3WTJ4wU2a9tzI7+tJ7UEp2kzRwxcsDp0J4qfGxoZVkuU9LCIhd2F8DQaSb4TX4qd1FMWKprtRueTmCClG+eVZ1t5VTo9mMsk57Jajrm3XkSt8CCtJjmZQXUgWWgR2CYA50YdzDWj3dIlyIrYaOLVcp8yXOXD//0vTl3xDym1lVWWkwxIDdBGvAtukIeZKEpZjSEwQDgCLoBu5pGstLogunQUNcvnIZy4yncplCHiGNdU7kgNqbYlqVGuVINcBMvNO9XB2DU28QFF/TqgFrC2z90BhYcT4+9/W0J/Kil0fsAzhh14wTrObtK9DNkgkr9ZhEUFyCwKU+dLGPcpljIwhrtqMfuFk9RYitoGuzNJeseCNwVkx3o5VHrqhR11Hbf8kgpcpWHThRc/ta36VSepqu+eyts/6ttOlSH34xfXorLEqOzMZbR7Q/+cim6vXEeyqqizmNZEb7aNxCbas+bbDuHey+t2K1VzfpPSj+EnIvQQCimK99dsGOVwiYl/EbAuWLGT5FgtOMi4nlBVV4Ow+6mq+XEgAFB5Nd2GccxUgPv6yWlqAMWsqR1Upurvp2iwd89FFYUWjL1zP653h765d1n+/vj+e03nlvSdng8n+sxbTxrsyVht8ZigF0PLQZRJyHe1phApmKK2fGhSrGz5PjQW96xLGGRPo+BWlDiNauI11ZSXV52xfWpstjw2kJc6WsMC+wsYRH+6wWW1R/jnEdAfjuFl8aocZBEN277JY8vC+NZdGmwixiGuLrHQJwUn65dlOqSRjQQcXW6c9dQQ8Hy7TdaNE+5xvLyHOGU1oAEeV4b2XOwE6VzO9wE0kf4pv+TzfsjlU556oK6k2J0D8AjC/g61w8+wG9UnVRVP/yjt/LOsYDiYbsRuBuySZa+CpqwWBCq3bbBA4aSruZrQ4blurASlocnTNHZyS6XeJyjnKKWJDzFBhY8PEq8It1/PG2pAXComAnMqwsCAjGdURW0Uibl2R/cUlIZu79j8UeKPA8S12NboP4InOswCf8qxR4aOe3FilBGPUYYktnbHMzVJWgf8C2dnTiEr0i7xTEoBuSGhdMSk9rWcbgBl15iS9DW5LCyFckKq9twd9ONe0xsPc+X/HVX4emuokmLdV/BSrfvdNbCZVpyMRiUQnXljo+DEthEA1f+OdnpUepCdXVn8aomHrs3VUQ0h6hpl0fRikY/NC7q1dQ68OxgsFuzFZzlx1HggPsRv3j4zuSa1ifgof9yHL3nK4aNfeDVs87iFJ3TjQwnYvRDEa479oOe2A7zCrP6adqk6hsnhdk7bMV6sM8Yx/7x2I/DYAH77jT0D+P4YtlvN6wK7Xy1esUO399sVP86uk+z2GLEEo7jBaBeL2jV35GKAHoONC9dsofkcPa4YG/NTUfUGjtulodzf6imdt9Ak8ZEENalZTd2U1ZX7m86cgU62hLZiF+mQYr2n96IvExF2JNkGzwVg72wUTJ99ZSitiWLhNYUA6JV91EquQ/azquwzVXrp+OEhiuGv00TuvHwbg8jDTH11oMwfOiLkFUjZS/Vx7PXzR4vMk0ScVgx56FnkfGVy9MoCYkH5uAhh0jjj/7iu8HZzbbuudOI88ZCixEX+kyJXELDkVJwAqf4hLXulbxGoUoODavgK/wSlGoVMXQs1v0gdM3rcN+uuFxVomLPfHImlT1pkZS0h2YqVeGbYXdot7K7iZoFCXfVwNtIoCEwM6mT+6xci0ZM4ZFus28LrzHnKAYVOKewqU6n49C1WcSgrzuYIna+o+/4ZC5h5EYZOKuyYzSe/V7vN/WTu8tXWLwviHLor9uPWw0oKsCIXJEmKUsQgydaNpTVqmc9Y0doQhtBSyHhr0Cqsr/tmPp1OY+ywZuzuH3CPEQJha2w7DEgf7SYh57fbHx9msMETTi9FZT4QGmeSszXdC5CGfNvvNzWMRZDKMSqvZymwKcU14LEFFBYQRQjV3FH/dJ/C/berVAze4ZgjrC0YieoeW1BZztV7Zh2XfPZ14d+GG63zX7TPhwvb9zur3btl68e7Vlcqmn3fAMepAFfJdx3uy9X1ei5oYVcsnqfm7Jvs+U6KOuchwjr/kIvU9DfxbazZ2I5Y4hqRwd6Hbazvb8r26vGD9Qxhtn4apcSkDkXaqNTwYhAoEPI899NA9RlCTjIlACNaKjZB57FvKkbCWU8iNSUGvgdAWsuOZUj3/HtXfv+2l3b85yB7T0d1hlDn0dpfsrCgDRnm2yttCKm/OrcssObmQaIXsjdSOXsEzR4Mcbc0ny0xJlxMb5Bdg3DwVjz1GfdvnE1y1JsXLqQHHQPjLx88pzPkpogtS950vKSx39531pIhJ02Xs1hOabHSltQljp4X0SwhHfnK8OO1q5a7Qdp2wHG0/63g4tG5BJjx2MQSBXdirJqwrKHImvO4qPMoPU/kEfge6s8aLIYrzjoWW7rF+/f5mJ07WGPXOphkcOT3MFyvLrd0It1UEbda1IwVD6afzlZerS9bh/vLvbQkRzCnocNuKhcdaRJRisupj0OMU45iyGgBXRCfGE8Q1ayAIRwUhDJYj8oeh7ygyTITHo9YaeAjDJdC0sTaXcT7McYt6N8m++5fr6xQgwRFQsAbuRq16vNX4u0GQ/H/gBOB+Rk11PL9B3vICAP+rnYvzg07llktc6LU6iFqlZpsQV709auElga8wFdkR1YFqmIPHLYcB64Vi7oFLHPWyn4ZklWx7aYNmm8KdNVVb58cyhOhzRuOo90v717DIvEsbzsHclyaf0c1oCDlIYpm/GfDqP7r55HZjrE8PrM7SYcr7mevSPI/VfPNlMxb9/tRl8ic2o9sXFFsQoLKwuc4XEaeX2u1tIOV5/H96qKgznMo3258p8lJWpEmWzp5We8FNrw1yW0DJqkU3az/7prrQ69/Tu4QUugEHAjArEaYsI5XXW/niIou7V6pjigNBKry1xE82Wlfl397BjCGAYSID95MttmX8u3dkEJx4nux7YYEovuNGWLQbtTCqNaE445iqof/ezdmNuRXWtXLXF0fOBMFz4QKaednrbQzwhuUUwwe3KVcp2qkmQhfBNe90pixyLmgC8c46v710VJI0wCjKhiY0gAMVxmRJKWK9ECZ1pJ+I1hL7XFP8SOsiI8QjNhChydirXFJ2+Rxa2bMS4h2cdnPY/bFHkd0vaUFTbRMy2zC6Inht7zqsP01tXq0T8tGc+Tkp0MlMnBABbiGJ1N+SjQgZrz5Ks5Q1czKrBhgh/PJ5NOIh6ST54TYrW2ptWSbNVvhlPQvDgGZBH5NOIPzOqEvxeTmUFnZFxrP+yJw2zLfVAQ8T2AMoklpWau3VHZWu25a473ffRAtXgqNRNtx3pQloyRPlf03ccw/7HVH8348FCHyON5dMhTlJMCAkr2NMHLXYEhZzD5x3rRwGm0tm69jWX1Y1sMbXGqpqE7n7fLZVccr4rD7VK82y5fDK5RnefTftruHI6m5+PCeKEz9i521x0GfkhZw80uO2J7+qDajczFQ2obLNygzqhMvn65swd++uKY3k3P3rvZPGvH/XCpLkM5tqlZpuLbjEL7pRtZKiox8XBj7zfLAL2AaJWUbTy9Gi0bWrtPvaoT+jMgmIpoYPbVStBZljyrFWw6WzDbQrI4e3wYMDuDzRBJhniwCDDwKEd6VdZPMngwIxnXzJR7npUDL6rRCe8PTFkgVyGDoBIlCSqfug1ihxBM34Ye9QrlhkLM3QC9qz3Dwh9yzHoa4itawkanH+blnLH05v22qxB/hK1KnmwqK+t14kUM50hhgiHWX25hrABt48t3YC3COQKis/TSKj63zSbKhgoqhMHeKmaA+BQkY8uqouNeptX8f1VyAHzQhp/lm055RSo0yMuYyggaiGpYmVJpI60euzg6WW7Ce3KMX0Rw2zl2fKHnRDNI0KTcKCLfqeaMdm808lPONvQ8ArX1zsOmcgBI6W23bSGsKWuTR4qsiqM9HJz7STPqfKPubtqwXSoL23LjZeRBUcT52Shz51Y1WjS/7ITw9mQRvi5FjBok3PCKfSm3VaR1FyK4RqKWntvDWYEC7sIO+WF0Ejl79nQGiaF1MwVvQHk3cFVQhKTvEaN4pj2EdUfW6CaAAmnCgtyID0+oi7TK1Msv7CF4j6gfwz6lAG2cRDdb6E0vj7OPIE9Lum2Slgf8xj5TrkJrVYQ7iPj0pb9iPTdXzHgb3iuMPHU5QezaSdfib3xM54+P434eP+77fzg377S7clN8Mh+LczoUde8JJLU2lHRvmD72Kes6adF6Cu/90KAsOax2RZ4SJg2lAAHHnlRS+ezbUCwziCDpoAof906D4FYPYdWhMb2lZUhEeA0mBjuJZVrR9aYPzsIbNcJjVgyCZ0tlDb25zHPS6HcJMClZpVrHudkqMNc+dqOpHApB/mlqEE/hmituLSZXDqd8+CfvEYlysj2XeRAbJnmki/bD3oBXD8sfZU7K1DJb5qzLoR7MprqZxKFPo5a2RQb0UGbGPbxRun6yapXzf1thWSeAqeB5OcS+6ifU8Aban5j9HeT4dDl7XhAGXiorNOOAIV1Oq4VLAhUTQ0NY1zQfkDGqNJsYG0PLT0wOJ8S2QtbsoTl1q61Oh14+MwvrmNrZDgehGCEpt6dHFgnLLITv0ivotPMNj1cvnuubXQ2YKgofaYjyzTLtbzqLZfvbDZ4n0d8IdloY6QmeZHxRgG6YtxCpJWCuWCj2GxmE03kzpOj2DaREu067F/fq1EhOiwLHxz6PWig0O0AScbmSU9njBsPGQ8kQ2glV3HaGbXbemmCmg/0K4YOoCGLKlpdUXe3L4zxhur2oEcybIprbmYTE0l1DjwMGcDjM+G9XUa8kqyhWTwJB2hbCijy82tNGu7qvBjtkl2Hub4tt2zAEzH61kzb1g34Xa+jU/rcrOVg6GZF3Jqmp6mC69RcvHkFnuFP7kKu6Of23h+dLVwzLw0ePx1/Py5dp++kwfzIuN9VYzDQBiQ6zJftdCF2hfWIaI5FmaYc62db5IMC0WMf6+vpBDGRxBFQRxjm4hyYYeJ7LkWBr4HwYMHovUtiTyu7Rk9ZOrjiV1P6lMBDBiyPjc+wH6fE53qQxHzWmtcouNSXIUxmPpx6qGBdS7q7a00MvFQ324gtDsugar25/dISp6rD6QQQEo3VQH6P6wR++RV0DLJryoOqJz1rg1Kk1k8fViaMQy9EVRm0NkIz9prfP22iczzEwvQyh3BIdjSUcMArMfewB+QGSW2Yx3009Y/L/IFKm0IjAtOI41dOZCTfKyGYSjTz53XvVNM5tyzluIspYymavdAZEnp6EMc2EbFscMETgyMDTDfvacdbjqhgNkKRY5LBaGwtubHQaokQfmZ05Q322N20hnpFK1EGCybqLgMla+XbKmDppS7erL15xVDxkwF1OBPp3o8RrtohPD74Qnf2LVgFzsSH09+QXq9H+nJk7jec1/hfEsoKx3MEQLrZqgXN38N0tYeQ6wVlpuYhN4ugP7QKBdN4SorGtqF1ljU64u9gD8Rs/jjEtRhm0AK+aeMex37npsDNd7ZudknYYgviTfcdGOYXil+SZo8w5Uxw2AVzY7UPpVBQuLbEqH6ZkAWNIl3YsWlvTxe2LLVvgZNFZZR3JnXNlFA3pcbebIJFmDqf35ke9PrsSZ8ypX4nT6WmxxbAtH8a3n+9vmm6v+Ldtq5e3u+lZNXcOq2PwbVdoNxgpc1ZKuebUnu2mOh3F80qIZmZMEGP+hXQX9gDtBh1u61cryuDu2P/vbzsLtRyT5BwYFknM5LhHJX3+OkIRwhQZTKAZsnvbXjmxjjJ2wi7pHMYMcGgckeRQa0OnBVRfh0sqOExwkgoRRBQWa6ccOf7rNW+McVgCzk/ZW8Iv4w/+/Lsc7EQl5uiG3aij+p7uNmLuIJK0YwQuFcC8hwYGPSK7Q/YlPIVNLvCIULpOcygZUkaag6jN6dQYxRVhFp7c5nHEsKHTh1B70z2xNWd5lo7ognSv0UBg3pM9nd1V55OBF+fLbeVqJPVAcBpWlcNGHXpYBfayqzL8Lphm6EbjOkDU4i1YxCnTGjDfINw76BOm8vIwot5WHzel0Cuo/ioQ8TQtg8vDiXDWp4lq77dM/QK4AzmD4Quh3Sn8fGPasO388+MAgRhSAm8XyNxThtNo12Yr0hc3YjRYS5q7NfgIZTdpuHq2KeawbwwJcR3j1C2UOzysdoH3py8jA5znPCwSpnvnPhCezG6uPEVqxHu2BG+rrM1tecTj5/nHuaIqgOlw3J33KKWptPfi4JfdewaD/VDpZ8YcLDG11NOKRaC+bUgqF0sBWMb29iVW9XpqK82gZmGUjgqJZlFapvDKvmfsH6b5WdpuOiiLhQpVXPpYdZZzWaXmGMVNxyl70Upz+tUUc72cGnZ08+VS+pWw8RG9pq/GZkhnS82K4s2bXSPdYtvUx9vi4g6QMXmoCoWcbv/KkSwYlWryFpjk6Gz2U8QBozmGfezV7bHFYA9BJy7Gc3g/av6m2vrOCL1qiiWsRxin5jXaEAHOaRxYPLXlal+h1M+boWRS7rW/azGNWAdb0N2iqWqb0dHJ7JJgt2BJ8Zin3unHG/r+TE3e7Fu0UI2AUaj2GnxZsQgx2nMPicNg76X64R+8NQuIYQRYWNm2IbyA4DMxBElsiKbj8U00yFMMAYMvXjDBKfQo4eg45VntCadwDDxDhKzOCBqaMjfpyzLP+C2DwpcnGnhksdNGLFNPHJjCEvLaJZTPbmVbFJAM5zyJGx2msx+v29nJPkPThr0nYubQA8k90nedPRAd2kAtWPHjby2POv/mrbvZURSUgP0xRklQJTCzXbpi4sS3ocSmmFJaKt5gzMgoc9ci4faVhV2zpdO27bGLRBIgJcfk/K/LDJUsBiMqzaRigp+NlJ2SPGXduCxuPDuzFbxRpW/Ll0J+DCms39d23x7uLwLmpPmoqHmDuNBGsjky7gk31zIPjvWW0K7mi7UPHAuOgl1tVkwWmbZWg4thhWoFb5WVT5CnO5l2sjIxp415MxePxaNaOvYJKmRCWtiox3r9bGPfg1kwrvl9zDpU031TDp9fbBN1ZXOupuu3dkB7clKaaCXJ2D4PD8cns3AlkLcCJS9FzHT1rDse+mpTbm/a4SQhhK/bYh00O96U1d3cpPIyeL5v+emrx2N/nap9jcX2krWWnp4r7cXmUP2rkZFcKcSz88YrCa/TnW2nrU4hzOwZTOXnMUYcOCd28e3w4u29080nX8aY1nu2IVazUmM/qvd2/az5IuTokNQ86zwOTKNgCaWcu4Er28WjTKjVkQO9oosFhuj9brW2JLkfgxUhhOQiSBRRgfr10mBW4ceyESdRD8RXcvWT//xvVjg5QRqoy3Uah70YXATk+qrTSc+FQkZEp4SfVNuGa220zKd5neZmv1jGrzVNh9Ur1rOJwBHDUQ+wpmHUnQBgEp8iG/vBOcS0SFrCJ8ocqQeKOQwtww4lvMf8feyuXdtVaAxn0i04nrLHq8v5vv1pYKPSARljsgBddmj3jgWQUcuSPCI1nko0dNGy4gmBQRq8OAore+UWIlEUNWLAI3vyh1nFeZLyWAoppaAgYAMiY3jFPmadSpfnwh1ODpJ527oAFu4/JaIcI0hVxfj19yqZN7t6HQ2J8tnley82fnprN9pVuR5QyYXucYSoETwacflsX+H9Is/ySq/V4YVJzCywXqVpMcyOfrafT3qR0KkA2r0X3LvNIWwPpy8OtoU6iBQM2hvUSieV9nzqOFKmRaCPHmj0WPVX0d71PD1EeaXaxOPV8+1wGJszHgnVsA1KsAUIh/DVwGUN22+pM1XQK3pN6IPmip1GLZCufrOud1XaF/3dJb2XNs86+8+ls8i9tPvyvJ2vD7vbbXX3eH7x8sVQNIf20lw3TlsRXtNIDR6m+HM0eZ2hqhMIMoFFcwfR/ejypeJV3pKpOR2eLFixFXhOdJvGCehNeJzxCpxExog5/ZQH37NHrpfvXeEu2asWdiaQvUH5cCHfSZogSXYMqcVTsyU0D57bMq1myCOT52WlZZBAsY8wOxLW3mLP6QVpLbPmUL/NY3Y04swrYpRMUX3ws3fCzauO8TM4gVU073yNSkVchQsofjq2hewKmEnn7ottfRZ5isbWIMSRFrXmo2RiapkH3tWikFWllTNV1tyMIvs6PwX5aJVtBscQtXaO5j6J150TLJAeiK5TlKS8wiobr5uV7V2pgYUipKyjLCXuqH3uR7SFKrYiZPSWeSRYdF5GZAfqB2NOEFPLNVXUQ8lGwkBPvy9ztj3DbWbJNEhP1qQlWqrVBlo7zXFo5yJOQx8z2kSkdsSU7AyIYWXA4WCRyb2qrJXv1k50wBfYNn+jJZ5HzNrJcXR7PIpiguOYJbVcm8gHC5PyfIoMDAb9zxuF/tJHPEOE1jMUcqTtwHHiDNXrNiZWzN6pxFVqHQ7mTO7DUFarYDBwishPBaP0MgNoNOmTnAibBEiCThbRoJqdZQSWlQyBfxcz89BnihF7gM5KuUSPBV/QWdkra7K10/vr2ZIGS24Pbd9tW4J4EX6+sT8tu2nlg4xMDxxwnQjfqkz2lf8wb+v2MvaH//pQvazt3X7n/XdsT77+5m7czGVXlr/0Y/x4HtIydeV8uFrG5Pj3SJ9EKzY0PWolLf70WoCIZoMrgT8ZuBc4dLvRCK6q8tHvhZcP8sxZpsLSIkyEbMmB4fjpu7B9artyW12H+wF5//mAK1wBtQL5XlK5c1GhY4kkwn6SZctDNVfYUc7ToSc/inKyDE0Prx5SAsgyEaaM8WIh/NJUt1aZl78Z0buSGIVNjr++0aymqT74ydv4yfTiSaOJx0SxxkehKRH9hZGL97AaK1NZXjUq5excTgrXKw9nAsooMBu6PKFXEcF/N4QgsPkyk7MA492ZX+OYwubYwd0KlTy3B9Uepq8MuVP2gfacy+UUZchB62yGJZZ5wjlTGZCf52LA+88e73s7zC2bgG+BS4wl0vZFOpL7645shFDYSJHA7BZ0uegSglBKxwCptlLOVjOEF4gqSMb0whwx8QTKcSJLZ7x4UWAiaVcZn0i1BmavKoOw51+txBGdCoWwP5HpPdnxPPG6Y24YHCKmE5JvywxgiTiimYBhMJKdJxrReTwsHgeaEvZOcW4gZGRG8gIkLA7q1m7Ntt/+tuNe/OBJ4ckBeMGPewhTexaCFeO2EMrB0T9pRA32jW4skanLVH/2dauO+ZEQz8dM48T00zI7LmTJ1Bw+F9mpTqho4+/oun784tJY4WWJYT1t3tws/VL5CTFtJbewtQSboZW9hD1klKo4fLCf/cwAorad9st+ej02j2n6dBjfKC6/Ps+P0/I/T57mfDr97s2t3ePpMr55u2ub+n4zTpUXOxYIhAc9jQvUEV1oPNp8lu590OJHtQ5GKVSr0mTcBKDJlI3CmQENKoXSL7JG364aU+ytskDrpwx9hjBsgebq1tb/wPDgWSKhUuflkKcoDeewe4JYQ1cKu12pXyYLOlhcDeGf4UwINYgbKEeUWauVMZkEgAlZJKn9PORSmtmXmlVuEcOx5h//+fsxc9w2WJ0kd9L3OYXd8ZFRhSs2uEUe3TNngwFUQhyVOylINV64ZICiirI6+65U4XUpTxX7yuGuJz/E5J+BK43zJ5xSINx0hFw69PMq9XaGnuBVf2rD4rwSJUejzGodWPFUNhSOKsHCsdb9f91/o/E3pBKy3TqOOwrQDWhGZA4lbuFlaFGfCsu2IkQtWGAW2uz1kI07QizLZhLaTqQKcjeU9x4j8uxSVCm+o7ST4bnQa0PYwbIA9aegs2V0/WzjcUQxl2l9echSWo2eeTvSkYEyFJgr4Wmj4rdBkuagj04OwDsh3CG9xHYuCHEMQM/jS/lAtxJUZrp8i7lCpylME8kRqrBA0Wua2Qwy8xX1YducT+NqRmbZveW2sB+dR6ZXj+21Z3DZO6SQl4QtADs8FK28FVsopwa4oZVpZw/iu5RH1WEaTFfUfkriYT8OZblVTt/43PCyL4YXFrkSqjelyYTaSPN72Rnh5CUpe+39WQTz2QNu3Kabb9qX2+7u4dR/1Jdfz5evtzf1Ut+n7VxXz5vHU28XbxXt/f35rh7bm8b2IcpKjrFR/RCaqhiBAfbPQySPzJ7xGxyjOXiRgF856YS0UzBfqYK6hbWTEaJaggjfZbzQ0PAq8VRNs1h89OQU+qviQHhsNOXNy+1R4EOZx+sCSa9zp87HIZtbyYJcPaXAAeTisCWi6ezxTE0qdxh/ts7O2mjIaQImUiI2ORtekcsW7O//5J1Y1ksYNjvR6aoRDTom9K0j16NGmwA1cb9NHETQKxBqsnMmQe9eSe1aDFKcXiQes5zPKhrD6qd6GAoWnFMKRhl3LDSYCkUxi0T+astIxGS+7rgb9Ta1gP0KDY8ruW1yMTuisaYBP0JGx3hRsVF8OTvjoa0ETgX/wEsJK9A0TYD0Fa2Wu1kUMfLLPspCkh3jXnapvTDKJ/v00NsKC5tdWkUVU6CjCHWfE9FS1k+e8sAe+1tZsnnH1j5ZopkGsHOSSz0cDn/fkr9iXooZZqRlqxZKbZNVe8xKYjAnMppSA6jsYx1hzObOjiI5ojwz00mwhWNeO7lHjBcRaKfgu/hhQCN89AXdS54avHYvUuqVBcp4Hq8yGN3mq8XxL25he+UKZy/J1WEki5Ex0cIkt0YxohQNzV037PBQiyWbRqSg4zbV/Tdne0207QqJGehgkBrbF+1d26+2WIAscUpze7d4mVuU56tpe9OkOWFkKqO+CgXYt0dhs+QsN7caKoTlwrztzjwL3tyUr063++73vvPGtmve3JWnfrA/vPfmzadvDcPL6vIive7G5c26cNrXiOrL1Q5L5l521cb96uxlDftnGwKuEnNS45iAR67QBDewFk3BlsqUQi0vvmHy/pJ3pcV9WVt7c5bFWAQpZsSqOsK7hpnnjT4QFymn5u1C6lDIk5IDjDhOhYSvw04UtmGMcesQ6BmkhIjF9fNNTHJr8qRbpOMoLidNXQTxn741LswioN2jbfDqR3/8rgVdWyt5KtciocMEHoRYd34auJJYTHgbRCMjJRGpQ7TqPVqHq90OEKFjDyNJkC3/VrXV60ITktpO5zDwduugGBbvBWypFMMaF1ttPHEvp7E/VvcB30WXK6voGKCM4Qe0iIT1cNH+L3cua5jyoHNMZieOd6BoLulwdxEjzMEggGrZbviLpzXTh1ZWfAI3ho9Olh81FjplOcKDxfuJQ8+JTq1nslTpEBRhe3WiayoBmeW+ViONFgNwyYWMs/PP7qzix12e4DThmU3BaBdw0W9pJH8lnHXbaslj6ThsL+eJMhlGm6CEUm3QcNanH2f/toTFc0Z5DeHBBKoI4snsDzvJlYkvdefIdB5XIYwv8/U4vVsNv3B0xoGPATgcIxEmYgS5SWmvqktvZnsTU4ZTq28H6EFwtS1hH6Ntis/1KK8SdcSmMs8xsoz4JETv6maDuNJn9th7OC+NNsbl3F+asSqq7U3nKbyYN0zQIO3FEezKjRwmBjqM6qtYWLx6tgklWXm+KZqvvny0x3gZHa84ORHEW5xfdUOI+yzfH9yE024QTNpjrysc6iZLzX0nV844QfUCL1Tk6iAu0fS4fr4h8/Xi9xIjuRAk7JXVYs3EdFuvXfy0pviah2wp4WWvGjtwfUjeV8Ubqh0kB7I5duGOUyhkweRh3U+IMNFsupK0QFYCMVYz1CkSKth7t2UgULsE2+WBoAxxQPA8gVipYcJwpiqGnlhw/tF/eNd+vS1o58XposP7Vxo9Cb7UIJN5Jh6PaT1tlA16RLPw1MVUVbEtSm3vkdE95GVWGwKl8z8moWMqojWB75cvdItK6rU7+4nIimfApLl4SmsdcQNAwaDSV5uqA7tyWzpEN8QN+2cdhRs0aKcgVnQUi4hl9z2z5HYqNGiC0OUc5XBgu8XW/UU3bj9yeH2Ro0iJ6bs0KyWt343ku3riJcmwmB/B/8Ag0HamfSAOxf6Squpwf6G/6aiEXgFWYqGYly8qU21s9Qu0dswOOwGwbbmITM/e3FnwgofJk5fJSZirkd9h+oGsBHzdqw/B8E4IVDiDIgBzPWbcTzE5uazC3ayVjbJ3Ko4eUIKiWTylIbjZMVnr+sXWMmhbOZZAYc2OkyUDQ9aqwcqNbtPYSYbPFAV1yHHllouSQbinR3bqGs8W5aZEEiFvstq99mVLFXzmMllK60iiIr6V84T4pIxyLpfim8EbBGM53xQvf3zbXjWX1A++u+f2pm6slPZtt9RbS97r84NVYZ7LUxM5eDJ4aim3e182d0W/PRSXy3i93dwfz+++uDpenC3yeOMhw34vZHq4RXCUZoEGdv3Uwmq5jO220lE6MRojinpZesKVLaVhpAnulp5KdpRzpSpmoEygPStaxMg7Iu/tG7v+GC+aNly291zwZdKYO0exnfqjriVjnxdR+YnCbu9z00F/W2JeWYmQtpMCj4lteWaw0iWHRAGn1GqrgvWJ7q0TF+986OsWD84COzlKb5/8zPxe0lrGMdCJ80xSaduEijrGboRcMwTZURIudAxBpYkg4SVQQJVGAymUTtkWxptJ6odMIK7perSCgZ0f0LqpGxZ0eAw64Vusk0ANsozTrsoOeXhu3uwA8BLMHLOYtM1g9Gi0ekkNOM8xKde1vschz+/1N2+7S+hAha0ddsDwrJBcISh1ak8fHA72OUAJRSgYKgT3SjdrcXOjnkAewVJa/YjQ117k5TDKMKeE8GKfPELmVkMaCi5m7XXwNiqkZ+4mfBgxdZEIEpfLiS6PXfCVH4kezrbqJXtBobY9T2CSRqdSssBYB/6WvgqTEYiqyoYKkapbOLqFqAx5PISo25oXa2sF1nuhNLbILmAebq461Nf8XmkMxjp0UX4ybcSbB99d1MA5HnrIUCT4niAoU7aEbuMNnBKMhvkLaMjURbF42qLZgNYnk8iK/owTF3d1e9v2v+0r2xjyY7h+udtVm2pTjr/q+7t+em7Pdv/8jeth20/tdFyO1d72E6NPRrhOTHgMf/qmvHlz1zX16fL8g7c3D8eLBavtm//mdLx/2I376xYd3+U0bfMysDqOBn8pPDRqqxgi63XcxSl+MZh9it6LFyuWIPs9HgbCk7fVZIVml2ElQpXprApojhDR9GSXcWwLy5+vn3UaAVPim5JHlnjUs4rk4dXZO0h5CnKgNA0d9lGanpkBBZ0O7CHE225lFRaghbc77aRf1umwGmPBKEPkMaVqxpZER98w9aRsFdVJjCP59z//zuGuZwPYSesbQw/dElRLLlSxjzi0qpDGz1uyr50niugtkBlaiaO+OCanS7d3SqtE/2EvW4qnznwt1UqOyJJzAfeIRjTFMDh1RrbXHdFks6nRc9Bdtl0BoZZ2oT0yOzbt+t2nQkC+XOtnpNEObJW4U4XIUbHDD2EdaAWd1G2eQ9HpKHayqIhtcsCY6OD0snACH7FMkNahgHy/NdjbXCRuswOD5ES8cB2WEP3otXUVR6V9g0VbRi4D2QjFdJQQeD7GbTkpYXAPqSpcNHo1y2gLYlYTXV3pz6naZEA4W0yE6BBmxxitkd3IHmd/u7HnaS9lrwdO3e3hXu2OOcukRGusMCZmfi/Vn9SaNGQ8Klk6c3XTMYXFn4YMFcrwp1W78DgcHnp8BSCdVsFp4GADkanBImwzS7gD6ry04cWYVswYgN+Z0HkGIhIfQFWvu/UYGZpJgkCrx3bRyfnT7XAY2770Lu79mB6a/vPh/uv7uSmmL8bxH87tD7absm3uq9f/+ipdVfPH07wrd9uOOVLoN+tI0ls7clyfVM7daT68OtiNnC7DvrSbnQ63/kTEY5h4fbwyz+hnr2wYPQve5y4gYLjgp863KBRhPZYx7JZezezMO4tZFcAOOlBKe3uzty+3dv6dZXw8KZo7VUKcpkHYmX2+I8hVuNeDT1WyNqN3DBfBd3rmP8KNghuwvWlHJ8qN3hdCzjUXq7h69BvxgSZ0VGxHWFQZ+xiUS8SPwcmSYR0cYdQU4aRWNRQldXag11Qf/un74FPKoQreOp7Q0PnTOjjeOX5hXiGsdCxCp7YA2lk4Ez7lqK0tWSFwGIqqIK+VB04SfEEitVr3OKh7HQ5kvZRA9vRrRRwQHOYIef/LJYcVUvJJzOB1Uo7yCK8I4HbT0fNAKbH+8f4izS3oaQpzfvU9Ny7BgxZQrI4R2AHbZSj6+Dn84u29451RZltoa6aYJj3pB8dlnXAnbbYjdFUws4LQWAbxAnAQgiIuZQzEIeAm5Q5JTqoMrXGnzX1LsYB/I1M85N0s974iBrT0Z0QFNLy93MCPmIip9DCR42DPAlqnQwwzcseYJTdbMlqURBqccASjMbpSpWIKdwq2sCVu9g3kCHnbDNJFxHygBC+hqx5eXTBvWccQkOQ6eu1zdOz2fB2ufglP03aLBauGrbjEfhq79VCDRK7UQtXcdpnkFHY7DdJX+36L9d5b2DWPd2e0HKfH0Al519J23W9tC1ZdU16l4kVbvyg205fj7eKDKu4+ur//6OHycXv1ehw+6XeH5jF5PekHwK6xij4rEBZan1E3tdM7U+drrKuvd1Y/1l91sKIsJWzJMrKLid91L7GUvabTYWQpkrcCYMuEEiKl859dSyxqsfCpmEGM8Qk5OD0irJDACrFgsU1h64SOJ0xjR+Vc0yM/ghTzaPZ+3hRqg7Thy3QZWQx+tp0GhC54csUsGFGa5TARTAX/7XoplnbQW9io2AquX431ma83KzvguFF1Wlq3ZG8rqj0xGXyp/D8M+FzzwOyExwAAAABJRU5ErkJggg=="></a> |
public void ifPresent(IntConsumer consumer){
if (isPresent) consumer.accept(value);
}
| Have the specified consumer accept the value if a value is present, otherwise do nothing. |
private static boolean contains(String value,int start,int length,String criteria1,String criteria2,String criteria3,String criteria4){
return contains(value,start,length,new String[]{criteria1,criteria2,criteria3,criteria4});
}
| Shortcut method with 4 criteria |
private void writeTreeLikelihood(String tag,String id,int num,PartitionData partition,XMLWriter writer){
PartitionSubstitutionModel substModel=partition.getPartitionSubstitutionModel();
PartitionTreeModel treeModel=partition.getPartitionTreeModel();
PartitionClockModel clockModel=partition.getPartitionClockModel();
writer.writeComment("Likelihood for tree given sequence data");
String prefix;
if (num > 0) {
prefix=partition.getPrefix() + substModel.getPrefixCodon(num);
}
else {
prefix=partition.getPrefix();
}
String idString=prefix + id;
Attribute[] attributes;
if (tag.equals(MarkovJumpsTreeLikelihoodParser.MARKOV_JUMP_TREE_LIKELIHOOD)) {
AncestralStatesComponentOptions ancestralStatesOptions=(AncestralStatesComponentOptions)options.getComponentOptions(AncestralStatesComponentOptions.class);
boolean saveCompleteHistory=ancestralStatesOptions.isCompleteHistoryLogging(partition);
attributes=new Attribute[]{new Attribute.Default<String>(XMLParser.ID,idString),new Attribute.Default<Boolean>(TreeLikelihoodParser.USE_AMBIGUITIES,substModel.isUseAmbiguitiesTreeLikelihood()),new Attribute.Default<Boolean>(MarkovJumpsTreeLikelihoodParser.USE_UNIFORMIZATION,true),new Attribute.Default<Integer>(MarkovJumpsTreeLikelihoodParser.NUMBER_OF_SIMULANTS,1),new Attribute.Default<String>(AncestralStateTreeLikelihoodParser.RECONSTRUCTION_TAG_NAME,prefix + AncestralStateTreeLikelihoodParser.RECONSTRUCTION_TAG),new Attribute.Default<String>(MarkovJumpsTreeLikelihoodParser.SAVE_HISTORY,saveCompleteHistory ? "true" : "false")};
}
else if (tag.equals(TreeLikelihoodParser.ANCESTRAL_TREE_LIKELIHOOD)) {
attributes=new Attribute[]{new Attribute.Default<String>(XMLParser.ID,idString),new Attribute.Default<Boolean>(TreeLikelihoodParser.USE_AMBIGUITIES,substModel.isUseAmbiguitiesTreeLikelihood()),new Attribute.Default<String>(AncestralStateTreeLikelihoodParser.RECONSTRUCTION_TAG_NAME,prefix + AncestralStateTreeLikelihoodParser.RECONSTRUCTION_TAG)};
}
else {
attributes=new Attribute[]{new Attribute.Default<String>(XMLParser.ID,idString),new Attribute.Default<Boolean>(TreeLikelihoodParser.USE_AMBIGUITIES,substModel.isUseAmbiguitiesTreeLikelihood())};
}
writer.writeOpenTag(tag,attributes);
if (!options.samplePriorOnly) {
if (num > 0) {
writeCodonPatternsRef(prefix,num,substModel.getCodonPartitionCount(),writer);
}
else {
writer.writeIDref(SitePatternsParser.PATTERNS,prefix + SitePatternsParser.PATTERNS);
}
}
else {
writer.writeIDref(AlignmentParser.ALIGNMENT,partition.getAlignment().getId());
}
writer.writeIDref(TreeModel.TREE_MODEL,treeModel.getPrefix() + TreeModel.TREE_MODEL);
if (num > 0) {
writer.writeIDref(GammaSiteModel.SITE_MODEL,substModel.getPrefix(num) + SiteModel.SITE_MODEL);
}
else {
writer.writeIDref(GammaSiteModel.SITE_MODEL,substModel.getPrefix() + SiteModel.SITE_MODEL);
}
ClockModelGenerator.writeBranchRatesModelRef(clockModel,writer);
generateInsertionPoint(ComponentGenerator.InsertionPoint.IN_TREE_LIKELIHOOD,partition,prefix,writer);
writer.writeCloseTag(tag);
}
| Write the tree likelihood XML block. |
private static void sift(final int[] primary,final int[] names,final int left,final int right){
int currentLeft;
final int primaryTMP;
final int namesTMP;
int childL;
currentLeft=left;
primaryTMP=primary[currentLeft];
namesTMP=names[currentLeft];
childL=2 * left + 1;
if ((childL < right) && (primary[childL] < primary[childL + 1])) {
childL+=1;
}
while ((childL <= right) && (primaryTMP < primary[childL])) {
primary[currentLeft]=primary[childL];
names[currentLeft]=names[childL];
currentLeft=childL;
childL=2 * childL + 1;
if ((childL < right) && (primary[childL] < primary[childL + 1])) {
childL+=1;
}
}
primary[currentLeft]=primaryTMP;
names[currentLeft]=namesTMP;
}
| quick sort list on 1 value with names as int primary is sorted into ascending order and names is joined to primary. so if primary[i] is moved to primary[j], then names[i] is moved to names[j] |
public static cuComplex cuCmul(cuComplex x,cuComplex y){
cuComplex prod;
prod=cuCmplx((cuCreal(x) * cuCreal(y)) - (cuCimag(x) * cuCimag(y)),(cuCreal(x) * cuCimag(y)) + (cuCimag(x) * cuCreal(y)));
return prod;
}
| Returns the product of the given complex numbers.<br /> <br /> Original comment:<br /> <br /> This implementation could suffer from intermediate overflow even though the final result would be in range. However, various implementations do not guard against this (presumably to avoid losing performance), so we don't do it either to stay competitive. |
public View onContentViewCreated(View contentView){
ViewGroup mainView=(ViewGroup)activity.getLayoutInflater().inflate(layoutId,null);
mainView.addView(contentView,0);
return mainView;
}
| This event is fired when root content view is created |
public static KeyPair load(File certificateFile,File privateKeyFile,String privateKeyPassword) throws IOException, UnrecoverableKeyException, NoSuchAlgorithmException, CertificateException, KeyStoreException {
Cert cert=Cert.load(certificateFile);
PrivKey privKey=PrivKey.loadFromKeyStore(privateKeyFile,privateKeyPassword);
return new KeyPair(cert,privKey);
}
| Load Certificate & Private key pair from X.509 and keystore file |
public void addPrivilegedService(Class<? extends Service> serviceType){
super.addPrivilegedService(serviceType);
}
| Adds a service to a privileged list, allowing it to operate on authorization. context |
protected byte[] engineDoFinal(byte[] input,int inputOffset,int inputLen) throws IllegalBlockSizeException, BadPaddingException {
return core.doFinal(input,inputOffset,inputLen);
}
| Encrypts or decrypts data in a single-part operation, or finishes a multiple-part operation. The data is encrypted or decrypted, depending on how this cipher was initialized. <p>The first <code>inputLen</code> bytes in the <code>input</code> buffer, starting at <code>inputOffset</code>, and any input bytes that may have been buffered during a previous <code>update</code> operation, are processed, with padding (if requested) being applied. The result is stored in a new buffer. <p>The cipher is reset to its initial state (uninitialized) after this call. |
public void startTransition(long durationMillis){
mFrom=0;
mTo=255;
mAlpha=0;
mDuration=mOriginalDuration=durationMillis;
mReverse=false;
mTransitionState=TRANSITION_STARTING;
invalidateSelf();
}
| Begin the second layer on top of the first layer. |
private void drawXTickMarks(Graphics g){
Rectangle plotRect=getPlotRect();
int yPos=plotRect.y + plotRect.height;
NumberFormat nf=NumberFormatUtil.getInstance().getNumberFormat();
for (double d=0.0; d <= 1.0; d+=0.1) {
int xPos=getXPos(d);
g.setColor(boundaryColor);
g.drawLine(xPos,yPos,xPos,yPos - 10);
g.drawString(nf.format(d),xPos - 3,yPos + 12);
}
}
| This method draws tick marks for the x axis. The x axis represents pi_e, the true probability of effect in treatment, and ranges in value from pi_c to 1.0. |
private static String buildToolTip(final ZyLabelContent content){
return HtmlGenerator.getHtml(content,MONOSPACE_FONT,true);
}
| Builds the tooltip text of a table row from the content of a node. |
public static double convertFeetToMeters(double feet){
return (feet / METERS_TO_FEET);
}
| Converts distance in feet to distance in meters. |
public static void appendUnpaddedInteger(StringBuffer buf,int value){
if (value < 0) {
buf.append('-');
if (value != Integer.MIN_VALUE) {
value=-value;
}
else {
buf.append("" + -(long)Integer.MIN_VALUE);
return;
}
}
if (value < 10) {
buf.append((char)(value + '0'));
}
else if (value < 100) {
int d=((value + 1) * 13421772) >> 27;
buf.append((char)(d + '0'));
buf.append((char)(value - (d << 3) - (d << 1) + '0'));
}
else {
buf.append(Integer.toString(value));
}
}
| Converts an integer to a string, and appends it to the given buffer. <p>This method is optimized for converting small values to strings. |
public boolean isConstant(){
return constant;
}
| tells if arg we are poxying for is dynamic or constant. |
public void write(byte[] buf) throws IOException {
write(buf,0,buf.length);
}
| Write a byte array to the output stream. |
public static _Fields findByThriftIdOrThrow(int fieldId){
_Fields fields=findByThriftId(fieldId);
if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
return fields;
}
| Find the _Fields constant that matches fieldId, throwing an exception if it is not found. |
private static byte[] encode3to4(byte[] b4,byte[] threeBytes,int numSigBytes){
encode3to4(threeBytes,0,numSigBytes,b4,0);
return b4;
}
| Encodes up to the first three bytes of array <var>threeBytes</var> and returns a four-byte array in Base64 notation. The actual number of significant bytes in your array is given by <var>numSigBytes</var>. The array <var>threeBytes</var> needs only be as big as <var>numSigBytes</var>. Code can reuse a byte array by passing a four-byte array as <var>b4</var>. |
public void closeFile(){
closeFile(true);
}
| closes the current tab |
public void updateStatus(JobContext jobContext){
try {
if (_status == JobStatus.SUCCESS) {
s_logger.debug("Calling task completer for successful job");
_taskCompleter.ready(jobContext.getDbClient());
}
else if (_status == JobStatus.FAILED) {
s_logger.debug("Calling task completer for failed job");
ServiceError error=DeviceControllerErrors.vplex.cacheInvalidateJobFailed(_errorDescription);
_taskCompleter.error(jobContext.getDbClient(),error);
}
}
catch ( Exception e) {
s_logger.error("Problem while trying to update status",e);
}
}
| Update the status after a poll. |
private void cancelScrollFeedback(){
removeMessages(SCROLL_FEEDBACK);
}
| Removes any pending scroll position feedback. Call this for every event. |
public final void actionDelete() throws BasicException {
saveData();
if (canDeleteData()) {
Object obj=getCurrentElement();
int iIndex=getIndex();
int iCount=m_bd.getSize();
if (iIndex >= 0 && iIndex < iCount) {
m_iState=ST_DELETE;
m_editorrecord.writeValueDelete(obj);
m_Dirty.setDirty(true);
fireStateUpdate();
}
}
}
| Delete data |
public QueryInvalidException(String msg){
super(msg);
}
| Construct an instance of QueryInvalidException |
public static Timestamp toTimestamp(String string){
if (string == null) return null;
else try {
return Timestamp.valueOf(string);
}
catch ( Throwable t) {
return null;
}
}
| Return Timestamp value using a String. Null or conversion error returns null. |
public boolean hasNext(){
return (current != null);
}
| Determine if there are more Nodes in the list to be reported. |
@Override public long skip(long n) throws IOException {
if (n <= 0) {
return n;
}
long skipLen=0;
while (n > 0) {
long sublen=Math.min(n,_readLength - _readOffset);
if (sublen > 0) {
_readOffset+=sublen;
skipLen+=sublen;
n-=sublen;
}
else {
if (_source.hasSkip()) {
_readOffset=_readLength=0;
long sourceSkipped=_source.skip(n);
if (sourceSkipped <= 0) {
return skipLen;
}
else {
_position+=sourceSkipped;
skipLen+=sourceSkipped;
n-=sourceSkipped;
}
}
else if (!readBuffer()) {
return skipLen;
}
}
}
return skipLen;
}
| Skips the next <code>n</code> bytes. |
@Override public double op(double z){
z=(z - average) / sigma;
double result=0.5 * (1.0 + errorFunction.op(z * Constants.M_SQRT_2));
if (result <= 1e-8) {
double sum=1.0;
final double zsqr=z * z;
double i=1.0, g=1.0, x, y, a=Constants.QL_MAX_REAL, lasta;
do {
lasta=a;
x=(4.0 * i - 3.0) / zsqr;
y=x * ((4.0 * i - 1) / zsqr);
a=g * (x - y);
sum-=a;
g*=y;
++i;
a=Math.abs(a);
}
while (lasta > a && a >= Math.abs(sum * Constants.QL_EPSILON));
result=-gaussian.op(z) / z * sum;
}
return result;
}
| Computes the cumulative normal distribution. <p> Asymptotic expansion for very negative z as references on M. Abramowitz book. |
public boolean isZoomXEnabled(){
return mZoomXEnabled;
}
| Returns the enabled state of the zoom on X axis. |
protected void connectToAnyPeer() throws PeerDiscoveryException {
final State state=state();
if (!(state == State.STARTING || state == State.RUNNING)) return;
PeerAddress addr=null;
long nowMillis=Utils.currentTimeMillis();
long retryTime=0;
lock.lock();
try {
if (!haveReadyInactivePeer(nowMillis)) {
discoverPeers();
groupBackoff.trackSuccess();
nowMillis=Utils.currentTimeMillis();
}
if (inactives.size() == 0) {
log.debug("Peer discovery didn't provide us any more peers, not trying to build new connection.");
return;
}
addr=inactives.poll();
retryTime=backoffMap.get(addr).getRetryTime();
}
finally {
retryTime=Math.max(retryTime,groupBackoff.getRetryTime());
lock.unlock();
if (retryTime > nowMillis) {
final long millis=retryTime - nowMillis;
log.info("Waiting {} msec before next connect attempt {}",millis,addr == null ? "" : " to " + addr);
Utils.sleep(millis);
}
}
checkNotNull(addr);
connectTo(addr,false);
}
| Picks a peer from discovery and connects to it. If connection fails, picks another and tries again. |
public int read(char buff[],int off,int len) throws IOException {
int b=read();
if (b == -1) return -1;
else {
buff[off]=(char)b;
return 1;
}
}
| This is a degenerate implementation. I don't know how to keep this from blocking if we try to read more than one char... There is no available() for Readers ?? |
public InputStream read(int size,boolean extraCRLF) throws DecodingException {
nextSeen=false;
nextChar=0;
FixedLengthInputStream fin=new FixedLengthInputStream(this.in,size);
if (extraCRLF) {
return new EolInputStream(this,fin);
}
else {
return fin;
}
}
| Reads and consumes a number of characters from the underlying reader, filling the char array provided. TODO: remove unnecessary copying of bits; line reader should maintain an internal ByteBuffer; |
public static void registerTurtleUpgrade(ITurtleUpgrade upgrade){
if (upgrade != null) {
findCC();
if (computerCraft_registerTurtleUpgrade != null) {
try {
computerCraft_registerTurtleUpgrade.invoke(null,upgrade);
}
catch ( Exception e) {
}
}
}
}
| Registers a new turtle turtle for use in ComputerCraft. After calling this, users should be able to craft Turtles with your new turtle. It is recommended to call this during the load() method of your mod. |
private void showFeedback(String feedback){
if (myHost != null) {
myHost.showFeedback(feedback);
}
else {
System.out.println(feedback);
}
}
| Used to communicate feedback pop-up messages between a plugin tool and the main Whitebox user-interface. |
public void println(long x){
out.println(x);
}
| Print a long and then terminate the line. |
public static String[] warningOptionNames(){
String[] result={OPTION_ReportAnnotationSuperInterface,OPTION_ReportAssertIdentifier,OPTION_ReportAutoboxing,OPTION_ReportComparingIdentical,OPTION_ReportDeadCode,OPTION_ReportDeadCodeInTrivialIfStatement,OPTION_ReportDeprecation,OPTION_ReportDeprecationInDeprecatedCode,OPTION_ReportDeprecationWhenOverridingDeprecatedMethod,OPTION_ReportDiscouragedReference,OPTION_ReportEmptyStatement,OPTION_ReportEnumIdentifier,OPTION_ReportFallthroughCase,OPTION_ReportFieldHiding,OPTION_ReportFinallyBlockNotCompletingNormally,OPTION_ReportFinalParameterBound,OPTION_ReportForbiddenReference,OPTION_ReportHiddenCatchBlock,OPTION_ReportIncompatibleNonInheritedInterfaceMethod,OPTION_ReportIncompleteEnumSwitch,OPTION_ReportIndirectStaticAccess,OPTION_ReportInvalidJavadoc,OPTION_ReportInvalidJavadocTags,OPTION_ReportInvalidJavadocTagsDeprecatedRef,OPTION_ReportInvalidJavadocTagsNotVisibleRef,OPTION_ReportInvalidJavadocTagsVisibility,OPTION_ReportLocalVariableHiding,OPTION_ReportMethodCanBePotentiallyStatic,OPTION_ReportMethodCanBeStatic,OPTION_ReportMethodWithConstructorName,OPTION_ReportMissingDeprecatedAnnotation,OPTION_ReportMissingHashCodeMethod,OPTION_ReportMissingJavadocComments,OPTION_ReportMissingJavadocCommentsOverriding,OPTION_ReportMissingJavadocCommentsVisibility,OPTION_ReportMissingJavadocTagDescription,OPTION_ReportMissingJavadocTags,OPTION_ReportMissingJavadocTagsMethodTypeParameters,OPTION_ReportMissingJavadocTagsOverriding,OPTION_ReportMissingJavadocTagsVisibility,OPTION_ReportMissingOverrideAnnotation,OPTION_ReportMissingOverrideAnnotationForInterfaceMethodImplementation,OPTION_ReportMissingSerialVersion,OPTION_ReportMissingSynchronizedOnInheritedMethod,OPTION_ReportNoEffectAssignment,OPTION_ReportNoImplicitStringConversion,OPTION_ReportNonExternalizedStringLiteral,OPTION_ReportNonStaticAccessToStatic,OPTION_ReportNullReference,OPTION_ReportOverridingMethodWithoutSuperInvocation,OPTION_ReportOverridingPackageDefaultMethod,OPTION_ReportParameterAssignment,OPTION_ReportPossibleAccidentalBooleanAssignment,OPTION_ReportPotentialNullReference,OPTION_ReportRawTypeReference,OPTION_ReportRedundantNullCheck,OPTION_ReportRedundantSuperinterface,OPTION_ReportRedundantSpecificationOfTypeArguments,OPTION_ReportSpecialParameterHidingField,OPTION_ReportSyntheticAccessEmulation,OPTION_ReportTasks,OPTION_ReportTypeParameterHiding,OPTION_ReportUnavoidableGenericTypeProblems,OPTION_ReportUncheckedTypeOperation,OPTION_ReportUndocumentedEmptyBlock,OPTION_ReportUnhandledWarningToken,OPTION_ReportUnnecessaryElse,OPTION_ReportUnnecessaryTypeCheck,OPTION_ReportUnqualifiedFieldAccess,OPTION_ReportUnusedDeclaredThrownException,OPTION_ReportUnusedDeclaredThrownExceptionExemptExceptionAndThrowable,OPTION_ReportUnusedDeclaredThrownExceptionIncludeDocCommentReference,OPTION_ReportUnusedDeclaredThrownExceptionWhenOverriding,OPTION_ReportUnusedImport,OPTION_ReportUnusedLabel,OPTION_ReportUnusedLocal,OPTION_ReportUnusedObjectAllocation,OPTION_ReportUnusedParameter,OPTION_ReportUnusedParameterIncludeDocCommentReference,OPTION_ReportUnusedParameterWhenImplementingAbstract,OPTION_ReportUnusedParameterWhenOverridingConcrete,OPTION_ReportUnusedPrivateMember,OPTION_ReportUnusedTypeArgumentsForMethodInvocation,OPTION_ReportUnusedWarningToken,OPTION_ReportVarargsArgumentNeedCast};
return result;
}
| Return all warning option names for use as keys in compiler options maps. |
public AnchorUpdateControl(Layout[] layout,String action){
this(layout,action,true);
}
| Create a new AnchorUpdateControl. |
public static Data convertInputType(String parameterName,Object parameterValue,Metadata metadata){
String name=parameterName;
Object value=parameterValue;
boolean hasMetadata=(metadata != null) ? true : false;
boolean hasMatrixMetadata=hasMetadata && (metadata instanceof MatrixMetadata) ? true : false;
boolean hasFrameMetadata=hasMetadata && (metadata instanceof FrameMetadata) ? true : false;
if (name == null) {
throw new MLContextException("Input parameter name is null");
}
else if (value == null) {
throw new MLContextException("Input parameter value is null for: " + parameterName);
}
else if (value instanceof JavaRDD<?>) {
@SuppressWarnings("unchecked") JavaRDD<String> javaRDD=(JavaRDD<String>)value;
if (hasMatrixMetadata) {
MatrixMetadata matrixMetadata=(MatrixMetadata)metadata;
if (matrixMetadata.getMatrixFormat() == MatrixFormat.IJV) {
return MLContextConversionUtil.javaRDDStringIJVToMatrixObject(name,javaRDD,matrixMetadata);
}
else {
return MLContextConversionUtil.javaRDDStringCSVToMatrixObject(name,javaRDD,matrixMetadata);
}
}
else if (hasFrameMetadata) {
FrameMetadata frameMetadata=(FrameMetadata)metadata;
if (frameMetadata.getFrameFormat() == FrameFormat.IJV) {
return MLContextConversionUtil.javaRDDStringIJVToFrameObject(name,javaRDD,frameMetadata);
}
else {
return MLContextConversionUtil.javaRDDStringCSVToFrameObject(name,javaRDD,frameMetadata);
}
}
else if (!hasMetadata) {
String firstLine=javaRDD.first();
boolean isAllNumbers=isCSVLineAllNumbers(firstLine);
if (isAllNumbers) {
return MLContextConversionUtil.javaRDDStringCSVToMatrixObject(name,javaRDD);
}
else {
return MLContextConversionUtil.javaRDDStringCSVToFrameObject(name,javaRDD);
}
}
}
else if (value instanceof RDD<?>) {
@SuppressWarnings("unchecked") RDD<String> rdd=(RDD<String>)value;
if (hasMatrixMetadata) {
MatrixMetadata matrixMetadata=(MatrixMetadata)metadata;
if (matrixMetadata.getMatrixFormat() == MatrixFormat.IJV) {
return MLContextConversionUtil.rddStringIJVToMatrixObject(name,rdd,matrixMetadata);
}
else {
return MLContextConversionUtil.rddStringCSVToMatrixObject(name,rdd,matrixMetadata);
}
}
else if (hasFrameMetadata) {
FrameMetadata frameMetadata=(FrameMetadata)metadata;
if (frameMetadata.getFrameFormat() == FrameFormat.IJV) {
return MLContextConversionUtil.rddStringIJVToFrameObject(name,rdd,frameMetadata);
}
else {
return MLContextConversionUtil.rddStringCSVToFrameObject(name,rdd,frameMetadata);
}
}
else if (!hasMetadata) {
String firstLine=rdd.first();
boolean isAllNumbers=isCSVLineAllNumbers(firstLine);
if (isAllNumbers) {
return MLContextConversionUtil.rddStringCSVToMatrixObject(name,rdd);
}
else {
return MLContextConversionUtil.rddStringCSVToFrameObject(name,rdd);
}
}
}
else if (value instanceof MatrixBlock) {
MatrixBlock matrixBlock=(MatrixBlock)value;
return MLContextConversionUtil.matrixBlockToMatrixObject(name,matrixBlock,(MatrixMetadata)metadata);
}
else if (value instanceof FrameBlock) {
FrameBlock frameBlock=(FrameBlock)value;
return MLContextConversionUtil.frameBlockToFrameObject(name,frameBlock,(FrameMetadata)metadata);
}
else if (value instanceof DataFrame) {
DataFrame dataFrame=(DataFrame)value;
if (hasMatrixMetadata) {
return MLContextConversionUtil.dataFrameToMatrixObject(name,dataFrame,(MatrixMetadata)metadata);
}
else if (hasFrameMetadata) {
return MLContextConversionUtil.dataFrameToFrameObject(name,dataFrame,(FrameMetadata)metadata);
}
else if (!hasMetadata) {
boolean looksLikeMatrix=doesDataFrameLookLikeMatrix(dataFrame);
if (looksLikeMatrix) {
return MLContextConversionUtil.dataFrameToMatrixObject(name,dataFrame);
}
else {
return MLContextConversionUtil.dataFrameToFrameObject(name,dataFrame);
}
}
}
else if (value instanceof BinaryBlockMatrix) {
BinaryBlockMatrix binaryBlockMatrix=(BinaryBlockMatrix)value;
if (metadata == null) {
metadata=binaryBlockMatrix.getMatrixMetadata();
}
JavaPairRDD<MatrixIndexes,MatrixBlock> binaryBlocks=binaryBlockMatrix.getBinaryBlocks();
return MLContextConversionUtil.binaryBlocksToMatrixObject(name,binaryBlocks,(MatrixMetadata)metadata);
}
else if (value instanceof BinaryBlockFrame) {
BinaryBlockFrame binaryBlockFrame=(BinaryBlockFrame)value;
if (metadata == null) {
metadata=binaryBlockFrame.getFrameMetadata();
}
JavaPairRDD<Long,FrameBlock> binaryBlocks=binaryBlockFrame.getBinaryBlocks();
return MLContextConversionUtil.binaryBlocksToFrameObject(name,binaryBlocks,(FrameMetadata)metadata);
}
else if (value instanceof Matrix) {
Matrix matrix=(Matrix)value;
return matrix.toMatrixObject();
}
else if (value instanceof Frame) {
Frame frame=(Frame)value;
return frame.toFrameObject();
}
else if (value instanceof double[][]) {
double[][] doubleMatrix=(double[][])value;
return MLContextConversionUtil.doubleMatrixToMatrixObject(name,doubleMatrix,(MatrixMetadata)metadata);
}
else if (value instanceof URL) {
URL url=(URL)value;
return MLContextConversionUtil.urlToMatrixObject(name,url,(MatrixMetadata)metadata);
}
else if (value instanceof Integer) {
return new IntObject((Integer)value);
}
else if (value instanceof Double) {
return new DoubleObject((Double)value);
}
else if (value instanceof String) {
return new StringObject((String)value);
}
else if (value instanceof Boolean) {
return new BooleanObject((Boolean)value);
}
return null;
}
| Convert input types to internal SystemML representations |
@Override public List<ExampleSetBasedIndividual> operate(ExampleSetBasedIndividual individual) throws Exception {
List<ExampleSetBasedIndividual> l=new LinkedList<ExampleSetBasedIndividual>();
AttributeWeightedExampleSet clone=(AttributeWeightedExampleSet)individual.getExampleSet().clone();
double p=prob < 0 ? 1.0d / clone.getAttributes().size() : prob;
p/=4.0d;
try {
if ((maxNumberOfAttributes < 0) || (clone.getAttributes().size() < maxNumberOfAttributes)) {
addOriginalAttribute(clone,p);
}
boolean generationPossible=false;
if ((maxNumberOfAttributes < 0) || (clone.getAttributes().size() <= maxNumberOfAttributes)) {
generationPossible=addGeneratedAttribute(clone,p);
}
deselect(clone,generationPossible ? 2 : 1,p);
}
catch ( GenerationException e) {
individual.getExampleSet().getLog().logWarning("GeneratingMutation: Exception occured during generation of attributes, using only original example set instead.");
}
if (clone.getNumberOfUsedAttributes() > 0) {
l.add(new ExampleSetBasedIndividual(clone));
}
l.add(individual);
return l;
}
| Performs one of the following three mutations: <ul> <li>add a newly generated attribute</li> <li>add an original attribute</li> <li>remove an attribute</li> </ul> |
public int findPeakElement(int[] num){
if (num == null || num.length == 0) return 0;
int n=num.length;
if (n <= 1) return 0;
if (num[0] > num[1]) return 0;
if (num[n - 1] > num[n - 2]) return n - 1;
int left=1, right=n - 2;
while (left < right) {
int mid=(right - left) / 2 + left;
if (num[mid] > num[mid - 1] && num[mid] > num[mid + 1]) return mid;
else if (num[mid] > num[mid + 1]) right=mid - 1;
else left=mid + 1;
}
return left;
}
| Binary search for a peak. Other peaks can be ignored. |
public static void serializeTrace(Model model){
try {
List<TLCState> trace=getErrorOfOriginalTrace(model).getStates(Length.ALL);
Assert.isNotNull(trace);
Iterator<TLCState> it=trace.iterator();
IFile traceSourceFile=model.getTraceSourceFile();
ModelHelper.createOrClearFiles(new IFile[]{traceSourceFile},new NullProgressMonitor());
while (it.hasNext()) {
traceSourceFile.appendContents(new ByteArrayInputStream((MP.DELIM + MP.STARTMSG + "0000"+ MP.COLON+ MP.STATE+ " "+ MP.DELIM+ "\n").getBytes()),IResource.FORCE | IWorkspace.AVOID_UPDATE,new NullProgressMonitor());
TLCState state=(TLCState)it.next();
StringBuffer toAppend=new StringBuffer();
toAppend.append(state.getStateNumber()).append(": ").append(state.getLabel()).append("\n").append(state.toString());
traceSourceFile.appendContents(new ByteArrayInputStream(toAppend.toString().getBytes()),IResource.FORCE | IWorkspace.AVOID_UPDATE,new NullProgressMonitor());
traceSourceFile.appendContents(new ByteArrayInputStream((MP.DELIM + MP.ENDMSG + "0000"+ " "+ MP.DELIM+ "\n").getBytes()),IResource.FORCE | IWorkspace.AVOID_UPDATE,new NullProgressMonitor());
}
}
catch ( CoreException e) {
TLCUIActivator.getDefault().logError("Error writing trace contents to file",e);
}
}
| Writes the trace to MC_TE.out. |
public AmqpSender createSender(final String address) throws Exception {
return createSender(address,false);
}
| Create a sender instance using the given address |
@Override public void prepareAccessibilityDrop(){
if (mReorderAlarm.alarmPending()) {
mReorderAlarm.cancelAlarm();
mReorderAlarmListener.onAlarm(mReorderAlarm);
}
}
| When performing an accessibility drop, onDrop is sent immediately after onDragEnter. So we need to complete all transient states based on timers. |
@RequestMapping(value="/{id}",params="action=delete",method=POST) public Callable<String> deleteTodo(@PathVariable("id") Long id){
return null;
}
| Delete a to-do item. |
public WitboxFaces(int face,int[] type){
mType=face;
generatePlaneCoords(face,type);
int vertexShader=ViewerRenderer.loadShader(GLES20.GL_VERTEX_SHADER,vertexShaderCode);
int fragmentShader=ViewerRenderer.loadShader(GLES20.GL_FRAGMENT_SHADER,fragmentShaderCode);
mProgram=GLES20.glCreateProgram();
GLES20.glAttachShader(mProgram,vertexShader);
GLES20.glAttachShader(mProgram,fragmentShader);
GLES20.glLinkProgram(mProgram);
}
| Sets up the drawing object data for use in an OpenGL ES context. Alberto: change alpha according to face |
public <T extends ServiceDocument>Iterable<T> selectedDocuments(Class<T> type){
if (this.results == null || this.results.selectedDocuments == null) {
return Collections.emptyList();
}
Stream<T> stream=this.results.selectedDocuments.values().stream().map(null);
return null;
}
| Iterate over all selected documents converted to the desired type. The returned iterable is not reusable. |
public static PlatformDecoder buildPlatformDecoder(PoolFactory poolFactory,boolean decodeMemoryFileEnabled){
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
return new ArtDecoder(poolFactory.getBitmapPool(),poolFactory.getFlexByteArrayPoolMaxNumThreads());
}
else {
if (decodeMemoryFileEnabled && Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) {
return new GingerbreadPurgeableDecoder();
}
else {
return new KitKatPurgeableDecoder(poolFactory.getFlexByteArrayPool());
}
}
}
| Provide the implementation of the PlatformDecoder for the current platform using the provided PoolFactory |
protected void uninstallListeners(){
frame.removePropertyChangeListener(this);
removePropertyChangeListener(this);
}
| Uninstall the listeners from the title pane. |
protected void paintData(Graphics2D g2,Variate.N xData,Variate.N yData){
g2.setPaint(linePaint);
g2.setStroke(lineStroke);
if (getSelectedPoints() != null && getSelectedPoints().size() > 0) {
for ( int i : getSelectedPoints()) {
double x=((Number)xTipData.get(i)).doubleValue();
double y=((Number)yTipData.get(i)).doubleValue();
double x1=transformX(x);
double y1=transformY(y);
double x2=transformX(((Number)xData.get(0)).doubleValue());
double y2=transformY(((Number)yData.get(0)).doubleValue());
GeneralPath path=new GeneralPath();
path.moveTo((float)x1,(float)y1);
path.lineTo((float)x2,(float)y2);
g2.draw(path);
}
}
else {
for (int i=0; i < xData.getCount(); i++) {
double x1=transformX(((Number)xTipData.get(i)).doubleValue());
double y1=transformY(((Number)yTipData.get(i)).doubleValue());
double x2=transformX(((Number)xData.get(i)).doubleValue());
double y2=transformY(((Number)yData.get(i)).doubleValue());
GeneralPath path=new GeneralPath();
path.moveTo((float)x1,(float)y1);
path.lineTo((float)x2,(float)y2);
g2.draw(path);
}
}
}
| Paint data series |
public MessageBuilder appendQuote(String content){
return appendCode("",content);
}
| Adds a multiline code block with no language highlighting. |
@Override public boolean isAscending(){
return false;
}
| Ascending is set to false as we are looking for Bottom N |
private DebugProtocolHelper(){
}
| You are not supposed to instantiate this class. |
public String name(){
return name;
}
| Returns bucket name. |
public MergePolicyWrapper(MergePolicy in){
this.in=in;
}
| Creates a new merge policy instance. |
public void pop(){
mv.visitInsn(Opcodes.POP);
}
| Generates a POP instruction. |
public static String ssx(String shpFileName){
String ret=null;
if (shpFileName != null) {
ret=shpFileName.substring(0,shpFileName.indexOf(".shp")) + ".ssx";
}
return ret;
}
| Figures out the ssx file name from the shp file name. |
@Nullable public GeoPoint center(){
return center;
}
| Query for the center of the map |
public static boolean running(){
return running;
}
| Check if the simulation is still running. This method should be used by entities to check if they should continue executing. |
public CheckItemProvider(AdapterFactory adapterFactory){
super(adapterFactory);
}
| This constructs an instance from a factory and a notifier. <!-- begin-user-doc --> <!-- end-user-doc --> |
private boolean sendEmail(MRequest request,String AD_Message){
String subject=Msg.getMsg(m_client.getAD_Language(),AD_Message,new String[]{request.getDocumentNo()});
return m_client.sendEMail(request.getSalesRep_ID(),subject,request.getSummary(),request.createPDF());
}
| Send Alert EMail |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.