From 9b8f328516359313f0156cd93d2709f7a4cb2d54 Mon Sep 17 00:00:00 2001 From: Charles Mangin Date: Thu, 21 Jul 2016 01:01:40 -0500 Subject: [PATCH] KFest 2016, day 1 DSK and Arduino code, as presented in Wednesday evening session. --- GP2IO-KFEST/GP2IO-KFEST.ino | 843 ++++++++++++++++++++++++++++++++++++ GPIO Routines.dsk | Bin 0 -> 143360 bytes 2 files changed, 843 insertions(+) create mode 100644 GP2IO-KFEST/GP2IO-KFEST.ino create mode 100755 GPIO Routines.dsk diff --git a/GP2IO-KFEST/GP2IO-KFEST.ino b/GP2IO-KFEST/GP2IO-KFEST.ino new file mode 100644 index 0000000..4cb5351 --- /dev/null +++ b/GP2IO-KFEST/GP2IO-KFEST.ino @@ -0,0 +1,843 @@ +/* + ========= + Pushbutton 3 (GS) / NC 9 | * * | 8 Ground + Gm Ctrl 1 (Stick-1 Y) 10 | * * | 7 Gm Ctrl 2 (Stick-2 X) + Gm Ctrl 3 (Stick-2 Y) 11 | * * | 6 Gm Ctrl 0 (Stick-1 X) + Annunciator 3 12 | * * | 5 /$C040 Strobe + Annunciator 2 13 | * * | 4 Pushbutton 2 / A7 / $c063 /SHIFT + Annunciator 1 14 | * * | 3 Pushbutton 1 / A8 / $c062 + Annunciator 0 15 | * * | 2 Pushbutton 0 / A10 / $c061 + No Connection 16 | * * | 1 +5V + ===| |=== + ^ + + + SETAN0 = $C058 ;Set annunciator-0 output to 0 + CLRAN0 = $C059 ;Set annunciator-0 output to 1 + + SETAN1 = $C05A ;Set annunciator-1 output to 0 + CLRAN1 = $C05B ;Set annunciator-1 output to 1 + + + SETAN2 = $C05C ;Set annunciator-2 output to 0 + CLRAN2 = $C05D ;Set annunciator-2 output to 1 + + SETAN3 = $C05E ;Set annunciator-3 output to 0 + CLRAN3 = $C05F ;Set annunciator-3 output to 1 + + +*/ + +// I2C + +#define SDA_PORT PORTB +#define SDA_PIN 5 +#define SCL_PORT PORTB +#define SCL_PIN 6 + +#define I2C_TIMEOUT 100 +#define I2C_NOINTERRUPT 0 +#define I2C_SLOWMODE 1 +#define FAC 1 +#define I2C_CPUFREQ (F_CPU/FAC) + +#include +#include + +// Adafruit I2C LED backpacks +#define HT16K33_BLINK_CMD 0x80 +#define HT16K33_BLINK_DISPLAYON 0x01 +#define HT16K33_BLINK_OFF 0 +#define HT16K33_CMD_BRIGHTNESS 0xE0 + +uint8_t i2c_addr = 0xe0;//0x70; + +// UART/RS232 + +#define HWSERIAL Serial1 + +int counter = 0; +int delayLoop = 0; +bool sendingBit = 0; +bool FlipFlop = 0; + +volatile long currentMicros = 0; +volatile long lastMicros = 0; +volatile int receivedBit; +volatile int delayMillis; +volatile long TIMEOUTCLOCK; +long TIMESINCELASTBYTE; + +char receivedByte; +byte returnByte; +int changeCount = 0; +int bitCount = 0; + +int byteArray[8]; + +//char stack[256]; +char inputBuffer[256]; +byte outputBuffer[256]; +//byte USBSERIALBuffer[256]; +//byte HWSERIALBuffer[256]; +//int HWSERIALBufferLength = 0; +byte bufferLength[1]; + +/*byte I2CBuffer[8] = { + B00000000, + B00000000, + B10101110, + B01101010, + B10101110 + };*/ + +byte I2CBuffer[8] = { + B01111010, /* bit 7--0 */ + B10111000, + B00000000, + B10111000, + B10111101, + B10101110, + B01101010, + B10101110 +}; +/* + 1 + --- + 6 | 7 | 2 + --- + 5 | 4 | 3 + --- . 0 + + colon is I2CBuffer[2], FF on 00 off + +*/ +int LED_ON = 1; + +int messageLength; +int stackPointer; +int inputPointer; +int outputPointer; +unsigned long baud = 9600; +const int reset_pin = 4; + + +byte ESPByte; + +const int LED_PIN = 11; + +int RGB_RED = 9; +int RGB_GREEN = 10; +int RGB_BLUE = 4; + +int ANN0_PIN = 5; +int ANN1_PIN = 6; +int ANN2_PIN = 0; +int ANN3_PIN = 1; + +char PB0_PIN = 13; +char PB1_PIN = 12; +char PB2_PIN = 21; + + +int IO_MODE; +int NUM_MODES = 9; + +int functionLength = 0; +char currentFunction; +int functionArray[] = +{ B00000001, //0 $01 RGB LED, 3 bytes + B00000010, //1 $02 RGB LED, 1 byte (white intensity) + B00000100, //2 $04 WRITE TO INTERNAL BUFFER, 1 byte (message length), message (0-255 bytes). + B00001000, //3 $08 WRITE TO SERIAL, 1 byte (message length), message (0-255 bytes). + B00010000, //4 $10 WRITE TO I2C bus 8x8 LED Matrix, 7-segment, etc, 1 byte (message length), message (0-255 bytes). + B00100000, //5 $20 SPI (not yet implemented), READPIN, retreive analogRead from pin N + B01000000, //6 $40 QUERY BUFFER, 0 bytes. SEND 1 byte response with buffer length + B10000000, //7 $80 SEND BUFFER CONTENT, 1 byte (buffer to send). Ready to receive, expecting 0-255 bytes. + B00000000 +}; // $00 DEBUG mode. writes all subsequent bytes received to Serial Out. Sends one byte at a time from buffer to Apple on LATCH. +//DEBUG is active until the AVR is reset or input timeout is reached. + +void setup() { + //LED MATRIX / 7 segment display + + if (!i2c_init()) { + Serial.println("I2C error. SDA or SCL are low"); + } + if (!i2c_start(i2c_addr) ) { + Serial.println("I2C device not found"); + } + + i2c_write(0x21); // turn on oscillator + i2c_stop(); + + // set blinkrate 0 + i2c_start(i2c_addr); + i2c_write(HT16K33_BLINK_CMD | HT16K33_BLINK_DISPLAYON | (0 << 1)); + i2c_stop(); + + // set brightness to 15/15 + i2c_start(i2c_addr); + i2c_write(HT16K33_CMD_BRIGHTNESS | 15); + i2c_stop(); + + writeI2C(); // "Good"/"ok" + + + pinMode(ANN2_PIN, INPUT); // annunciator 2 + pinMode(ANN3_PIN, INPUT); // annunciator 3 + + + pinMode(ANN0_PIN, INPUT_PULLUP); + pinMode(ANN1_PIN, INPUT_PULLUP); + + pinMode(RGB_RED, OUTPUT); + pinMode(RGB_GREEN, OUTPUT); + pinMode(RGB_BLUE, OUTPUT); + + + pinMode(PB1_PIN, OUTPUT); // PB1 / solid apple + pinMode(PB0_PIN, OUTPUT); // PB0 / open apple + + digitalWrite(PB0_PIN, LOW); // RTS + digitalWrite(PB1_PIN, LOW); // Bits out + digitalWrite(PB2_PIN, HIGH); // SHIFT is active LOW + + pinMode(LED_PIN, OUTPUT); + digitalWrite(LED_PIN, LOW); + + + Serial.begin(baud); + // to ESP, other serial devices + HWSERIAL.begin(baud); + + enablePinInterrupt(ANN2_PIN); // Apple ready to receive + attachInterrupt(0, APPLERTS, RISING); // ANNUNCIATOR 0, Apple sending byte + attachInterrupt(1, RECEIVINGBITS, CHANGE); // ANNUNCIATOR 1, Apple sending bits + + setRGBOneShot(0, 0, 200); // blue = ready +} + +void loop() +{ + + TIMESINCELASTBYTE = millis() - TIMEOUTCLOCK; + if ( TIMESINCELASTBYTE > 5000 && IO_MODE > -1) { + IOMODERESET(TIMESINCELASTBYTE, "timeout"); + } + + int incomingByte; + + if (Serial.available() > 0) { + incomingByte = Serial.read(); + HWSERIAL.write(incomingByte); + } + + + if (HWSERIAL.available() > 0) { + incomingByte = HWSERIAL.read(); + + bufferLength[0]++; // should be fast enough to get one byte at a time... + + digitalWrite(PB0_PIN, HIGH); // RTS == UART has bytes to send + + outputBuffer[bufferLength[0]] = incomingByte; + Serial.write(outputBuffer[bufferLength[0]]); + + } + + +} //loop + +void IOMODERESET(long resetTime, String reason) { + Serial.print("B"); + Serial.println(bufferLength[0]); + + if ( TIMESINCELASTBYTE > 5000) { // double check there's actually been a timeout... + functionLength = 0; + IO_MODE = -1; + // + Serial.print("MODE RESET "); + Serial.println(reason); + // Serial.println(TIMESINCELASTBYTE); + setRGBOneShot(0, 0, 200); + + digitalWrite(PB0_PIN, LOW); // RTS off + digitalWrite(PB1_PIN, LOW); // Bits out + digitalWrite(PB2_PIN, HIGH); // SHIFT is active LOW + digitalWrite(LED_PIN, LOW); + + // Serial.write(HWSERIALBuffer, 256); + + } +} + + + + +void enablePinInterrupt(byte pin) +{ + *digitalPinToPCMSK(pin) |= bit (digitalPinToPCMSKbit(pin)); // enable pin + PCIFR |= bit (digitalPinToPCICRbit(pin)); // clear any outstanding interrupt + PCICR |= bit (digitalPinToPCICRbit(pin)); // enable interrupt for the group +} + +ISR (PCINT0_vect) // handle pin change interrupt +{ + + //APPLECTS == ANN2 pin rising + + if (digitalRead(ANN2_PIN) == HIGH) { // ready for queued byte, annunciator 2 HIGH + + if (IO_MODE == 6) { // sending one-byte buffer length. + sendByte(bufferLength[0], 1); + functionLength = 0; + IO_MODE = -1; + + // Serial.println(bufferLength[0]); + // Serial.println(outputPointer); + + } else if (outputPointer < bufferLength[0]) { // will always return something when queried, for debugging. + // Serial.print(outputPointer); + // Serial.println(outputBuffer[outputPointer]); + + sendByte(outputBuffer[outputPointer], 0); + outputPointer++; + + Serial.print(outputPointer); + Serial.print(" == "); + Serial.println(bufferLength[0]); + + if (outputPointer == bufferLength[0]) { // zero padding? + + // Serial.println("BUFFER RESET"); + sendByte(0, 1); + outputPointer = 0; + bufferLength[0] = 0; + + } + } + /* if (outputPointer == bufferLength[0]) { // done sending. RTS LOW + digitalWrite(PB0_PIN, LOW); // RTS LOW == no more buffer to send + } + */ + + digitalWrite(LED_PIN, HIGH); // set the LED on + + } else { + digitalWrite(LED_PIN, LOW); // set the LED off + + } + +} + +void sendByte (byte byteToSend, bool oneShot) { + + + if (oneShot) { + outputPointer = 0; + } else { + // outputPointer++; + } + + delay(100); // ~7ms + digitalWrite(PB1_PIN, HIGH); + + for (int i = 0; i < 8; i++) { // send 8 bits, 9 transitions + + int bitToSend = bitRead(byteToSend, 7 - i); + + if (bitToSend == 1) { + delay(80); // ~13ms + } + + delay(20); // ~7ms + + if ( i % 2 ) { + digitalWrite(PB1_PIN, HIGH); + } else { + digitalWrite(PB1_PIN, LOW); + } + + + } + delay(100); // ~7ms + digitalWrite(PB1_PIN, HIGH); + delay(100); // ~7ms + digitalWrite(PB1_PIN, LOW); + +} + + +void APPLERTS() { + // signal to start receiving bits from Apple II + bitCount = 0; + changeCount = 0; + returnByte = B00000000; + + // Serial.print("RECEIVING. IO MODE: "); + // Serial.println(IO_MODE); + // Serial.print(" FUNCTION LENGTH: "); + // Serial.println(functionLength); + +} + +void RECEIVINGBITS() +{ + // ignore short "reset" transitions + currentMicros = micros(); + + + if (changeCount % 2 == 1) { + + + + // Serial.println(currentMicros - lastMicros); + // Serial.print( " = " ); + if ((currentMicros - lastMicros) > 70) { + + receivedBit = 1; + //digitalWrite(A0,HIGH); + //digitalWrite(A1,LOW); + } else { + + receivedBit = 0; + // digitalWrite(A1,HIGH); + // digitalWrite(A0,LOW); + } + // Serial.println(receivedBit); + + byteArray[7 - bitCount] = receivedBit; + + //Serial.print(receivedByte); + /* if (receivedBit == 0) { + returnByte &= ~(0 << (7 - bitCount)); + } else { + returnByte |= (1 << (7 - bitCount)); + } + */ + /* + starts as 00000000 + + 1 or 0 gets added, byte shifted left + */ + + //returnByte = returnByte | receivedBit; // 00000000 to 00000001 + //returnByte = returnByte << 1; // 00000001 to 00000010 + bitCount++; + + + } + changeCount++; + + + + if (bitCount == 8) { // got a BYTE + // Serial.println(receivedBit); + receivedByte = arrayToByte(byteArray, 8); + // Serial.print("HEX "); + // Serial.println( String(arrayToByte(byteArray,8),HEX) ); + // Serial.print("DEC "); + //Serial.println("."); + digitalWrite(LED_PIN, LOW); + // setRGBOneShot(0, 200, 0); + PROCESSBYTE( byte(receivedByte) ); + TIMEOUTCLOCK = millis(); + } + + + lastMicros = currentMicros; + + +} + + +void PROCESSBYTE(byte receivedByte) { + // char longstring[80] = "AT+CIPSTART=\"TCP\",\"www.option8llc.com\",80\n\r"; + // int rd, wr; + String connectString; + int readPin; // pin to read for readpin mode + byte returnByte; // + // Serial.print("P"); + // Serial.println(receivedByte); + //setRGBOneShot(0, 200, 200); + + // TIMEOUTCLOCK = millis(); + + /* + if no IO_MODE, wait on a byte from functionArray to start IO. + + case IO_MODE + each mode sets number of bytes required, sets byte countdown "functionLength" + subsequent bytes in processbyte fall through to io_mode + + functionLength = 0, done with IO function, waiting on next switch byte + + */ + + + if (functionLength == 0) { // waiting on next function + // interpret bytes as mode switch, values + + for (int i = 0; i < NUM_MODES; i++) { + + // Serial.println(functionArray[i]); + + if (receivedByte == functionArray[i]) { + IO_MODE = i; + Serial.print("F"); + Serial.println(i); + TIMEOUTCLOCK = millis(); + + break; + } else { + IO_MODE = -1; + } + } + + // Serial.println(IO_MODE); + + switch (IO_MODE) { + case 0: // RGB PIXEL + functionLength = 3; + // Serial.println("RGB LED - three more bytes"); + + break; + + case 1: // RGB PIXEL, white + functionLength = 1; + // Serial.println("White LED MODE - 1 more byte"); + + break; + + case 2: // $04 WRITE TO STACK, 1 byte (message length), message (0-255 bytes) + functionLength = -1; + stackPointer = 0; + + break; + + case 3: // $08 WRITE TO UART SERIAL, 1 byte (message length), message (0-255 bytes) + + + /* long string + read available write size wr + move wr bytes from longstring to writebuffer + write wr bytes to HWSERIAL + wait X + + + */ + + + // connectString = "AT+CWLAP\n\r"; + + // connectString.getBytes(HWSERIALBuffer, 16);//sizeof(connectString)); + + // char HWSERIALBuffer[messageLength]; + + // connectString.toCharArray(HWSERIALBuffer, messageLength); + + // Serial.print("Content length= "); + // Serial.println(messageLength); + + + //bufferToHWSERIAL(sizeof(connectString)); + + // functionLength = -1; + // stackPointer = 0; + // Serial.println("ESP8266"); + // HWSERIAL.println("AT+CWLAP"); + //HWSERIAL.availableForWrite(); + + + + //HWSERIAL.write("AT+CIPSTART=\"TCP\",\"www.option8llc.com\",80\n\r"); + + //HWSERIAL.println("AT+CIPSEND=72"); + // HWSERIAL.println("GET /KFEST.TXT HTTP/1.1"); + // HWSERIAL.println("Host: option8llc.com"); + // HWSERIAL.println("Connection: close"); + + + + IOMODERESET(TIMESINCELASTBYTE, "serial demo"); // ONE-SHOT + break; + + case 4: // 0x10 write pixels to 8x8 matrix display + functionLength = -1; + // wait on N bytes for matrix/7seg display + // first byte sets message length + + break; + case 5: // 0x20 read pinstate of pin determined by first byte + functionLength = 1; + Serial.print("READPIN "); + + break; + case 6: // QUERY BUFFER - send 1 byte, buffer length + functionLength = 1; + Serial.print("RTS "); + + //Serial.print("SENDING BUFFER LENGTH = "); + // Serial.println(bufferLength[0]); + //messageLength = 80; // how to get the last byte/length of the buffer ??? + + //outputBuffer = char("this is a test."); + //outputPointer = 0; + //sendByte(outputBuffer[0]); + + //bufferLength[0] = HWSERIALBufferLength; + + + //sendByte(bufferLength[0], 1); + + break; + + case 7: // SEND BUFFER - send the bytes from the stack + functionLength = 1; + Serial.print("RTS "); + break; + + case 8: // DEBUG MODE + functionLength = -1; + Serial.println("DEBUG MODE."); + break; + + default: + Serial.print("BAD MODE."); + Serial.println(receivedByte); + break; + } + + } else { // waiting on n bytes + + // Serial.println(functionLength); + + switch (IO_MODE) { + case 0: // RGB LED + setRGB(receivedByte, functionLength); + functionLength --; + break; + + case 1:// RGB LED WHITE + setRGB(receivedByte, 0); + functionLength = 0; + break; + + case 2:// read bytes into local buffer + //Serial.print(receivedByte); + + if (functionLength == -1) { // first byte == message length + functionLength = receivedByte; + Serial.print("I"); + Serial.println(functionLength); + } else { + inputBuffer[stackPointer] = receivedByte; + stackPointer++; + // Serial.println(stackPointer); + + if (stackPointer == functionLength) { // last byte + + for (int i = 0; i < stackPointer; i++) { + HWSERIAL.write(inputBuffer[i]); + } + HWSERIAL.write('\r'); + HWSERIAL.write('\n'); + + IOMODERESET(TIMESINCELASTBYTE, "readbytes"); // SEEMS TO GET MISSED? + + IO_MODE = -1; + functionLength = 0; + + } + + + } + + break; + + + case 3:// read bytes and send to UART (e.g. ESP8266) + // handled in interrupts + break; + + + case 4: // read and buffer 8 bytes to I2C buffer for matrix/7segment display + if (functionLength == -1) { // first byte == message length + functionLength = receivedByte; + Serial.print("I2C "); + Serial.println(functionLength); + } else { + I2CBuffer[functionLength - 1] = receivedByte; + Serial.println(receivedByte); + + functionLength --; + if (functionLength == 0) { + writeI2C(); + Serial.print("I2C DONE"); + } + + } + + + break; + + case 5: + readPin = int(receivedByte); + Serial.print("AnalogRead pin "); + Serial.print(readPin); + pinMode(readPin, INPUT); + Serial.print(" = "); + Serial.println(analogRead(readPin)); + + returnByte = map(analogRead(readPin), 0, 1023, 0, 255); + + // now put that value into the buffer at 0 and signal ready to send *** + inputBuffer[0] = returnByte; + bufferLength[0] = 1; + + IOMODERESET(TIMESINCELASTBYTE, "readpin"); // SEEMS TO GET MISSED? + + IO_MODE = -1; + functionLength = 0; + break; + + + case 7: // send inputbuffer contents to apple + + // *** send only N bytes, zero padded + + /* + get length of expected message = L + move L bytes from inputbuffer to outputbuffer + set outputpointer = 0, wait for latch + */ + + // first byte = expected message length + functionLength = receivedByte; + Serial.print("SENDING "); + // Serial.print(functionLength); + Serial.println(functionLength); + + // Serial.println("SENT"); + outputPointer = 0; // buffer sent, start fresh. + functionLength = 0; + inputPointer = 0; // buffer sent, start fresh. + bufferLength[0] = 0; // buffer sent, start fresh. + break; + + case 8: // DEBUG MODE + functionLength = -1; + //Serial.print(receivedByte); + Serial.print(char(receivedByte)); + break; + + default: + Serial.print("NO MODE FOR BYTE. "); + Serial.println(receivedByte); + break; + } + + } + +} + +void setRGB(byte inByte, int bytePosition) { + + switch (bytePosition) { + case 3: + analogWrite(RGB_RED, 255 - inByte); + break; + + case 2: + analogWrite(RGB_GREEN, 255 - inByte); + break; + + case 1: + analogWrite(RGB_BLUE, 255 - inByte); + break; + + default: + analogWrite(RGB_RED, 255 - inByte); + analogWrite(RGB_GREEN, 255 - inByte); + analogWrite(RGB_BLUE, 255 - inByte); + } + + // Serial.println(inByte); + +} + + +void setRGBOneShot(int REDInt, int GREENInt, int BLUEInt) { + analogWrite(RGB_RED, 255 - REDInt); + analogWrite(RGB_GREEN, 255 - GREENInt); + analogWrite(RGB_BLUE, 255 - BLUEInt); +} + + + + + + +byte arrayToByte(int arr[], int len) { + // Convert -1 to 0 and pack the array into a byte + int i; + byte result = 0; + + for (i = 0; i < len; i++) { + if (arr[i] == 0) { + result &= ~(0 << i); + } else { + result |= (1 << i); + } + } + return result; +} + +void drawPixel(int16_t x, int16_t y, uint16_t color) { + + // if ((y < 0) || (y >= 8)) return; + // if ((x < 0) || (x >= 8)) return; + + // wrap around the x + x += 7; // 0,0 => 7,0 // 7,0 => 14,0 // 1,0 => 8,0 + x %= 8; // 7,0 => 7,0 // 14,0 => 6,0 // 8,0 => 0,0 + + if (color) { + I2CBuffer[y] |= 1 << x; // 0,0,1 => 10000000 // 1,0,1 => 00000001 + } else { + I2CBuffer[y] &= ~(1 << x); + } + + Serial.print(x); + Serial.println(y); + + Serial.println(I2CBuffer[y], BIN); + +} + +void writeI2C(void) { + // writes bytes out to HT16K33 controller via I2C. + //Needs a general purpose I2C version that will work with more devices + + i2c_start(i2c_addr); + i2c_write(0x00); // start address $00 + + for (uint8_t i = 0; i < 8; i++) { + // rotate the byte right by 1. "carry" bit gets rolled around + I2CBuffer[i] = ((I2CBuffer[i] & 0x01) ? 0x80 : 0x00) | (I2CBuffer[i] >> 1); + // seriously? ROR. + + i2c_write(I2CBuffer[i]); // write the bits to turn on/off pixels + i2c_write(0xff); // control/bitmask? + } + i2c_stop(); +} + +void ClearI2C(void) { + for (uint8_t i = 0; i < 8; i++) { + I2CBuffer[i] = 0; + } + writeI2C(); +} + diff --git a/GPIO Routines.dsk b/GPIO Routines.dsk new file mode 100755 index 0000000000000000000000000000000000000000..d266044f756b59d0537315e3ec0a4963973fabd6 GIT binary patch literal 143360 zcmeFa3wTpi+AqGdcbcYYOH(Kiu5K!qmWx&yF>)=1mb8R|fLxr5ab_4(1ZBQq9G(9- zq7tmNyM`GrEfR^rFx|B~>?$B7WT#whDlJ=zl4{W+Qd^*9bCdh-|F@DB8NWH-bI$X8 z|L6RlGpDr4+H1Y*U2DDXyViOyYi%@Uk+I(Y-ntnfMqiY^Di1$#HI7_&*IG+jZIwly zDE8tRj?%YI@#b3ipIdB>Oozq&n<`7$8*#NYXXGC|y4^$K0>k6VF2n`K#JOHD)EPVZ zI7cqO&P|1`iT64zYi(=u)>_x*ubox9Hmi1R4xiw7+%cQ&9VgmbAIHBOZ%#<(JSR{I ziJAm?C9jofZ=Px8-3jH+#Mar~*?FQaWKbS)YuDxpbX!R5Jo$So#ai`o zhWLcUUP;E}-hEQ~_UmsNFmMp{e}DcRDKM?;U;q3&(&FD{%-VmOk^bL-{woSFR1B3e zGkeb5I|_AHN<%5p3_W#{Vn~vv2F{tjaDMKR+rYXx02}cmm_7>DcXm$pf`!p+@~O)Q zSatN7U}H&=rUoy_UX-1`AbZxF?0f>PTLQ3Yq>Q2nSU0x*^RuVVoR^y)Edbb3fW=3j z?f~m4{$KyrP|5!ZTmJ>w`7>u{FYUpmdjyU4`A=YjXJs$UTDmZMZhjP2w+LWK{|Ri+ z3~ToE`3q*u&(4kvL$?@UrXRt&$vb$)QUK1Mm6bC+LOxwCz|rZxL^ z-|_%<*KKTR-Pro)&Ruw$Qz+HV2AJ+P*nf0`fe~8D)YEb|PMrm?6K=!aZkbReEB7{Q zb#noRar{nv&!z(AHBZ1VutkAUfu0XDg(gM_hnVtW{1DYqN#5js-@><(=6 z0XC3e8`1~Z^187N%*nM{ehsnR1&1Ln=o&5!Ub+K_G`z{cNhRM$=8$Plc# z`L~CV1+Y=K!A5q24JLh?F?UWDAZMafHv?d4x4~}rEi!~ha&ofgN6K_F0XFhBSWn*u zJ^V=a{H0m9;dI#m>-C?&Oi_s3o(ZeV0obbBU~9Sw(r-cbLda4yAD_Be0PA}jtfx_A zFx2H)^X|``o4w#R@Er*awQp47P)LqRGd64bg4`MRELgf=VfGw=bj1>cY1H{`Dd;99 zHc8Ob$a(YU&Yb%rvaZ2YD)oFO!0yJ}I7uOqmK2%)`Ts<`spw#Ov}H1}dl;JqKFnTh z$?cXW-L!u>4pRi|#{ugy0runM=^5_e9)kAqA$zb;~Q;^W(KSW_llY zWUsJL`k}+8WzTx%(y`BW%-&YHWsJ#Y-5tkovhZCNUgM#x&s}1d+;k7Fo)=fGVq0H)qT?*hj>^QniG6j9r{z)2rmU}jgwdFPqfr{m<4?ibe1*Qc2e&Q}^t z`a(TI%gF%At%XZvi*Q)HjHy|&b{ygPc60DQ2^M|=5L4F$dWRUOTRs^|~LGGy_zmI!5 zC{QgStDGW~2Gdz3(Zd7=roK6$&Un>IwRlDarlq>lbalon+$Dy)$YiL6Rn&UARKD7( zX=Uo<^S01&`G#PW9210O$?>3&5#-FN9*x1NX)Bo`8AgvDogT|gmOOjhv{1JEv#DZi z)zp={{OhOM*dcDQz`N3Xs({<==MMP2Pn}xM1^nDWzxPSxNq+ANWCZ=*r#lY#9h1GQ z+9^ouO7bw#`xG7~!B_I~X7+{6d@R1bles;9I8LT;d;Q)&m`_dS_W8Z5xf=heDcpX) z$tFY^F)b@_tP~=xEL-k)%3I)=yi)Qzp7btvOj#N9J5~sLfL_?^cT8e`zF9cnH!Yj! zc-lLufO4!ddslbV_!S+u%g=7wY_hS>Y~ei|MGH%5_(`gl(s66bG<2bSx%fN3P(XVU zYip0!S1a+gb;ir?KJ4HvvQ3yH84Sx-a~$bfiC?%O9aybA7NNus0K3gi9XjY&j8zlY zPp*}(wN7fC(f|y~p#y#;Hkx_KR!JV%w>BS~a&QuX?gbF*+RcTe92~WQ2-Ca;TUMBy zF(&WSf>_5?C*3+N`$?JpZkkC+aZ^=OYagC!JXtl>_)RT)ZL_svvv(@D&2M6V@t%0E zn=&EK#52pLMl05D^UJ5dnSj)usY1=l9#pHVj|1cvllSC}1EM-B`@0 zo{pkfMbJPtv_N56w%V~8JQMtW(0i*O}12u~9|`a4QY z5n^h;o2Crwq2+g=Ws6%|HMRajzcXC_kzYK*?tIVLU_-kg>NPhVEs7^aI#NX2enR4A zkT|S-W)imf9aGm$%U&sKzk5naBQ=*1?$qLYT18KTVbYkPASS{jrga)7##RWsAc7Ze zYVE|elYLeGwjME>(mJV5zF@20>UYL=Z1tN~0&G%Y)l|pCLbLbj^HUv9*RG!$nVGAQ zC`5@8S5D;VX~>gF*zP~I$_5U+<|o{m?R8T^o}{F3O;Yif68|X(YyrjdB)h1=cmXoZ zYv(@pd!OKTkO?CCF~h6;-c?*R;ml4y>u}qU*wLL&AW->p%88r*>5Nxvglb<3m5FklR&26N)gxR#Gg+2p{_+xY#$}+p>ba;uhoCaqpon zFgris6KuC96K9o#SvxtiBv^KG4@vS6UgH=q_vdMRCYM?p-YuRk$y#o@RLJK!E|gl? zFi$zYE|ouGsSW&Qtm|9;=zWGA-od-c8qaMoTMxd=pOk5SGxzwWQn{Gg%uSU_rb)$_ zl1-Q@`KC#gNR?zsZYnToXPH@QtF6(>mu%(I;$5t`$v0anY4@`qY~o*Gg-sqRprP^I zcDCK`yu@?Xj$4@0#j_>$$R;@kA92R=>J__`_{!N5*168vl6=Y*DBdOZR&>OZZML=H ziJL98$?a|FNhWa0t&#h%l-qfCx!qoBRW?ZPk5>{3mAFDhhmKiSZ>Y?Z(qCBr2RwA< zNpd{<>rHIuCUGabVw0`@@lCP`W7!p8G@;&dY(T3Cg_S=Dk8i@T#%4>#q1bt}2gWNI zAx?hZJ3iFKbIy(IrA=J6#B=g^i!f74%#n)fH3f5tzR}_|z zwlA9?p-pti4rENdRRX7EaK+YIEo)nMDpx&S>&9=nx?${eDdP{AN;@+~C~QNnBo82K zT8I%1Kn4LOPh2j@U9~eb5$tn}FRwoSamHot*1Iz07|&A>eGZ~u2hnH8R9S>CBrG*{ z=T{=b$CyDO?9H8igPJhQ~zj(Dyxy<(c z(3udT<%11#C1{9^8`*~Ut(P}qpp13NJCK0&X=pM>@}2Vs&iP$knmYLk(mZDqzVLHj zNIcDjCH@>b1+XtA?wDi)aYAe5{)9HOC2pn!Y61b4v1c|}S8VcV@l7c8z)k={eq0nC z;*?%Q7-D!M1_0*R+Uk^ekd=LLi`W4vjZ{MA;>_M2>iywzEPouND700jtuRxl0^Z%x zVS%bK>O(Kf+Ob9`o#V&Ok}`f7k`x{L#76OmjkRnP57`7z@iB?lkd6~liV4DF5*~cV zqyR+|(Z|3e1s8>{B&DBeDCx3~6$z8|v zNm5#dQBQ<)+DB<(0%ojr+R-gn>*_XC@Qig?WR-}l0qh?x5W+(i`)?p@+O+{}8jD%L zSf6l>ok_m?ZN$cuF`N)x`2@fiI>^8pZ-olwc;re7Q>2{c3$5IS^=XmkNrWZIU`ZmH z7qTSzAj31id$O7^aZ|j*4E~?c?f=gPk(OSkBr78cEFtYMkk+ST z+pr!TW#du}I`*fd*ZeG1b1y}&dXd(wp($eS-eK<^2p`z@`OyRJy?Yu%``nF9jYkjE zyNTuN{_&^V9FBri`L_A0ddl`4mYa@*KB+zG-XqH}pxsr~J3kVt#h-TJzw^{t`#dylW7Wu|j# zYMqRADixc}C=?&OFBP8$9!!-V5MG4+q1;o^Rzje;7im(A+Jo`Ee`uBCfXK>(&R2QX%x#zhnur}4Th9r58Rc=LpJ#?UJm`i3{ zjg0Fm6VRo)E;Dt;GXkB;DU86Ra_1RAo622agqT!Vi@9D{jbye7f}gt;w9fRb%j6C>3c(al^DK))6kw_?y-SK={&B@ zA6QCT((mHF_uFBZjt12Rh7!eoT&v%(vel0-;d@v}LYqJITW9Z5bGxqGqYtF-B32#x zYYY5>wgi5TbvZQIsVQPpw(yZ6J2Fhj2pRNfJ5AIS76Ju|3w^Erwzjr_CW_%~t6#pz z3&2(uLl>ecY}pTOF%|q4wQ6ma^dxrF7CX_T;>6G{CtaW;?eg#A(^hiQ&wcA>7jF?x z`Qt>AFMR7yJn2vT&M&vyJSJ=(r~K@RihEA^%>ZdPICaSA{MKKGV&3hU>(bD5#_Kky z7Yihw<(mDxo;&VmM^upIa=I9sJ5FJ&Gs;;f6brJ%#|twgS;ua?Nwhp{!U^lZ#3J8r8b}>Us^W_79G1~ zn;g4^q)fIgFltU?fW~B~L8KrKbjgR3Be(Fq&9-Q>f%|r&Q|T|%WA@#ByJ4b|9gC=B zVLxg3`1sv&3~Bm8v}I*J`bH-I?efT(WQ8=5fjy(r4=hO>T|Y3T6VR?L&gI7fr-#$m*Y zCk8!`b9LQyV}ws6`L7meG7vyQjHv5n+DBp>5l5|}CDbAPz80xVIv+LqhnE)_3@iP9 z3v7Nx3%3DP3Xb04EO2TlJ6KM}O0>CumUZ7@siZ+u`AeGLTBA6%Sc%(8)040eyJI4r zBV^RJHBhvCKB7_Dc!dm?v`t)U7{~!K@@h=i^dzkGP~x{@KC&r0MK4h_CqU6;r+*++ z6KTS7h&6DxGj3LT3u?nKZ9t6MOUuf59KXC=3L<2ho#SzNF3q|BcVSLLa``Mk6Jbc{8l5%%9 z--+TAp@o1j-!%s{-w7(%|^u_aaF4)%Vrf-u3rNon*=Y@LwK;q9x6r4a=|(13KAZTynCrR4(`>j(e2D$)R<>oUcpp5J zU=oL!w$~5yjl-(as$6o;-=w5$0f!_+$)@Qcz zy)cgs$q9TNDEuk>Iweh#6~m;k$tbaqC9>BfJ}F@#U!;qUFd{8-FEYk>!U7#n%YDd# z#E$cc*VxfMlWhfhs`2PZ|Jr;@q{^jaUCA(F!K~aBU8Uq{$SFA{6^A84OI=B|RJ=>_ zJtkG!r1T7BL~e#MB;BZt7k&xhUm{fqzmhtZO66^`rdAxv)97?O{yrm=O7zuAm6&LC z5@tV!gArgHWMRxyMnL6xRC3iyL=hsZk8gqGG=^w74CWn;P}=#u4Vio$GKQ0`3?Vf$ zlzsxN)LKb^T^%CizzWopfP)KEwu8EaX@jEtN{NV#*S_V6`dyM7d$w9K$r>Am1rA$> z>;wj{#BJ#wd<^V~%UV*6KPVpdj#q|2qCM2v zbABa0p!nm~5Lc0`5HXMJJ6&)Sm~76Uk(y%2>AV;7mGl^Lx|H-Aqu@8doi!Y$E9Rz{ z%-&TgCaisOZNb`=>sG8=zV0cqAl)P!{~^kja}hGF#QMD?O01PwZI((RePA`;OZ+U# zG$M%y3FY>%PgeStN|j5bb>iBsHnaDMj%o>hWqZdi$uT8nvPsF_@`TsEZX(tXP1VH0 zH8 z4Dne=~_S3xROJ;)wQ&a+EQlM3XH*(QxZL?xfQnYpchSbIumZaB4#n zomw-Hr6*a0@BE>GVk+kGw|+~V@fy@*{CX&p{rPYGu5bNqMY)W85m|Pz&&qF!p6%>q z>OAR}^_|eJ8NSO*FeU(Fuh4X0o)yL1u1inyFsLRTN31L{Qqk7yTmL;L{r7-7p1VpG zNZ74&#{tg*iJK2^uX|xc$>z1=penP8P^uS^g`vgI_vTK(MP8wt2n|;rMJt)s8s5yu z+p4Rpl|kbkk(3Kyal*L8lAMU0_tz4yO@uzaSgPJvoz4IOzVq_BaV!LmekE|*{;tBQ z&BzsJg5ba{pH&8sCLSO~J4w+!VtP-Jhd$flSM;EeY^swlR-W)9S++zXW)ENxik?w! zwg1CSm3`~4tzi&F0>X<*J8*d@p~WBSr5rb`Z1I<)+S0G84YIzrt%Z@#D>0odez_Sc zRR;>I7fI}_a&c-@)W=nGU;6|1RCC|>O-0J^-1`+)c!a1C10pik2MZD?9xEromPprw z5jxw7ul+=^7aotA1{UGhQm!V?zMSYs8lo@JWQC1rN=+!^roaItA^J%8aIf-vK?6g% zfQCu9@|-`ES-~5{Usay-Lz${8%!tEebSZvoSvhRzND`6-YZ;vl#VZel`YHE?^vXC` zBju)*8ai72E|}brx-ZhM7isI~q;4b`tqVDy{((ELX=}CeK%wz!=w3w&=H6e&zl2>e z4+a<{J-wo^7}}f$vQT}_k4b^hejOpN-uWLGd7d}{v?ra=$v;><|A2L+bcUuYdB9xU z;&=BcKH+y~7K5_OdC?#|iLJmno@{S<&Q!wgz0tq3QExsk51HF_z*i8Z;pRyCahHZrU!}63kqT^`!B(u$#8D$f(J@TM6qui<3jiaMP zjv@Yw0Rq`Rl>VX-;(g8!a`Ku)h`Zlj7SWh3)eU}E1D+a)4hi)z;t3rEtB~mJ@gyiT zLxQ1Ww>8X>B6eH??6|1W<5Wlp2%b{d6R1dbGAR6Zc(Y+p5pVIYNaKvMFvKYH(lxM# zmPy=iB;j`w_uGH=bw~Bw+cuXtT=ZE{r1#(XVQEA5AbHs0^M5BjwG4B@+24ez@O&-N93l(MdC}xM<(K`Iq?^KDl7-c4Ah?{ zsRTx2#E~D-)`|Hj#$XAaDcPb3?@;PB@MaTq8k2GyeedaY)U4{R#M2cRB!FfpS)iYR zJ+NIo!=BwCK0q>Q*p)AC7t={PQyCU@mk+|4P1L0B@fI2{iq%n^8j}aQJO*bZeYp@< zTF{5n8laQc#u((s@%>r6L0&2(8RVygUWU*n@d>W4K}a-kDFmp_Xi#*aMaq160-g?; z4Dvm~k~qac)b4kn!y9XamuhgafD+zJg-Q-hf1m+J7E0q><+0G$GDcKt4g4r`ht`m{ zQfsKFZiy7&DnmxRduVk{T$vDy*_NSJ{F7htV5nigdym`Wi@Fp&?t>xX9|RDA>-ICk zvG~c6J@q(ugM&AFj(idUK>1IOl%r%@7v3$rs1JQBPepF+ z>-xwL2{rB^)JTs~BlRcLkdwRV5Ql-YxKXiD@B8)LfnVQE1}tAu)PX-~f6viSL+EH^ z1co;wCkgNHXEMl1(dbTGYVT~ngo`4{Jh=^GB)35vMzJ@(oJro~Jf|TPrwrw_4r6Pw z+sJo4Y?Qw&uQDp1!+u>uW4$>f(#rGY9$l63m%|JOIe=Z`lAEfnGGaBunTYdohu}j| zcz2nSV=B;~&TTK{npAmw#kv$Xjn?~e>r#tfNi8WPj?FbMr^*A|OjSxnVRDL+P?b{d z?Q1HaLn+Q*y?ugJKS(E^vUN(BG2vv zM~)mmLfaxvaEm$si#suO1+v2a%d=h8cp4;`GOfurH#-Sa7;CY(yXC!DDQ|a z4fPpL2R_>U{mU-RJ6+4DcjjxTAnH9#QOBrQ4fQoOjLOhZG8IcL=+a~zd!C}^YqO3O zP+7;QJ$tC`EL&GFJtH?m?&s;!+n?p)YDzR3PG4h5;|$>CSmDK*O0~<^)y2*q(IWGd zH~=7+#~MvZS68vx1<+^$^ZxQTn7v)9@b^?j*V(074-Nwkp)5%DNo&I}F1|*H*%va) zqlDOfA(PAs@%us=d4Q0x50`k>;KTyX`qYLH#1XFVgCaE!wK+`<_ec%j$x&KEFG^ca zY310w{78aZSi?~@aEzkXEksyKgK;!h8YHdvcd(~uClg6K53 zymW-9^CqOT7?vf~_gZRYaip29Ab07OxEv6^k8ZT+-N``S(;1?}nEByNYhgv9AZH6YO1Mgy&PawW(Z2kli^_ zh$iNb@Nub?C6O*p!_aU%Y7&2z(*|Jx!~}(xYw+vwyHim#_Kj3I2|nkSlsMn(sg=&u z&NoRlLQWa{bdv51rFYD|f6L^Mp?9&vQtuuu;;#MG?YJyy-;ZlHhfue)LfGwqe9gug4c zUEldXP$uZKr;fd_X!Z9V?F^+Lw*PNh9u&J@S$IJxz6=H`IN8XwT=LG#-!-?>pLX_>27q z_U&#s?B2iU=m9BhOy=~g88fqUW?6D)Tj%7@Td;`H8WR$F>vXYw;*t|%XhTYTf_~x8 zfA{ns|M=InMeE-w-xdsg)^y_R#XbA>AAsgo-*EWI(a+r!wfB?SPvyohj)j}Hmh-+{ zqhky^Xr{q9Z*l(UHNV^+Y&Ydo#v1p+PR*a$%%`ZKMH3dypza+reg9M{Gxvcf@^$iH zL(JSr;m>C#QT-w*`L`J=HMVZgU&)iLtI9c?uyw=9%x8vw%fB&phN9oGzvbtZS^KBu zPW7G~JUuu6?i}kQ3oPW4#=N-;au?>#&7V7GZvMRach8%jos+v{hIQ_O?CJC7;quF` zKfJK@%+^1PGuNWgq_VL9y_cj|T2IP&v-`t+3&Pok z6`?}-e}s*~ypR4Wa$6T|pYuWHn#?tCMy6+Sg65JYR-@Hu$E6Hg5T}i~lz2&#pn(cQ zQE}Q~GsdMPqHMjE!Dq7eO?(bxG}`G|+13R!bLKAsBG#zY($JJ*dJh;jJng=RGPAqX zTQ_f9SCVwva{~tr*s~uoc6rY+S>DrlG<Z zFXCz~hrPfzwzc>oHSC-@uf##Odt3 zwTarC<)cs$ z!LY^iacyKtHf~-`UznXUAJ@|6&d<)DJ|{bC{v-L;xie`%Q>UW#q>Oy$=p4Lc&x#O6>LTL4Og#FGq03dXZU~{4T6@t%+t$ve| z27Km@QveG4J6iqaMW&T7Hi->HG1ya5G>|1MFB*!)7sRl86X~{=pz3bVg7*7nR-N%8 zpJv9hZSpMwx%B$du1Bp)yQ05mg2HPx_ys8)2}Bb#!y;YNqEiO(nJuT~B;U{*ErQaE zms^Tt;_;`~r^rJb2~fyzFo2ThP_o>fPs#ivB=rr?#w1wR0F&_n=xs4I90RpC0oUu6gp3+4fvC;h zNAdrzvahOPaw0!AFm0r3XXK2OIg=g>qusMr9buY zNdA*ZO8f;3!V#e^aUr*Dq&v3C2!-91=2okW=}d?*%Trh;-K2NqIV=?cV^fnRtQd<- z1+4QtZ(tLGd^|n^RFiV1SG_8~*bJ9+6IZTQR;Wm<&u^=3C|8Y_@F-}JUDxKK zj$xoBYK2g)hKynh`s%Atk&FJx>rFzX3LER~pz?{0b+kAQmDDlW%AV~)uirie|8u51 zRhX-$%ek^Vz7ntuV9U)NB`SiVZ&a`syM$bodtDW5D(6&%$5n2(bM zd)MciYy^Yy^H7|)*wRjswS{|0Ew?vOVR?FWe3+ea)7PLXqt?xCYg?CFtqFq@LcO|T zU64x(+U-J8&}^%~{16_l5xP_yH=wxm8ew6Ldlb9`^J1%0)iN2bnF~efNj-;QxGS;N zX)PuHPy^vx25z&OKCL1k-r`QFfvQ_vtBSC|`zqEiM~m3M*JhIX^n{p5QVgpLvM;sZ zJ1%HjaVjE74htE3E(tZ1RH`M^u_}wQ1m|EDawTeKiHdh|#H|T!m9<=@TFZBVc3@md zg?gw&6(6Xwq`%Ns3tw(#H0prT&T_Dfd?bYKQNHYs795F03x4jbGxM1c>9G(3nU*)43@kaEG`P}DtRp^T>eH*uye&hJ6D3g*Ml2`tFhdf zZ+2zGxs&W=ht)#kHP7|!lrk+qt)b#hZd9?*{FTOmc%_BNEdKD9#lW-U?dM!U%9B1;HC~ z49fKTOqecJna5Y%lAl3dglE%H5vSRmx0J!3Wy-$^thyCirt~rxQ^X;8=?ts+#`@CN zRwf9ZBav62ab&T(za~kbVzXKxXm189lY%vxQvI{}?*#1?f-7hdHU=$4mQvrl!OBf| zx)ij!gM1o@&TBw@Eqmf?@t`|K|7=xeSr%0&U)_?uZf;wfcc!9gW4GKyr2V_EMJCN; zBUQXJ(iO)HbRP>{kcek;5aJ2BJAL|e*b~2fvTJP@vAQ&Y4#xEol2^Q0%IJ_*9Fog8 zvK0OMv*bSBoQx#&w1a_Px05mNw5IHf9AFq@#yN4yq_<$ZSljjHWZ)5A>Kbda0aSPy zN5>h2`LT21{Q2bdSyfZlXW}*zHYxtg2rldRuAUYBf6q6z>B)|%2(Q-Q#*Sl}5M;=+ zu!nKXa7;&GmLs!uTI+NhdmqE@qpe>vd;+(JVNcQJ>nG!SiG0n5FqoE)m3xJfoL_n< zyvyd7&Y1RjRtIBl*N2jwy7uHY;}xpBMkDL6zv$)OZ8)@JFaS%bLKl{rR_Qi}R5gFLUQs7|>GIo@viE-R(HTY#ELM!sQ z96nm00eTTG{F?GR>%~9=TNW9s^#?`>FnQt-!eTI$uozrLHwnYtW!2QZWmH#TO_zKb zO2y>5byGd#)=gYD(DuJaWdB=Ron}Z& zocuq=sDIXUV{gV$`Y2_wT%xE;M(UF0zDuSx7K?|DgQxn0-9gzMG%5Pq7y=dr^3Z9d z&`nbxQx*T9Uaz7~m8=T zZl+(>+wFF~i!wj?KknRrM~P`!A4i{3)3UyfzVG)_^o3Qu*Qem3*ulOB`yA|VRBUd_ z+h0i{x#SLG-&W+x=e_-uxJcIie)1JtWz3kuDiizSXdz|{>l*Dmhe~)BM=Qx8Mvisk zIR0p!Atm42?Dj3D_Xm&w{ubl=$+%Ext1|g?V~)p;amF4`8spUA7@zUH&GdZ#G3!k> z(=q@%HMRQ(Iq3rf9j3Jda3+^2$BEpEz=6?)8QQ!&`C2+-i%T0YneZ`w^neII@%&HU z`q9bL45No6j3(uyhu|+-j&JLOqlijOHaACa8}>cl z+GN3Aldf`hvXUFI=l@3qqA89P^3j)k^dlerGk#g5{D!1@J505vW&Iojk?!Ldu&lph zP@S@}BxVc>Io%ji*%dnmTMb4}(n)uu`;#<#BHb4=riHE?noNSxyCe3P9x|YGa_5mOh*phd1iEEvsA=-9hNRsj#P$+Xm(|qH#u}b9x(Rf zk;W8ch8SmJNE@-0R;KX>9Lag!WI55%+pHJvOM{&x+@FT_P%X_lxQ^IX4Le5Sw{pkG zw!rvc+5N%5{lT*F!8#MWXVk%DG8~1m9vewk#9ro(9V3-g)5`mT+>DY(mbuHPKjIjkm|hBnk!z!oA&xt zS)OaUwcb)&nrp(5AXG}S>QC}i1+YdD+1MQ?F`mq_$JC0@csj|6hU7`E~(fGNQuro5b$H-?{fm(y}9m1ts z+>@$s`4+cAMU?N?s*tC0t5spP%KcF#Mqi8afM;l6uIkb@qp92sPTLHB!ueaSl;*&t zTP_y4=RI`EGBsdTU84w$FkR(FH-lp0gPct*eq43rter(hmex6g7|}CTcE@+(AnTvc zL`mYyS0hxJt~#$qsbUkHL8W_ytH=n2m1^SqD!NY$P1to-)i;NbRs5WFeOEbMEv%la zuD3vILhldcz_m16Jupi#qEW}(%9qsY*f7p`Az`ZS9d>O{UC*n}*Qu^&)S_Hk(ZWb= z3p}GX^$k09vKEo#3pUn%A@FCltZz8*yjq4T`mKrTD#0zRwzhFyPFojTM442nA8 z=&4AAIcj5@&s*5I3+((0_H-H&lrLwp4_y)`33Y1Xrx?BUqyiTMbnjE_gtOvsw*4}u z*sl?~&XaEzuT?pR%Kow)_wA6cRT9}(FFI2!?1T$;YqLV~$XSR37sa#efJ-<<+kQE2 zP5RX`eOTD2<_Yhp%gbAHg+Hkk>n#U!g=avK%9lDesE&O2hvrt_6*egbGxwfaZ3uI2 zwQ_^%&2w0NF4b0q3ySZm%KV0R)w(L{`h4-eB4t2bt$fitr*&@UJA`K&)z&%Lvy~G& z=iN&{2iD3uFEVff{#~`u`q23*>$vySIc`-xP%9gLtTgtm^Tiv~Rd_LjOVyi7m*qS1 zu~N@Xv!UsH@9YS3tgR;qDeh&jE9~&|^DeR{6(<|AnsJ%v`40By9av6Yg0~~QJ`Xmi zG2B*LgUCL%ie?4(%83(!b48^3QmQi8IvLgpo zg(C9AUb+DpZ9O5p5iA=N#x#Q9j^Vq?Qo=YtL6vQQaeo~HcMgW6sc^z5I`-k4NTQ4i zqigIB9pZQJVW~r#;M&4%&EzHmNQK=o#NPm|yGZ3;QMs4Za^K5D&WcE(oLD5M6$48b z3gn@sakvzvL;i6K7*<#(U+R2?a2bPvhqW}l1ztTFjtR`G?%8KgC--sk<>Af|iD=K8 zQ)Uc%XO$&~ao*RF<*~5yJH=knf?lK`2@=E8V|k5*Paw0{?y)$s(4Zp+Zo?=~_yqVO z;8k+W(m%VMa?ISWab%OBMEp$XsE7Cg$#xBI({0-v1o-nAYkH?Ak2ey$aQ>M)#Z*3M z6*^JkvGBcq%#P<@0K$j#Va(^-em9)uKj+l*^UM(^8p;JwM9XKHaoRINWNfY1cwJ=e z30MfrK%XD5ZWD#CqAWHn$3voG59Z?1?)VP88r9;MbugDr>J*RMA$$?h%L3q3UUM)P ztqh3tA}I!p6n2ZLq3d`GRmQHt#yT^xf=Nl=~ACC)Zu4T z^wZq&3`seYLNxS*jcQX$7z_FH9heUaUTfq`ux{;ezXaM72Qo6bb&&yOVy$*`iUkB& zN;k5N5oFGxz%IBGJbz<21hYmuHHK<+IDUJaYl;jbFTY5e= z4JX((chupvxMMqUgC!!{-6HI~$A%)3e}w>-S6K*KsV^0#jQWaSllZ2}y{T5dh`uzn zYsylZM16JNrgo~VZ<7hcuKbf~BZYmMh~zX4Zc-*y4{pNQsj|UM5LHrSY^r}tg}VOd zGvd(bGxwHS`KFo?!@hP#j3-%xn+)9Fi96i_kFW5iiV*MTXG8_F;!V{?pd&C`nQD4& zU=#PYT0N+#fZ|G_c{s8#e=NdVk?s9$s0>1>ilu4YY4+rq3On|E+;)U~t((OjKZCg{ zAI2Y!Bf^4j)<5gWhMGJRGw;WV*fR&8A*;%t)Hq5$Z^J^gyH8V~cay9sEG5IVl@zNM zMcn}E%QEWA9u{U6l}VY5QU;IGNrd5esa=eL(rjQi;9^A()Dc`lF}s4XA@3y z#aQ<-PtZs3;Wd@eC!c@}Y;xoT1~p+_IDST)%pPuUC{{D#T65%ct+T9LJ3v6L43-e_ zPpYeL6U5P#(iBK(GIy*c4RknECmj_kxPPf;g<)^DS5wC$-?ehb*w<8JZ&XVBlZvyW z38&2+#e{`6gHzv`L~M~=s*KlGU*)sW<@g#y>|aia zv)G@ti_;^_E4L)R7~vXtGKG>m8wxw zUi<->+=#}3M)8#&sCE*KQ*Z{kTqT6)XhYzqi3G0B+bcLQ!`K9HOzc^3(&Y#rsO5;K zDMs^i)G_BJ!AX{g^;jZ^OktgEa}FmAgv1U2C?FA$LpNlzjVp|pUIN{WFe=lmobkbS zt3Tu1XM@zqgKp<1b5>Pgnz=c|4$3D2grS)ghM#HUb8PJ6-zzKN8nM8iAj@s;WTLXw za(OD*QMuVF>BewjL^E0wMmBS=s=~15)2D@$W)Ec^jW?4S{*G z7~Jfd7_n|JCzV_!V)09C07NuT6I zGL$s7y0sJEYR6o4+AWU@lJ{RW|!T#ztcZi~1SCzlsTBHoEl`r?$Iz(fawfr2pFk z-#Kptw0_0-&lbx>m!zN*a+GFmp`Pb8I?2(J&3}RT|OchB#NKCl< zBRe&gE|_c)(~Vee*wvwt7M1l1voBzix8_Fd5e;7OP0D@=eiQw82_1-A&CBSn!2t^702NA>}zyVZlj z^=|~7eW6Li7LU0sTG`4=k)R@twG7rc=KnFlrz-c`*u=}?J!DV_SZebhZN%>OAC2{oHY!#O;>kwg(MIm~ zjpmO3XjC4=I}5rxA8mBT6sQf4Hr7Aci1%?l*@%ENU2bMy`K%Gl(wr&pU`DYF;QzWYr47yvk3AGPaB)@v#u`l8061VN# zU9-QotLu<_G~C?M^$h&)mXo{QU1i6 zmFMiu-f9#BJSCgCB|sR!dqY|3b7v<%M()6)Z{D$hImUulnZ@s6^?OVntvjI__xEBQ z6Y*NaiH7Giw7Fe;b7Em3R<+i0a;zX`GUp8H)9-rjgJVv*0AapZ@n%8nsYxPT0PS$+ zv9!_L`XFBV`1hc9D)+ab9Zk5*F*fS1Nsm7J_V&gLDdQi0bm@{Mix>U;zYbtn5J_Kz zV053JukX3v!DQfwJ)PEWFmjU$^knE!;~r!m%!#s_L>>Yr7u5ju^bK zDCo$JMgWDyL2F~M`0ZfvhMmxJ6+bszr&x;PCp7%R!up!aH4F zuCZsDpL&P9B$T^^Pno+Mj1JREeJyahwnns^Ih~?#G;&$Z zp1tHi>?gIMx=+cWSW5ov2#p1d)^v3-45f|L(6I(uqhT1WR->WmE}EwGCoR`vugX`R zypr*4#)-lcA9pUja^~Es3o9=*Um9?hIeY2ytSkF(Zof&6R<4cF#TMq~%^o{0f9|}8 z=P!VG(bONw&?E723UA@oPIb&Kgex#legLnnxqZAf)!_z_6Q$b$?oCs0G zxm`dFOlKQZ`JBmC6tyKSMKCnW?Kbb+5bYFwpQ`ZHwQEF8ooQKq(XzP}EkSX^?S47G zn+qEZ-blBjV#bUMpWmmK=xYGO8I*)}}Lfy{GCERV$(%qKbo{ zTU84?^mJ55K$M?b|Y7%q9-IA8;Q3RbKpdCNF!0lW!f2! z`l6wdQvqHJ^|2=uV-voIEnT7L00!_f>Ua@)0oP7dW<^Nv%nI!mEyTdi!pSt43y4HS z%!TpL({bKyWHWqC`S3My+K3`N7^Xl-1M2`S?jtS6Bct0`_|6vbN?A%Hj?Teh+%X#* zwu7zce27KNja=8xbjI_LbS&!cdCcBsmc;hEIJA6k*mZE$q;1;#%v$?>rR3I&HPc!%g3&GbBb- z>#&e>YF1~9n}Xez!BoB-Bo`{*CPt|1oB;3f6lg|0p$Y`iEVw@iFY_84*do+~)kOko z1JNvDG)@DGkwB6H`ovmqT_es+aNC0uc&;jVz^>!O(Z_1%_bO|<-tfID_JY(vW(Wfq zxDcRoLgTL|k)wv0YQqebZMlZ{QH7nn{z^l9R>Ftsb16;mXbB&w&-HDBLkphK!A&;j z4p?doMrqyg9qbL~6r5u;vE#0ZeQ>@pGUgYeCL`Rd2GzEw`z*B`old&$U z3GpGs$=ONQkb$UN1_>BlB6zZ*dB>?{Jyc~~F;5QcrO9zog0|sp3K4RfSMtz>L1H5e zvH;agjAR(W&5D-KH2+gz@;uHG5<<6w(EL2{TSC@M8J=v|QV7Mt@>KMoBCJTcgLGgI z8jz@CrO#2vNCPg|NKx-^x>7M95(jL7d=gI=(WYa=#6Q?_4e1`Q>;^S=P1Gq%A|1}y z3VT|SS#Mz{{Q!mh_9ISsMSZA!@9?3L2n%vucZCs5bQy@nfU}}mp-i*)4ul6DH|}ZG0>=XP6zp6`)2~%K{5;%mh^&wv1A{xc+Nh?#P=V+p zj+NCgBEmj|JR^iRgSqTD5Qm(=bSFwi_#n{hTRY$%$7I7%z5vh*8`(Tvu2_i?v}_I z(=B=H$ZF6{OH!|YG<=9myxBJ5?ye>8B)Ej}!yM#x5N9&C9e!^JJhA+^ZR%6oRbhvk zh&6PGuw6B`8Tbv@ji*S*O<}MX zrX{%Rp-Axbw<_p@H83IULNHoBTOAW7#~nDh+ez#?5l+Opktp#%QhjhZ{RJ$yi2c^T zg*J#^5$-^@1`Cy}GubgFo4q@VU?Yr=gzv=55sXj<-oov%x1k$sfJXQZGz1q-Q}1eM zY7;|KTW}HJAGC)0K%=2584V@iRGp7zsI3}?`VczGM^GuY(G1wDc zyP&T48JgZrY3Km0p(W@qK}JJ=N-=aj&Cm@RhCa+NG}Ix@7c`|ghKnyv45j&!qBUR9 zw5A!i5sovo=4(o$`35S`DUAj%x7TRCrx;B;&1g<*7|j`m(VWFGzYdyWIyJcd#!$=! zie@g-G;>KqGnW~f`GL|fS7;4$4O-N7M#J2o80IF;Ft?yosSLyXM4KnN(f{W^nvAsJ z?9d^D2d^4CGW9N!i2PR&oliHy@4c!KGA?)8+&7D#Y^=o*<|iAKMUnrqA@sR??sPO& zAzyGa(d1k5_s>FXS2RW*N5dkIB*s12Shlip&WgrDTlZxr@xIpH<}2#DEM6j#hs z7M5Y)YD8?0CMhee|9{)N|KKR90}kMuyX10*gd7WEMwGrPA_1FF{%8?YiVYg@m}wcs zMr7vbXy?*D)QQ6$Z+El%-e=$2ySMLG-=q`p1i2z$Z8@Lrqf(SH&1=Sp}Pj*Bbs(V|Eorib1seOnL2WLsAYg(Li{ za~8=KtRIO;=pAec1mu$(Jkkl^*-qeUJOBz@Ex$je6op>Hhcc`TEIH#>R5gnPFvIeHR9XNdJ@_WBojar=I}z+7BuED$TyfVNmXuZlHldsDx#R0Qv| zW#A|7vz{7^{*O>}46FXm)?}*l;44Pg(Sf5!P8p*{^7S`fF%G1Ajl)9&_}JQY;1%PI z50CUK#k1diuVh-LgWomyDjy$lW1^Gaohxonch^K`@9^V zJmdS3HyiKh@OZSZLYOf!#7wbV6}vEYeDf0y#NJZVsCiJdUhSlrw(pH!iMDn#wLa8K zU8f0amiB$^dhw9j)7#dEp^mYeU51b0Ui-$jUh{^yBk{eqlh&-ntjx;v$LVPCX1V^# zL}AZK>nb^~Ld`jBi(t(2GZw#?Y(mu2nB7x!TnIslngC>jDiyg;N^(t5AY3OOE9nn5E zhYDm1C6&U014_no0D86xc`LyH=8ki^V@ACN&2Y%mu*n*9%)tMQrwPwb&>t!f^JTnt z5V5{98`J3W9t)=S>vF7E(Y6b$4U#qTf7UugNJOi4)F9Z|Y*mD8C7x1yJiZaH??ErL zJM4S1DfM)ReHW6-V2uO!6>RYR-itlMp7h7Xp=lVpeoE$3!Vxa+*zEDOPxn2Z$&^TI z`@){h#YiKbEw)Eyk*8E-jfq@>Eb+(qU+f)m!+tAVY^US3_C92lm*P8Y1KH-U7%e}E z2)+A-$C}6vGOMFi#nb0-G}&Qxn(Q-+r^v_&O5H3ub(J?ebrt^n%~5&%k%(m8aAm6h z-$I8_bfh_fsMxdg6RIybJ?!dM661MA?u4}{Bq6%^+g4kR-jU5T%c~t2iKy|yOyiOF zU?eo>40H~iD%PuYYW8jX-cv2_Jvfd`qW2?-B2SHsr^%=5^mXFgmz?!{Ok(!{f`d4+pO~Y&7my&{4Lrx%*J%{&jLGaBU2WFJu>u zLzO#MjWwce0e+;X>MLqDEjKIlwJCersZXd26YI2F zjIkzc(Qd6@8N4SI{8g$w_*5$Rhg5K9D!4lpzHQrv)V8guZFQ+_Z7Khns;(&*_$&`~ zN|CCr(nlKYV)5^!J;fTYGr~CHsC`25zb4lFWUP5pta&r0=eQkB5WVId;XAjj>#{u^ ziF^!%?m%lJzfAF8{LA`u>}WC|%l8^sRg*c5N_bV8HB*V8ohl2!TwTXUnsi9N>E))4We|9}2+Y`skW%gQgxxHew zxh%Wdyrr)_T2iG<|Ki@$+p)4``IlFRI-^RoD6&k+9zcdKd@BMlaUw&h4D|KwZ#g86 zrR20a!zHNNL%{qcl>z(-V&yk0>Q~~c7oAG7D`X z(ySbMc3tPnrR|A9qfs_$c~cXE)QoS zX}Y99p?q=U<+4u{mr)i7yXE*C6Ib4vFB(S0YNw|Lzq;Gprn@gOAhwQVF{-qH5{y@Uh2bx>^fyZxQpIk&Q7t89ilLm;fb(QyyX-%&cyI# zM0-g@^>Y_WynptR2r>hC5d|`NAM+W@yy|pbkpBY>wL2>_`TruGkB7=FfjSTF>O$XQieI?&#h21G#5)i{QB#Bv$IC%VtMDLMLi{H)Lvk@6Xoy`X}3+$IlG` z-z*^(qkEC=7nr|lqloMiiS z#X+29E6#_vO=wp*M{H8++*3kVRKDOBk&QwqBLO^3=tvCID-pkl&qo(;8N$JhqCGYz z@wVS}yDK;NF8NT%JDTOja~&_f_`~ikbLI0L-0xg%u7qtC<8hEL|BI7UT=J1-1kMY5 z-S$7$QgO4>Dwi)mkT2IDOQS-lVbrR{k{`$Wx+O^~zrf}6k11nHp<5Z_^T+d-;#*m; z_`v^LanF^Les#Xim5?$VlOcfbf0XMp z0%-hPjt0;3%EfigTHERSsS^#K{kagbZzc?wL$1(JUUpey+g)<3Dm?Z;&%hIxk-#_O zoU3OMv(KWA9#y|$E7~*jR-dcaX|lqF>yK8VSD=wD+I%>jNCN)JIu(zbg96#>?~(Ta z*`a|qfE>I=lNluZ{;$DrfG5zYL#ae62sD`GNC_AZXZBfN5tGAY+ULTtOEQn`%C$1| z02GRIUU^4i1pWQYa(^y_j$xQ=0ZcBHY4cNtVHtf6r&boL;FX_jbRIuv1TytrRsnwc zT4Q**;6ExiWUW|st8&36?1`E&{#?qL>&SpmfC3bt00k&O0SZun0$(j)30cCCBY*k7 zdS~uI0SZun0u-PC1t>rP3Q&Lo6rcbFC_n)UP=Epypa2CZKmiI+fC3bt00k&O0SZun z0u-PC1t>rP3Q&Lo6rcbFC_n)UP=Epypa2CZKmiI+fC3bt00k&O0SZun0u-PC1t>rP z3Q&Lo6rcbFC_n)UP=Epypa2CZKmiI+fC3bt00k&O0SZun0u-PC1t>rP3Q&Lo6rcbF zC_n)UP=Epypa2CZKmiI+fC3bt00k&O0SZun0u-PC1t>rP3Q&Lo6rcbFC_n)UP=Epy zpa2CZKmiI+fC3bt00k&O0SZun0u-PC1t>rP3Q&Lo6rcbFC_n)UP=Epypa2CZKmiI+ zfC3bt00k&O0SZun0u-PC1t>rP3Q&Lo6rcbFC_n)UP=Epypa2CZKmiI+fC3bt00k&O z0SZun0u-PC1t>rP3Q&Lo6rcbFC_n)UP=Epypa2CZKmiI+fC3bt00k&O0SZun0u-PC z1t>rP3Q&Lo6rcbFC_n)UP=Epypa2CZKmiI+fC3bt00k&O0SZun0u-PC1t>rP3Q&Lo z6rcbFC_n)UP=Epypa2CZKmiI+fC3bt00k&O0SZun0u-PC1t>rP3Q&Lo6rcbFC_n)U uP=Epypa2CZKmiI+fC3bt00k&O0SZun0u-PC1t>rP3Q&Lo6rjLmDeylt&brV5 literal 0 HcmV?d00001