{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"provenance":[{"file_id":"1AB3RNlLfkZBSZKu6_Wh20CkIpbxfJIve","timestamp":1663461789208}],"collapsed_sections":[],"machine_shape":"hm","authorship_tag":"ABX9TyPjt7Nlfw8ghpIMuJAVzzsR"},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"},"gpuClass":"premium"},"cells":[{"cell_type":"markdown","source":["#計算機程式設計二\n","#第六週上課內容\n","\n","## 主題：分析 Binary Expression 以及建構 Syntax Tree\n","\n","\n","#### 這份教材主要是解釋與 mini project 相關的 parsing 和 syntax tree 概念。"],"metadata":{"id":"9xoK4OIjIfZA"}},{"cell_type":"markdown","source":["###GitHub 教材參考資料\n","\n","[i2p-nthu 程式設計二 Syntax Trees](https://github.com/htchen/i2p-nthu/blob/master/%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88%E4%BA%8C/mid1/5-syntax_tree.md)\n","\n","\n","\n"],"metadata":{"id":"05G1Fqg6GRZX"}},{"cell_type":"markdown","source":["####Expression 運算\n","\n","像`4*x + 5*y`這樣的的運算式 (expression)，該如何用程式來分析並且計算？首先要先把每個元素拆開來，包含了數值 `4`和`5`、運算符號`*`和`+`、以及變數`x`和`y`。而這些元素如果依照數學運算的原則，應該要先算`4*x`以及`5*y`，然後再把兩個運算結果加起來。假設變數`x`的值是`1`而`y`是`2`，代入之後得到的運算結果就是`14`。\n","\n","先記住這件事：每個 expression ，最終都可以得到一個數值。\n","即使包含變數，當變數用對應的值代入之後，最後就會算出某個值。上面的運算式，可以拆解成三個運算式：兩個乘法運算和一個加法運算，其中加法運算是基於兩個乘法運算的結果。\n","\n","上面出現的運算符號`*`和`+`所牽涉到的運算，都是二元運算 (binary operation)，每次運算都需要兩個運算元 (operands)。運算的時候，必須依照運算符號的優先順序，例如先乘除後加減，而且通常是從左到右依序運算。如果想要違背優先順序的運算，通常會另外使用括號來界定順序。\n","\n","但是，假如我們不要把運算符號寫在中間，而是寫在最前面 (prefix notation)，像是 `* 4 x`，這樣的寫法，不需要括號，也能表達出各種可能的運算順序。以上面的運算式為例，原本的運算可以寫成\n","\n","\t+ * 4 x * 5 y\n","\n","首先看到 `+` 所以預期後面應該要有兩個可以\"加\"的東西，可能是數值或是變數。接下來看到`*`，是個運算符號，不是能夠拿來\"加\"的東西，所以還不能被當作前面`+`符號的運算元，還必須繼續看下去。再來看到`4`，然後又看到`x`，所以`*`所需的兩個運算元就具備了，就可以得到`(* 4 x)`這個運算式，這個運算式最終應該會得到某個值，所以可以拿來當作運算元，如此一來，前面的`+`所需的兩個運算元就具備了其中之一。接下來，`* 5 y`也構成了另一個運算式，因此`+`所需的第二個運算元也具備了，整個運算式就分析完成。\n","\n","現在換成另一種狀況，假如我們想要的運算其實是`4 * (x + 5) * y`，如果用 prefix notation 來表達，依然不需要括號就能寫出來，只要寫成下面的形式就行了：\n","\n","\t* * 4 + x 5 y\n","\n","運算的順序會是`+ x 5`，把運算結果另外取個名字叫做`E1` 然後是`* 4 E1`，再把這個運算結果取名`E2`，然後就可以算`* E2 y`，算完就得到最後的結果，符合原本想要的`4 * (x + 5) * y`。\n","\n","問題：如何寫程式分析 prefix expression？   "],"metadata":{"id":"azEB13vJtHte"}},{"cell_type":"code","source":["%%writefile E06_01.c\n","# include <stdio.h>\n","# include <string.h>\n","# include <stdlib.h>\n","# include <ctype.h>\n","\n","# define MAXEXPR 256\n","char expr[MAXEXPR];\n","\n","typedef enum {VAR_A, VAR_B, VAR_C, VAR_D, OP_AND, OP_OR, END} TokenSet;\n","\n","char sym[]=\"ABCD&|\";\n","\n","TokenSet getNext(int reset)\n","{\n","    static int idx;\n","    TokenSet ret = END;\n","    int i;\n","\n","    if (reset) {\n","        idx = 0;\n","        return END;\n","    }\n","\n","    while (expr[idx]!='\\0' && isspace(expr[idx])) idx++;\n","\n","    if (expr[idx] == '\\0') {\n","        return END;\n","    } else {\n","        for (i=0; (size_t)i<strlen(sym); i++) {\n","            if (sym[i]==expr[idx]) ret = i;\n","        }\n","        idx++;\n","        return ret;\n","    }\n","}\n","\n","/* an expression can be evaluated and yield an integer value */\n","int evaluate(int A, int B, int C, int D) \n","{\n","    TokenSet tok;\n","    int ev1, ev2;\n","    \n","    tok = getNext(0);\n","    switch (tok) {\n","      case VAR_A:\n","        return A;\n","      case VAR_B:\n","        return B;\n","      case VAR_C:\n","        return C;\n","      case VAR_D:\n","        return D;\n","      case OP_AND:\n","        ev1 = evaluate(A, B, C, D);\n","        ev2 = evaluate(A, B, C, D);\n","        return ev1 && ev2;\n","      case OP_OR:\n","        ev1 = evaluate(A, B, C, D);\n","        ev2 = evaluate(A, B, C, D);\n","        return ev1 || ev2;\n","      case END:\n","        tok = getNext(1);\n","        return evaluate(A, B, C, D);\n","    }\n","    return 0;\n","}\n","\n","int main()\n","{\n","    size_t len;\n","    int i;\n","\n","    fgets(expr, sizeof(expr), stdin);\n","\n","    len = strlen(expr);\n","    if (len > 0 && expr[len-1] == '\\n') {\n","        --len;\n","        expr[len] = '\\0';\n","    }\n","    printf(\"%s\\n\", expr);\n","  \n","    for (i=0; i<16; i++) {\n","        printf(\"%d%d%d%d: %d\\n\", (i&8)>>3, (i&4)>>2, (i&2)>>1, i&1,\n","        evaluate((i&8)>>3,(i&4)>>2,(i&2)>>1, i&1));\n","    }\n","\n","    return 0;\n","}"],"metadata":{"id":"ueZaPjLItKXw","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1666095751966,"user_tz":-480,"elapsed":3,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"8a27eae5-7e1f-4b66-8126-c47e8bd1e254"},"execution_count":8,"outputs":[{"output_type":"stream","name":"stdout","text":["Overwriting E06_01.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc -o E06_01 E06_01.c\n","./E06_01"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"15HoZpdK5iKH","executionInfo":{"status":"ok","timestamp":1666095775811,"user_tz":-480,"elapsed":9834,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"2eb8b169-bfaa-43e1-97b3-8b97d8d73f8a"},"execution_count":9,"outputs":[{"output_type":"stream","name":"stdout","text":["| & A B & C D\n","| & A B & C D\n","0000: 0\n","0001: 0\n","0010: 0\n","0011: 1\n","0100: 0\n","0101: 0\n","0110: 0\n","0111: 1\n","1000: 0\n","1001: 0\n","1010: 0\n","1011: 1\n","1100: 1\n","1101: 1\n","1110: 1\n","1111: 1\n"]},{"output_type":"execute_result","data":{"text/plain":[]},"metadata":{},"execution_count":9}]},{"cell_type":"markdown","source":["####用 Boolean Expression 來練習\n","\n","整數運算還是稍嫌複雜，我們再更簡化一點，先從 Boolean expression 開始處理。假設只有兩種 Boolean operation，`&`和`|`，分別計算 AND 和 OR，另外也規定只有四個 Boolean 變數，`A` `B` `C` `D`，每個變數的值只會是`0`或`1`，例如  \n","\n","\t| & A B & C D\n","\n","底下是完整的範例程式碼，我們會再一一解釋每個函數的作用。\n","範例中有特別處理輸入資料裡面參雜的空白字元，如果假定輸入資料全部都相連不會有空白，程式碼可以再簡化一些。\n","\n","```c\n","#include <stdio.h>\n","#include <string.h>\n","#include <stdlib.h>\n","#include <ctype.h>\n","\n","#define MAXEXPR 256\n","char expr[MAXEXPR];\n","\n","typedef enum {VAR_A, VAR_B, VAR_C, VAR_D, OP_AND, OP_OR, END} TokenSet;\n","char sym[]=\"ABCD&|\";\n","\n","TokenSet getNext(int reset)\n","{\n","    static int idx;\n","    TokenSet ret = END;\n","    int i;\n","\n","    if (reset) {\n","        idx = 0;\n","        return END;\n","    }\n","\n","    while (expr[idx]!='\\0' && isspace(expr[idx])) idx++;\n","\n","    if (expr[idx] == '\\0') {\n","        return END;\n","    } else {\n","        for (i=0; (size_t)i<strlen(sym); i++) {\n","            if (sym[i]==expr[idx]) ret = i;\n","        }\n","        idx++;\n","        return ret;\n","    }\n","}\n","\n","int evaluate(int A, int B, int C, int D)\n","{\n","    TokenSet tok;\n","    tok = getNext(0);\n","    if (tok==END) {\n","        tok = getNext(1);\n","        return evaluate(A, B, C, D);\n","    } else if (tok==OP_AND || tok==OP_OR) {\n","        int expr1, expr2;\n","        expr1 = evaluate(A, B, C, D);\n","        expr2 = evaluate(A, B, C, D);\n","        if (tok==OP_AND) {\n","            return (expr1 && expr2);\n","        }  else {\n","            return (expr1 || expr2);\n","        }\n","    } else {\n","        switch (tok) {\n","            case VAR_A: return A;\n","            case VAR_B: return B;\n","            case VAR_C: return C;\n","            case VAR_D: return D;\n","            default: return -1;\n","        }\n","    }\n","}\n","\n","int main()\n","{\n","    size_t len;\n","    int i;\n","\n","    fgets(expr, sizeof(expr), stdin);\n","    len = strlen(expr);\n","    if (len > 0 && expr[len-1] == '\\n') {\n","        --len;\n","        expr[len] = '\\0';\n","    }\n","\n","    for (i=0; i<16; i++) {\n","        printf(\"%d%d%d%d: %d\\n\", (i&8)>>3, (i&4)>>2, (i&2)>>1, i&1,\n","        evaluate((i&8)>>3,(i&4)>>2,(i&2)>>1, i&1));\n","    }\n","\n","    return 0;\n","}\n","```\n"],"metadata":{"id":"mviKuWaapY32"}},{"cell_type":"markdown","source":["####用 Boolean Expression 來練習\n","\n","整數運算還是稍嫌複雜，我們再更簡化一點，先從 Boolean expression 開始處理。假設只有兩種 Boolean operation，`&`和`|`，分別計算 AND 和 OR，另外也規定只有四個 Boolean 變數，`A` `B` `C` `D`，每個變數的值只會是`0`或`1`，例如  \n","\n","\t| & A B & C D\n","\n","底下是完整的範例程式碼，我們會再一一解釋每個函數的作用。\n","範例中有特別處理輸入資料裡面參雜的空白字元，如果假定輸入資料全部都相連不會有空白，程式碼可以再簡化一些。\n","\n","```c\n","#include <stdio.h>\n","#include <string.h>\n","#include <stdlib.h>\n","#include <ctype.h>\n","\n","#define MAXEXPR 256\n","char expr[MAXEXPR];\n","\n","typedef enum {VAR_A, VAR_B, VAR_C, VAR_D, OP_AND, OP_OR, END} TokenSet;\n","char sym[]=\"ABCD&|\";\n","\n","TokenSet getNext(int reset)\n","{\n","    static int idx;\n","    TokenSet ret = END;\n","    int i;\n","\n","    if (reset) {\n","        idx = 0;\n","        return END;\n","    }\n","\n","    while (expr[idx]!='\\0' && isspace(expr[idx])) idx++;\n","\n","    if (expr[idx] == '\\0') {\n","        return END;\n","    } else {\n","        for (i=0; (size_t)i<strlen(sym); i++) {\n","            if (sym[i]==expr[idx]) ret = i;\n","        }\n","        idx++;\n","        return ret;\n","    }\n","}\n","\n","int evaluate(int A, int B, int C, int D)\n","{\n","    TokenSet tok;\n","    tok = getNext(0);\n","    if (tok==END) {\n","        tok = getNext(1);\n","        return evaluate(A, B, C, D);\n","    } else if (tok==OP_AND || tok==OP_OR) {\n","        int expr1, expr2;\n","        expr1 = evaluate(A, B, C, D);\n","        expr2 = evaluate(A, B, C, D);\n","        if (tok==OP_AND) {\n","            return (expr1 && expr2);\n","        }  else {\n","            return (expr1 || expr2);\n","        }\n","    } else {\n","        switch (tok) {\n","            case VAR_A: return A;\n","            case VAR_B: return B;\n","            case VAR_C: return C;\n","            case VAR_D: return D;\n","            default: return -1;\n","        }\n","    }\n","}\n","\n","int main()\n","{\n","    size_t len;\n","    int i;\n","\n","    fgets(expr, sizeof(expr), stdin);\n","    len = strlen(expr);\n","    if (len > 0 && expr[len-1] == '\\n') {\n","        --len;\n","        expr[len] = '\\0';\n","    }\n","\n","    for (i=0; i<16; i++) {\n","        printf(\"%d%d%d%d: %d\\n\", (i&8)>>3, (i&4)>>2, (i&2)>>1, i&1,\n","        evaluate((i&8)>>3,(i&4)>>2,(i&2)>>1, i&1));\n","    }\n","\n","    return 0;\n","}\n","```\n","\n","首先，我們用 `enum` 和 `typedef` 自定了 `TokenSet`。其中包含的 `VAR_A` `VAR_B` `OP_AND` 這些都是對應到整數值，`VAR_A`的值是`0`、`VAR_B`是`1`、`OP_AND`是`4`，‧‧‧ 。這樣的寫法是為了方便我們之後在做各種條件判斷的時候，不必直接用整數值，而是可以用看起來比較有意義的名稱，`VAR_A` 代表變數 `A`， `OP_AND`代表運算符號`&`。\n","\n","再來看 `main` 裡面做了哪些事情。一開始是用 `fgets`讀取整行輸入資料，\n","`fgets`的用法請參考\n","\n","<http://pubs.opengroup.org/onlinepubs/9699919799/functions/fgets.html>\n","\n","讀取到的資料放在 `expr` 陣列中，`expr` 陣列是 `global`，全部的函數都看得到它。\n","\n","之後的`for`迴圈，則是用二進位表示法，跑完`A` `B` `C` `D`四個變數，`0`或`1`兩種可能的值，全部16種組合(2的4次方)。關於位元運算，可以複習「計算機程式設計一」的教材。"],"metadata":{"id":"CcRwh3m2cesR"}},{"cell_type":"code","source":["%%writefile E06_01.c\n","#include <stdio.h>\n","#include <stdlib.h>\n"],"metadata":{"id":"bJ1QleIptpJo"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["%%shell\n","gcc -o E06_01 E06_01.c\n","./E06_01"],"metadata":{"id":"9Fuv_VafwfkA"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["#####函數`getNext`\n","自己寫的`getNext`函數，目的是為了找到下一個非空白的字元，並且判斷出是哪個 token，然後把對應的 token 代號傳回去。\n","函數中的 `static` 變數 `idx`，是用來記住目前讀取到`expr`陣列的哪個位置。\n","\n","#####函數`evaluate`\n","這是整個程式中最關鍵的函數。用遞迴方式來算出 prefix 表示法之下，Boolean expression 帶入變數值之後，得到的運算結果。\n","依照目前讀取到的 token，決定要做哪些事情。\n","1. 如果 token 是變數，就把當時的變數值傳回去。\n","2. 如果 token 是運算符號`&` 或 `|`，就先把後面應該要有的兩個運算元，分別透過遞迴算出來\n","           expr1 = evaluate(A, B, C, D);\n","           expr2 = evaluate(A, B, C, D);\n","\n","    然後再做對應的組合及運算\n","\n","    ```c\n","        if (tok==OP_AND) {\n","            return (expr1 && expr2);\n","        }  else {\n","            return (expr1 || expr2);\n","        }\n","    ```\n","\n","上面用 `&&` 和 `||` 條件判斷來當作邏輯運算，是因為C的 True 通常會用整數`1`來表示， False 會用整數`0`表示，恰好符合我們想要的 boolean 運算結果。\n","\n","####處理十進位 + - * / 運算，從 prefix 轉 infix\n","底下是「計算機程式設計一」教到 recusion 時，介紹過的範例。把輸入的 prefix 整數運算，轉成 infix 並且算出最後的答案。\n","\n","```c\n","#include <stdio.h>\n","#include <ctype.h>\n","\n","int calculate(void);\n","\n","int main(void)\n","{\n","    printf(\"=%d\\n\", calculate());\n","    return 0;\n","}\n","\n","int calculate(void)\n","{\n","    int c;\n","    int ans;\n","    int op1, op2;\n","\n","    c = getchar();\n","    if (isspace(c)) {\n","        ans = calculate();\n","    } else if (c=='+') {\n","        printf(\"(\");\n","        op1 = calculate();\n","        printf(\"+\");\n","        op2 = calculate();\n","        printf(\")\");\n","        ans = op1 + op2;\n","    } else if (c=='-') {\n","        printf(\"(\");\n","        op1 = calculate();\n","        printf(\"-\");\n","        op2 = calculate();\n","        printf(\")\");\n","        ans = op1 - op2;\n","    } else if (c=='*') {\n","        printf(\"(\");\n","        op1 = calculate();\n","        printf(\"*\");\n","        op2 = calculate();\n","        printf(\")\");\n","        ans = op1 * op2;\n","    } else if (isdigit(c)) {\n","        ungetc(c, stdin);\n","        scanf(\"%d\", &ans);\n","        printf(\"%d\", ans);\n","    }\n","\n","    return ans;\n","\n","}\n","```\n"],"metadata":{"id":"0JmfW6E6wtN7"}},{"cell_type":"code","source":[],"metadata":{"id":"VRy2iKRgHRuF"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["####建立 Syntax Tree\n","\n","底下的圖，是大家在邏輯設計課裡面會看到的邏輯閘。\n","\n","![image.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZoAAADfCAYAAADP5BUIAAAAAXNSR0IArs4c6QAAAERlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAA6ABAAMAAAABAAEAAKACAAQAAAABAAABmqADAAQAAAABAAAA3wAAAAA44qyoAAApSElEQVR4Ae2de2wUV57vT3XbxmAe5u0kJDQQDcYOiSfZzMK9O4mZzcxllLk7JtIoEJDGljCPy0oJ0r2asNIIZ2dWBGnuhPtHMiRwZaILsfkncXZnFO/sA5O7KzybSeJkAjhPNyEPJwQwb7+6a38/29WuPlRXV3VX16u/P+m46pw6z0+1+9e/3zl1SggICIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACIAACASDgOJxN9dS+69QKJf6Eaf4agr9UnqooxsPnFSDOUDudtaP0i5FJLtHR0vi7dtXxIM5TvQaBEAgFwJZvx1yqdRGmTbKuz5D/l2U/nSGa6FMDq6isX07eumDdzSpio6XttT22C6NAiAAAoEi4KWiYSvmIgXZmtEAdtMJWzVFI0WkaCbvqaLGhap0zhoWTz23o7Z/8gLOQAAEwkIg4uFAGqjtTEqGu7WKQjWfQEJMQFViNLptF0uSfaRo9zS2vl0Z4tFiaCBQlAS8VDQ/lYgPSHGOZnKrGWRFkrME3J0uikQi/KPjyaHhMlI4p55obO0z+xHi7FBRGwiAQEEJeKVo+FdrvTSyp6Q4Rx81SEOSKwS88apGIoI+G+ozI4lrpx974WSdK0NFIyAAAgUl4JWiYUtF/4t1kOL7KXRR0Au7zvBloydSLOfkUlPV5IkNz59qKJYhY5wgEFYCXika2VLpIMCsbI4agJbzGmRBUr4EVHc9ZZa6y+60SER9heZunrRUAJlAAAR8ScALRVNFJOolGq9OxFnhyLJeTkDcaQKqULzxlFkdyJ6NB0+2Yt7GKi7kAwF/EfBC0TRKCNiS0RRMP513SddjFK+X0hB1lIC/tczYUFXRODxylZ+7goAACASMgBeK5scSI81tpiW/qJ3ojnCf6WA4depHd5nZ2BQl0gA3mhkhXAMBfxJwW9Hw5P4qCYXmNtOSZcXD6Q0U9IsHtLw45kHA5+6yTCPbs+ngybWZLiIdBEDAfwTcVjTyfIvebabRGaCTLi0ycayiY72UhmiREkgkRNv635yOFenwMWwQCBwBtxWN7AIzsl4YIlafBe6j5F6H+VmbaEnyNSwOcI85WgKBfAi4qWjqqKPsOtNLnCL1BoGtGlnYGsrkPmuha7xAN9Dhq/ffoCEUVoI2L2NCo3pk9MY2k+u4BAIg4BMCbioa2ZphBE9SOGYQ+NUBsrCSaZATEbdHIKDzMhkGqf4MVk0GNEgGAR8RcFPRsEWSr8gr1vKtr8jK+/CpzPzuQNXI6PUn8qsCpUEABApNwC1FU08DiTkwGLZoKh2op0irCMDzMjbvTDKZ3P0/nj3Ji0UgIAACPiVQ4lK/jNxmT1PbQ1na/yldj+nyaO6zQ7o0nFoiwNZM+BQNb1NzsUz9GQ1upyUMyAQCIOA6ATe+eVg59FHQ/+rspfgKC6NtoTy7pXydFP+hlBaKaFG++MyZO9d/pLn2FmeqQi0gAAJOE3BD0aylTr8mdfwpirdIaUbRako8bXCBv1T6DdIDneSEovn5j2JiedW0FIfh0aT429/GRfybwVSafFIxJSp+2bBUzJ9Rmrp0eTAhdrZ/KIaovCz33jFDPP7QIhGNKELON3d6qfjVT+4UpVHzj9aJjy+LZ499JledR1xZfaS5pjuPClAUBECgQATcmKMxcpt1WBwPWz4cZOG5GohEgL/kl86fmpZaVhIRD6+cl5YmR8pL6cGUaele1JnlUbH5u7fKWcfiC2eVjSkZw4sWE1cvmykOb64RO9YssljCPJsiVP5BAwEBEPAhATcUjawU4sShxwYLPLxpEdZ3lsw0tCRqb6sQU0jh2JX7Fk8XsXnldovZys8K57lNy3Pqn74hmoEy+kGjz4JzEAABjwjY//ax19FKyi5/U71orwrRTvllv0+VzTpCn53dXz+omZMa53ufXxOJJC8AEIKtk7tI2VgRdrX19l8fy8rWELvJ8hF2kW06eCotHP9gIK1KM+spLaN5pBrb0pgDwlUQ8IpAoRUNf6OwL4cd9lpooXM7wq4zuY4VdioohrzLF04TcyrG3V+sLP759AUxoWfGhr9q6SxLGFi5nL0wmFJSD5HyysUaMmvswOtfiF///myqDc7rhPUULVEbzNrFNRAAAW8IFFrReDOqImz1vtiM1LzJ2YtDoufTq+KTczdSJOy4z9ga+ujr8bJsbTx899xUPU6dvPXpFfFvH11KVWdlLimVOeOJujDjJVwAARDwjAAUjWfonWuY3WY1t0y6xt45e1WMkjnzxzNXUo3YcZ9xod+9ez5lcRTCquE2Xn7rnBhJjLv3OL5gZqkooZVsOYuStoQ+52pQEARAwFkCUDTO8vSkNtltxtYCy3/0XU77Iv+runmWv8i5jkJbNYMjSTFwfTTFbP6M/FazJZNKLFUZTkAABHxDAIrGN7ci947IbrPPLoxvuHD+6kia++z22VPEojlTLDdUaKvm2lBCXLg2Yrk/2TJGFJUXibRQYDMpjCFG44KAQOAIQNEE7paldziT20zLpXef2V1FJls1VleuaW27fUwm4TpzmznaAwErBKBorFDycZ4HvlWZeqKfV5tpbjOty7L77J7bp1t2n3EdeqvGjutNa9/syEpyTsXkbgRmea1c4xeiWcmHPCAAAu4SSH8c3N220ZoDBP5s8eRzLmyx8FYyZqK5z8y2pNGX16wa3tZmGe06wIrKKZF3JDh3ZTi1ACGXNmgnZ/l5q1yqQRkQAAGHCbitaPjhzUYKZg9c8rM3PRT4S6ObAiQDAaMtZzJkTSVr7jOrioYLslVz54KpY8un2ap5Mz65mi1VcQ4nj9w7P20nA221XA5VjRWJRJX+XMuiHAiAQOEIuK1o1tNQfmNjOL2Udy8Fo90BbFQTzqyZtpzJNlperszKw2jDTKOyequGLaI/kqLhXQd4U81chXcc+Is7Jx8iNXL72a07mYzEqUzLRKBDoKWPeh8L9AjQeRCYIOC2onnQJvlqyt9Kgd+suc5m2dBn17vN5F2U5cHrd3XWnql5U/ecjZxfjmtWDVtE36ueLV+2FW9+4FbxIM0t6eXNM1dNd5jW5810Ho0kYdFkgoN0EPCQgNuKJtehNlDBlomQax2hKie7zU7S0/zGFgqv8lXGHt7Uvz6At6Sxo2j0Vo3+dQLZoPKmmauX1Zhm+5h2MHj++OemeaxcpGc/oWisgEIeEHCZgB9Wna2hMbMPht8xw+cbKMQpyPK4nFDMcdlt1v3J5HYuRlzk1Wd2tqTR6tOvQNPS8j3yppu7X+0b28kg37oiQvkq3zpQHgRAwHkCfrJo+Neo9ou0k85PU6jSDZl9LdUUeN6m6EV2m/H+ZMbCOlwI7eFNzarJxX3GVg3vT6Z3e+W6Uoy3n+HgrChdztaH2kAABJwgMP4t5ERN1urg+ZZGKStbMV1SGkd50cA2KZ2tnXYpLTRRJ96wGRoY9gcSttc59xGCmIRhCcXjUhqiIOB7An5wnWWCNGhwQbN4DC4hqcgJdBT5+DF8EPAtAT8rmnqJGiueTG6zFrrGs96BDl+9/wYNAZILAUURr+ZSDmVAAAQKT8CviqaFhl4nDX8fxWHRSFAQFYJ3BCiJTusCCxAAAX8S8MNigGcIzYAOTxWdV+vifMpukV1SGqIgMEYgGlU6DjUtMXK1ghAIgIAPCPhB0ciWi4xlPyXslBMRBwGNAL2HhnePgIAACPiUgF9dZ3pc2yjyJYX1+kScg8AYAUUcemlLbQ9oFIaAqqqrKJQXpnbUWiwEgqBo+F5UUmij8CRHDKSF0nipdqDDwuX3GwwNSZkI8NzMrCG4VDPxyTedFEwDheMU+H8PAgI5E/CDollDvdcrCN5Ii5+XMfqVupvSYxQgORPghXkhkYiy/7kdtVggUrjb2UtVlyqKwgqnRWum/n89W6Wd4wgCVgj4YY5G7ucAJbRT6KBwjMIqCpqwCb+VAhYGaERsH1mnB1/obZoDs0cxN1PIO0kKpjeRSJyj4wJqZ/ebH35+7hevfLC7dEpZ2aYDJ/clkkqPoqhxuC4LeRfCUbcfFY1GdpBOXqSgVzR8rZr/QIqbQDQqNjy3FdZMoT8FpGSua23ULa3634urzkW+GSotJbt4dyQybh3TjhacpUdVk/GIEnkHCkgjhqNGwM+KhvsY1zqqO/J8DSRPAip9R9BDjkGVXYc313YGtfMB6zf/4BuTSCQy5efrVozserlPXB9OaMnasU5RInX0sWowU0BCjPa2bb27VyuEY3EQ8LuiMbJe+ovj1hR2lEFVMvSrueOlLSufLiwd1K4jwP9vqf/DudPLSnd+f5H4u9+d0WUxPZUUUFQ89sJ7g6qIdEcUtVtVlXdUdbQHyseUYeAv+lnRxIjuzwwIv2+QhqQcCbDCYesmINJbVjqdF4pAPCSw4pYKsWlVlTjcndtvPnLHlStCrach1NMcD1nWUD4e3k5XmvaDoqmTRlpO8QcpbKMgu8kGKG0/BYhDBDQXWgCUTU9iNLLuSDN2AHDo1udVzdq75ohPLwyK1z/gf8n8xYryqRxRu7DKMH/WXtTgB0XDW9BYle2UMbefUVZbKMJ840qGJ2x8a9p0lpYMbzjS/G1nvtWK8B4XYshN//UW8cXAkPjo6xuFqJ4snXTL51KZELTwgOd3usjldhyKpyDYC1KpHxSNlYHxhCQrmXYrmZEnFwL+VDJJoe5ra74LWxDlckudKZNRuZdGFbHz+7eLv3n5E3HpxqgzrWWvpZqyVJPLbZuseMpKhzoPNeHHSHaE7udw+4HNf7Q5RLZe9lFYQuEQBUgxEVDFdigZb284PaiZUdFwz2ZNLRF//b3bvOwkK55tpHjaRkbLLj524E8n6Bmflo0HTq3yslNoO50A+0vclHJqbD2FWJZGu+g6Kxk2k4tG8IbN8VvNK8voC25Xka9E6iMaMenDzz+44lJaQaP0wGYrLWtuzNZIYV7Nna1V8+vkEh6gpdadyWTk1bLSqdjh2xxXQa+67TpjF9ihgo4IlQeWQEIku+kDuevIlpVdgR1EkXb8kXvnj83VvPvZVd8QoBWVlTSXs56snfXDI9cGNx18rwNKx5vb47brzJtRolW/E+ilrf7XtTevXH24GUrG7zcrU//YhTZ/Rmmmy56m88KCCaXTRkrnIimdtk0HT671tFNF1LjbFk0RocVQzQgkVaUrQq9fTowqHe3bV8TN8uKapwTYhW1JppVFxY41/DBnXIwk/Lm4hAcyrnTGXPjrNx58Ly5U5flZw+IQlk5bus05ZYKiyQkbCo0T4C8Thf5xLT302UnZ/pBURbxyRHQ+t6PG8hcYaHtHgOZnhuy0fueCqeK/3zNP8JxNIERVYtTPPbSCbQ9ZOe30eX4R2xs5f+fofx8CAiDgQwK+WAww8XqA3Xb4sDXT8vd94sx5npINpPSQK/eptq01HYHsvQ87jTkaH94UdAkEgkyAn6/Z8sCtgo8BlTparfYKrQI9/dgLJxsDOgZfdRuKxle3A50BgXAQWDy3fMyFFvDR0IOhopXmcfo2vnByW2NrX3nAx+NZ96FoPEOPhkEgEATiufaS52pY4QReeB5HEb8ZGb3eRw+CPgGFY/+OQtHYZ4YSIAACFgiw64z3QwuRVNGyl2eGhq9/ybsPNLa+XRmisRV0KFA0BcWLykGguAnwKrQHvhWu7+NIhB4EpTeMDg2X9UHhWPt8Q9FY44RcIAACORJ49P4FQV4YkHHUmsKhPdZO8xxOxoy4IKBo8CEAARAwI5D3GmXeePPR+xeatRH0a1U8h8Or1LDbgPGthKIx5oJUEACBcQL9ToD4yxWzxa2VU5yoys91VNNGnq9teOHUsQ3Pv1vt54663TcoGreJoz0QKEICvDCAXWjFIBGFX1OtvE0Wzh6sUBu/41A0xfDJxxhBwAcE7ls8w7ebbjqNh7bu4XXdT9KS6Lc3HfhTvdP1B60+KJqg3TH0FwQCTOC/1c4NcO9z6nq1KiLHNh482VrMy6EDu0dETrcchUAgOASM9jrrpu7nPTlvB0FFRcW0+++//zt2ypjlfej7PxBnFj0irg8nzLKF85qixlV6HcZLW2p7wjnAzKOCosnMBldAwEsCRorGy/440nZjY6P4y617ROd7FxypL2iVJJPJwYgS2XlkS+3+oPU9n/7CdZYPPZQFARCwTaAI3WcpRmNzN7wUesyVVjx7p0HRpD4COAEBEHCDAL+FMxR7oOUDSxWNtFDgRLHM2+DFZ/l8WFAWBEAgJwK8As2p99X8cOVcsfHPjR8I/fjcDfGLf4iLUXrjnpHMnV4qfvWTO7PuXPDMP50Vb565YlRFPml1tKvAMVI2aw41fXsgn4r8XhZzNH6/Q+hfsRJYRQPnJbKeyzESpzpRVVUlqqurxUdf3xh7OVo+9ZopGLneTArHqqLh+i4PJsTO9g/F0GhSrj7feE9pyXColQ0UTb4fEZQHgZAToLdsGpsDeY57x5EPxKUboznV0kwvVnvQ5madRorCjqLhjmZSWDkNIr1QqJUNXGfpNxsxEAABlwjcc/t08foH9j1GbMnISubEx5fFs8c+S+u5rIxmlkfF5u/eelM+fSG5Htlqun32FLFozhQR/8bxVeZ1wyMlrdSXdfr+hOUciwHCcicxDhAIGIE75tj3DFZMiYof1MxJGynPn8hKhjMceP0L8evfnxUJ3fzMfYuni9g86+2+9qfz4rhOGZaVRMTcitK09p2KKEqkIay7QEPROPUpQT0gEFIC5Dlz/Oc7o+LVZ3aF322jL8eurHfOXs1YzVufXhmbD9IysKK4944ZWtTS8bOLQ5byOZJJEbvDuD8aFI0jnw5UAgKhJtBfiNHNoxVfdmURua708vc932RcUabl+6O0WuyWWel1aPkyHfVtDtNCgPPXRjJldSK9amT0xjYnKvJTHVA0frob6AsIFBEBvWViddhVM8tSWa1+6X91aTjNfbZgZqkoiVhbByXP85wl6+azC4W1cFSReDQ1yJCcYDFASG4khgECQSMwrSwq+KVoVlee8fzMnALNj2jsVi+bKVYvq9GiaUdWbK3//mVWCyqtUA4RRUR4aTtLC4XdfBJwWQNFE/A7iO6DQJAJjCQKsnLacSQFXNbseF/9WCFcZ368K+gTCPiLgP01yBb778Uuzl9fHim4VWJx+IbZ6KmlgvE2bNCFRCgaFyCjCRAIOIGCfPGdu2JvUv3aUEJc0E3EW11qvHBWmYjq5mS+vJR5joWfo9l08NRYeL//euq2LZs/VWx98LZUvLAnya7C1u9+7VA07jNHiyAAAkQgF2um//JwGrtVS2elxeWI0XM3VvdY+zU9n6NXhnafwZH7Yj0eedV63mDkhKIJxn1CL0EgdARyUTRvxq+krSDL9uUvP3fD29C89/k1SyzZgvr9qcn35rAF9fDKeZbK5pGpv6x0WvtE+RY68vK4oIcuKJqJO4oDCICAuwTOnM/swsrUE6MHMH/ZsFQ8cu/8m4r8/Eexm3Z1/r///wtbm2LyFjluWjWqquw81LSkIA/I3gTIxQSsOnMRNpoCgSASoJ0B+hXF2nMndsZ3+ktrloVc53Ndn9+0tT8rGiNloy/L8y92t/pnq+YU9fPBGZVjVWk7CxRgrzOhqsmOl7as1KwZfdcDfw6LJvC3EAMAgYITKMgv7NNfTk622xnB+asj4q9f+iDN0shW/uW3zhnuh5atHF/nsvpl2A/RXmtTyI3mqChqvKx0tMnROn1UmcO0fDQydAUEgk2gj7rPD5l4HqLRaCNbNE6Epqbx71KekM9ljka7pWxp7Dz6odj6/943VTi84SavImNlkauwYvuE9lTThHeBvuu2Ci2a95GXM6tJZV2YX34G11neHxNUAAIgYJdArtaM3I6mcOR0q3FWIk2tp7Nm/8Vv41nz5JIhmUwORiLRHx5prunJpXxQysCiCcqdQj9BIEQE7M6VhGjoqaGwkolGI+tIyXSnEkN6AkUT0huLYYGAXwl8MTAkcl0I4Ncx2e2XpmQOb67ttFs2iPmhaIJ419BnEAgwgX/tvRjg3uff9WRSDLAlUyxKholhjib/zw1qAAG3CCyhhuJuNaa1Q8ubW+h8txbP58irt55o/zCfKoJdllaX0aIKVjKhnpORbxIsGpkI4iAAAgUjcOLjS5ZfC1CwTnhUcUIku0ujI99+aUtxKRnGDUXj0YcOzYJAgAg4tqnmP56c3NIlQOPPv6uKOFReMn1NmJcwm0GC68yMDq6BAAgwAUcUDW/nYnVDy7Bgn1i+vOvI5pp9YRlTLuOAosmFGsqAAAjYIsBzM0ff+NpWmaBnZleZItQmWr7cG/Sx5Nt/KJp8CaI8CIBAVgL/cvpiUc3N0M5wT7U3r2zJCqZIMkDR+OhGbzxwkrcbCaBwt+lfy1x2KfQLb3S0JN6+fUXcPCuuhonApRuj4h/e+SZMQzIbC1kvStPhIngI0wyCfA2KRiaCuAUCsmLJqmS4zj0qrT2JliQFKdQeKvFqIplob9t6d9G7FSwA9zpLfz4d4H3GWNmEWcYewIxE9paUTHs6jNv853vvoGjyJVg05fXKxZJiMSNTR7XV0R5Pu0np9FJtR0tKhvcV64ocM1A+uTaYaz8++vqGYLdZyKVTTZZsP7wVlnqm+wxFk4kM0icIaAomb+WSiWg1tbB7eKTscVI6e0tLppHCCd+LnzINPszpvADghde/CO8Q+eFLoWwvpif8c72ZXiiaBurs41k6zO6UryjwMZQvAsoyfh9dLpiCSRsj7UJfSQl7RhLXtm54/tTOtq01HWkZEAkcAZ6X4X3NwiYpN1m0Am4yizfXC0XzDPUtlqV/9brre+j8/1Ao6nXoOh4unLJyYUvGA1GVWCSivrL+wJ+6xWjJBiwc8OAeONAkPy8TtgUArGBERNk/ezSy97kdtXnNWzmAOFBVeLEzQMwmIc7PyulJm+WQPWcCHikZXX+jIrKKFg6ceOyFk3W6ZJx6QyBup1nNZcbHsEhSqPtIwSxpa75rJ5SM/bvqhaKRezlACV0Tgc8zCVs2azNdRHooCVTRe9RPkCutIZSjC+mgjr7xVXh2AKCtYxJQMHl/Uv2gaHpoFGsmwmw6st+G4zw/I8ujcgLi+ROgV8n6ViKRSDm70jYeOPWEbzuJjqUI8AvNOt8L/H5m7BZ7etawuOXI5tomuG9TtzfnEy/maKx0tosybadwTMpcJ8URzZMAKxmaiA+AqM/QqrTyI821Twegs0XZxXNXRsTzxwO9yqyX/h/2lpVOa8fKR2c/wn5VNDzKLgoDFCopaFKtneDoDIFgKJnUWPeQG60XK9JSPNw6GczWEM/HPHvsM3F9OJEtq9+us/XSQT+3XiyGVyp7Bd/PioaZlEtgjNxpUhZEw01Abd3w/LukbLCjgFv3mV7U1U8vPzNt7nB3v+CHMwMiY8qFtkQ6erh5ZVdA+hzobvpZ0TQQWVnRvBpo2uh83gQiEbZwo680tr69GjsJ5I3TkQr4yX8/P/3Pr06mz003DfY4WS5dsFwcue22KvGjomHl0kiBV5npJU6R/foEnOdKgCdlzH+h5lqzS+Wqh0dKWqmtdS61h2YyEGArhq0Zn0mvoqg9qhr5A1liXW1bi++Nlj67H8IPiqaeoGT71uuiPE0UfPeJpj4FULLh9v+QFCXSwMueMV/j3b3ijTKf+aezwrPnZWgLmGQyEo8q6vGkKuLk4uuFteLd58GsZT8oGrP+8TWeiITLLBsli9d58j+Lu91iTd5no2XPu6kXNJELKTSBRCJ5JRqNzNDaYeXCSqYguzJPKBCtrYii0gvExFAiqfREI4mBmcORXjw0qdEJxpF9KG5Lrj+nWeHspBBa9xkt382Vjdv30DftJZPKupBaNX0EOSaBXkLxuJTmSnTgyo3Ls6aXpxRN679/mZqXoR8uA6pQeow6QkqCd+fmfQsnRaH5EpW2c5mQkpLRHsy3aTTCefSDookT2hcn8C6kYzUFnqdZNZEmH9gvL/+KbaE0/nUbaHnofx4SC5ffH+gxeND5HtrxmRYGLEl9cXnQh0I06StFk0gkztDDs3fwQGnPr/3RaJSfc4OAgCUCfnCdxamnLQa9raO0Vgp81AsvEuikELYvFv0YHT9nd1nAnpmxyqBuZPTGNsq8z2oB5LNPgOY/FnApmlzvJoXDngUICFgm4IctaDJ1tocusPUiKxS2eDhAbBCg5Z0hFvWnIR6c50Mj5dJAiqacjv10XEdB/p/0vI/ogL8J+P3rJ074WOHIAkUjE8kSD8sCgAzDrFv/m9OxDNeQnCcBUiwdVMWGCSXTn2d1KF6EBPyuaPiW4INdhB9Mu0OORpNr7ZZBfusESMm0U+i2XgI5QWCSgB/maCZ7c/NZOSXV35wseqW0FopzCLTQQgCaSXFWfv6jmFheNS1V6fBoUvztb+Mi/k1m70fFlKj4ZcNSMX9Gaarc5cGE2Nn+oRii8rLce8cM8fhDi0Q0ogg539zppeJXP7lTlEbN152c+Pjy2F5Zct2W44r4MeXdbzk/MoIACLhGwM8WTSVR4MUAfNQLWziyotFfx/kEAf6SXzp/ahqPspKIeHjlvLQ0OVJeSvu8TEv/DTKzPCo2f/dWOetYfOGssjElY3jRYuLqZTPF4c01YseaRRZLpGejlVD1ja19/MMEAgIg4DMC6d8m3nQuRs22SE3fQ/F6CrKS4Wx7KWT+Oc45IGMEvrNkpqElUXtbhZhCCsfIOjFDd9/i6SI2r9zUGjIrb+UaK5za25ZntJ4y1cHvrRkavrGWrvN8AgQEQMBHBPyiaHZbZNJJ+eAesQCL3V8/qJmTyvne59fEilumjVkebJ3cRcqGX1KVTdjV9gm52arJ/cbWELvJzNxu2eozcpE1P3CrePBbk78pNOuJt523I9GIWkf5oWjsQENeEHCBgBeus1ytEVYwRsudXcAUvCaWL5wm5lSM/45gZfHPpy8I2g8qJauWzkqdm52wcjl7YVAkJgo/RMqLrSEn5cDrX4hf//5sqg2uW7Oe7LRDw+MHfiEgAAI+I+DsN4a1wbFVYlV6KOM+Ckso8JPIuSopKlpccl9sRmre5OzFIdHz6VXxybnJ94Vo7jMrVNga0t41wtbGw3fPtVLMVp63Pr0i/u2jS6kyVuaSUpknTlQ1WSWnIQ4CIOA9AS9cZ2yVsIuj0mT43XQNSsUEkNkldpvV3FKRyvLO2atilCySP5KrTFuBZsd9xhX97t3z4s4FU8eUF1s1HLc7x5PqUIaTl986J/7LslmpeaUFM0tFCa1k475bkaQioGisgEIeEHCZgBcWDQ+RLZUukwAlQ3ByFdltxtYCy3/0XU7b0v2v6uaNfZFbaYfrKLRVMzhCb6i6PprqzvwZ9lazRRWFFU0LBdZMQQ8xGgMEBEJBwCtFEwp4fh2E7Db77MLQWFfPXx1Jc5/dPnuKWDRniuVhsBVTyLmaa0MJceHaiOX+3JRRVWI3pSEBBEDAcwJQNJ7fAmc7kMltprXC7jNNtFVkWjzbUbZqeOUaBARAAASyEYCiyUYoYNcfoGXC2hP9vNpMc5tpw5DdZ/fcPt2y+4zr0Fs1dlxvWvtmR1aScyomdyMwy5vhGj/MCwEBEPAZAS8WA/gMQbi682eLU++mGnvuhbeSMRPNfWb12RjNquFFBcto1wFWVE6JvCPBuSvDKVedxTagaCyCQjYQcJMALBo3aRe4LaMtZ7I1add9xvXJVk0prQxzQh65d35qxRnXp62Ws1E3K5oWCtyhMIY4jQsCAoEjAEUTuFuWucOZtpzJXGL8it2HMDWrhkuzRcTLu7RFAuM12v/LOw78xZ2TD5Eauf2y1qpgp++sjJABBDwg4CfXWTWNfy2F5RT4nCVO4X0KXRS6KUBMCOjdZvIuynIx/a7Odp+p4brYquHnatgi+l71bLl6W3F5Cxou/OaZq7a3ulFUccZWw8gMAiDgCgE/KJp6GukzFPghTjOJ08VdFNrNMhXrNdltdpKe5jd7oFL/8CYz4y1prOx9pvHVrBqeq9EWH2jXzI68aebqZTVmWcTHtIPB88c/N81jdJGe64wbpSMNBEDAWwJeu85aafjHKGRTMkwpRqGNwhMUIBIB2W3W/cnkdi5S1rGovPrMzpY0Wn36uRotLd8jb7q5+9U+y7sB6NurHBGd+jjOQQAE/EHAS0XzGiFozAHDj3MoE/oistuM9yebFJ4XTxf54U3NfZaeyzzGVo1+fzLOncNKsbFGePuZTQdP5fzys4RIdj+3o7bfvMe4CgIg4AWBm7+B3OnFemqGrRMj4bkYDtpP8nvofC2FcgosXRTW8EnYZOOBkzyvDsmBAH2QnzrcXNuSQ1EUAQEQKDABL+ZoWGHwnIwsA5SwgYKR+4P3sHqcwpMUBilAQCCNAM3PdKQlIAICIOAbAl4oGlYWrDj0wkqGrZQefaLuvJ/OeSHAUV0aTkFgnICixl9qvivTZweUQAAEPCbg9hxNJY33ZwZjPkRpVr4oOI9RvhZKZ7dToMNX779BQyiUhNcrB2umUJ8Z1AsCzhBwW9HUU7e1uRZtBOwK26tFcCwUAa+m4wo1nlS9/bOHFXx+UjhwAgL+I+C2onnQAEEXpbFrDFJgAmoojRplL1abFfiDg+pBIE8CbiuaOoP+QskYQClEkhI+o6a/tGTq/kKwQp0gAALOEXBb0VQadP2MQRqSCkQgXFaNsvdQ0xJ2vUJAAAR8TMAPiibuAJ8WqoN/rwc6LFx+vwMozKsIkVXTC2vG/F7jKgj4hYAXy5vlsctLneXriINAGoFkUgzQftHrYM2kYUEEBHxLwG2LxsjNsdi3dNAxnxJQmtq23t3r086hWyAAAhIBtxWN0cR/TOoToiCQkUBSqPvattZ0ZMyACyAAAr4j4LaiMfoVGvMdlaLqUHCWoiVVpaut+a6dRXV7MFgQCAEBtxXNHwyYVVNag0E6klwhEIyHa1jJTCkdWucKEjQCAiDgKAG3FwN0Uu95nqZcGsVuisMdIkFxN8oKx7fWzf62LTXb3eWB1kAABJwi4LZFw3M0Txl0vo7S+P00lQbXtKQYnXAeDhDHCfhVySg7jzTXQsk4fr9RIQi4R8CLbxe2ZvooVBkMM05pL1LopsCWDwsrn0cprOcISZzCEj4Jm+B9NJN3dHwJM68uw8T/JBWcgUAwCbjtOmNKrED4F+orHJEkRnF2o5mJpoDM8uBagAnwyrLZo7yHWQ1bwBAQAIGAE/BC0TAyno9posAvQDNzl9Hlm6TnphQkhIVAZzKZ2IlnZMJyOzEOEBgn4JWi4dYPUeik0EphLQUrwgoK/norpBzOw1vXFGqfNF5RFlUS9CrmlV0OdxvVgQAI+ICAl4qGh8+ukR9SYEXzYwoNFKooaBKnk14Kxym0U4hTgHhAQK9knFA6rFwiQj06a0R0wEXmwQ1FkyDgIgH6nQrxC4HgLQYYXxJtUfF00oftD/Q2zHhZ6XDHoaZvD/iFO/oBAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAsVC4D8BlXIyv9hIzzcAAAAASUVORK5CYII=)\n","\n","\n","下圖則是 syntax tree 示意圖，可以看得出結構和上面的邏輯閘圖很相似。\n","\n","![image.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAboAAAEwCAYAAADB3LQ7AAAAAXNSR0IArs4c6QAAAERlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAA6ABAAMAAAABAAEAAKACAAQAAAABAAABuqADAAQAAAABAAABMAAAAAB3mR35AAA/hUlEQVR4Ae2deXAc133nX/fgJgmChyRKoqWRbEtQHEvQZrOG8oc88iZreiuOoKSyolNyCVzroEtJGZRLCZWtjaDa8sqOYhGuWpdOB5R3ayVld0NGqVj0OhbHTrLkZhOTtCUTugxI4iXxwAAEcU/3/r4NNNhodPfMAHP08X1Vb6b7Xf3e5/Wvf+/q15qiIQESKIpApqc/rdSsWK1N180ORDJN7dP4L8VoSjuoNGPKUPqQMowhVW/mso/fd7iUNBiWBEigeAJa8UEZkgSSQSDT29+kcrOdSlcduqHfZJpmuxx3Vrz0hjagKfOwSplvGIbKqvrpgezjD5yq+HV5ARKIOQEquphXMIsXTCDz0Lc3qdnGDl0zRZGZN5n5lCg1UWwepqF5jdJ0TempBlXX2GSFqIebpnuE9neaHh+xPI3ZWTU7PW4dT10Y9Y5gmKeULgpQM39kGJoowfxA9pv3D3gHpisJkIAXASo6Lyp0izWBzFefbtdNfauZ1+/0U2qNq1pVfdNqlWpolP9VCkqu0mZm8oIovgk1OzmupifOK5wb+fzSy4ryM3V9rzKNl7J992aXBqALCZCAkwAVnZMGj2NLAPNruj7b7VZueio1p8haWqWX1mwd1zU0h4ZDfmZKzUxNqBkovokxS/nlZ2ec+RsyNXOvDHc+z3k+JxYek8BFAlR0F1nwKGYErMUj+myXZmp3S9GsxSMoIpRb05oNqnH1OtXcuj5ypcYw5+ToWTV5/qyi0otc9THDNSBARVcD6LxkZQlkep7r0jT1iFxlQblhHq1pzXrV1LrO+i91Xq2yOV5+6gWU3rdUa91T2d5tk8u/AmOSQPQJUNFFvw5ZgnkCbgUXV+XmV+GeSg/zeSn1jewT9/b5xaM7CcSdABVd3Gs4AeXL9Dyb0TQNPbgMipuqq1erNlyhVq3fVPKKSMSPg5kYPafGzhyz5vTmyyNzedqj2Se+tDsO5WMZSKAUAlR0pdBi2FARyDz0TIc2q++STGWQMcy9rd64OdEKDhycBgrv/IfvWas5LXd5V08Wrzyc7btnrzMcj0kgzgSo6OJcuzEtGxScnlePmKbehSJCwa1af7nYK6zjmBZ7RcUaz51W508fU/mZhem6w6ZSD2d33bNvRQkzMglEgAAVXQQqiVm8SCCz49mdytR6ZbFJI+bgMDyJXhyUHU1hAmNnT6gLYu3VmrIidbdsRbYj27ctVzg2Q5BANAlQ0UWz3hKXa7zkrc2m+u2tuFZjDk4s5uNoSiNgmoYaO3tSjZ1+X/bqlH7d3IKVO2TBysHSUmJoEogGASq6aNRTonOZ2fHMdunF9cmCk0YotnUfub4qO5XEHTp2Yckdf8fahQVllc2mv/7qri89HPdys3zJI0BFl7w6j1SJMw8+u0uG13qQ6Za2S1XrZWkOU5axBq3enczdnT9z3EpV04y9hlG/jUOZZYTMpGpOgIqu5lXADHgRkF1N2jQz/4IMVW6Rnpxae/lHRdFd4hWUbmUggL01z7131N5b87Bppu4QZTdUhqSZBAnUnAAVXc2rgBlwE8DWXZppvIINl7HIZP1VN3Co0g2pAufYV/Pc+29Y797J3N2IfCcvw/0zKwCaSVadABVd1ZHzgkEELCWn5fdLmDS+GrBe5uNS9Y1BUehXRgL4WkLu+JtqciyHhSpUdmVky6RqR4CKrnbseWUXAbeS23D1Jzgf52JUjVPM2w1Lz47Krhq0eY1qEKCiqwZlXqMgAXzVWxs2DmG4Ej05KrmCyCoaYImyU3UdnLOrKHImXkECpX0auYIZYdLJJqDnjCeh5PAtOCq52t8LeBkfr3E0rW6T/UK1tVgYhMZI7XPGHJBA6QSo6EpnxhhlJpB58Dvdsv9it6anzPVXXc/hyjLzXW5yUHZtV14nc6Si33TVqUZnH1tuWoxHArUkwKHLWtLntRV2PFF5/TBeBl+3+fpIfgjVrsb6lKZu3LxaXb2hSc3kTfXTY2Pq3bMLe0vawSL3jxfLT79zRNamSHPEVPLaATeEjlwlJjzDVHQJvwFqXfzbvvLcAfQWVq3bJO/KXVPr7Kzo+rde16buu/WKRWnc9dzPF51H9QSbQudOvD23Xdi6umv4Mdeo1mQy882hy2TWeyhKndnx3FYoOWzr1brp6lDkiZnwJoCX9Rua18gQpraJQ5jejOgaXgJUdOGtm1jnzFplaZj4lpxac+nVif1AapQq2e5xa3m1HZ9KilLemddkE6CiS3b91670o7Pb0TvAqwTc2qt21VDKlVFXGGKWemvSZ1JfKSUuw5JALQlQ0dWSfoKvreX1+1H8NZdelWAK0Sv66ks2W5mW9+y2Yj/S6JWAOU4iASq6JNZ6jcuc6Xk2g3fmsGwd72nRRIcA5lObW9dbvTqlz3ZHJ+fMaZIJUNElufZrVHbd1KzeXMu6S2uUA152JQSaWue+IqHltTtXkg7jkkC1CFDRVYs0r7NAwJSVljhhb24BSaQO0KPDp5OwYpbDl5GqusRmloousVVfm4Jj42a5chqf38HiBppoEmhokVcNLJPPzB/wjwRCS4CKLrRVE9OM6UYGJWtctTamBUxGsRpaWucKqpufTkaJWcooE6Cii3LtRTHvpvoUsl2Pl49pIkugcX4RkWZqfJ8usrWYnIxT0SWnrkNRUl3Ly4tYStU1toQiP8zE8gik6hrsiGn7gP8kEFYCVHRhrZmY5svM65aiwxwdTXQJLHz13TCt+oxuSZjzJBCgoktCLYepjLqyHoyOHkGYcse8lEDAaqzILilceVkCNAatCQEquppgT/BFDZMf74xJ9eN7dZapH2edxqRO41oMKrq41mxYy6Vrp5A1Iz8b1hwyX0USyM/OWCGzjz9g1WmR0RiMBKpOgIqu6sgTfkFDzSu6fMJBRLv4tpKTUgxFuyTMfRIIUNEloZZDVEbZUcNSdPmZqRDlilkplYBpzPfI5xsupcZneBKoJgEqumrS5rWUoRtHgGF2apw0IkxgenzMyr00XAYiXAxmPSEEqOgSUtGhKWbKzCIvUxdGQpMlZqR0AtPjo1YkQ1c/Kj02Y5BAdQlQ0VWXd+Kvln38vsPKMCdnJi/IghTO00X1hpi6MKfolDZ7MKplYL6TQ4CKLjl1HZ6S6pr1cJy6MByePDEnRRNAIyU/MylLZ81T2W/ez6HLoskxYK0IUNHVinyCr2tq2vMo/vjwBwmmEN2iT4ycsTJvptSL0S0Fc54kAlR0SartsJS1VX/RNM0RDH/NTk+EJVfMRxEETNNQ47kPTSuoZjxdRBQGIYGaE6Ciq3kVJC8D2d5tk/LRzn6UfHz4w+QBiHCJRcnhZX/56qrKctgywhWZsKxT0SWswkNT3JT5vGmqqbGzJxTmfGjCTwCLh85/+L7Vm5O6+1b4c8wcksAcASo63gk1IWCtvtTNJ3Hx0Q+GapIHXrQ0AmNnjl3szfXds7e02AxNArUjQEVXO/a8slH3KFbuYa5uYnRugQOhhJMAet0Xzp6c683VGTvCmUvmigS8CVDReXOhaxUIZPu25UzdfBSXyp34hcltwaoAfRmXwAKU4WNvKVOZ8kFxs8/qjS8jHUYhgVoRoKKrFXle1yKQ3XXfU5pm7DWNvGY9TOWhShMuArnj78ytjjVku6/WuofDlTvmhgQKE6CiK8yIISpMwDDqtyl5iE5PnFd4qNKEhwAWC80NK5s5U9M/Z62YDU/2mBMSKIoAFV1RmBiokgSsIcy62TuwNRgeqrkTVHaV5F1s2uO507JQ6F0ruGlq26SehoqNy3AkECYCVHRhqo0E5wXvZJm6doe8SD6Fd7WiqOxy44s/Jjsysfg8StULJZc78baVZdnJRpQcV1lGqf6Y18UE8OInDQmEhkBmx3NblGnulc+/NLa0XararvhoaPKWlIxcGD6lRk4OWsW1lNwTX9qdlLKznPEkQEUXz3qNdKmcyq65db1qu/LjStM4+FCNSsVQJeblYKjkqkGc16gGASq6alDmNUomkHnw2U5lqH3Ss1tb37RKrf/I9SpV31hyOoxQHAG8QpA7/pYsPDknHWpzSun69ix7csXBY6jQE6CiC30VJTeDmZ7+tGYaryjdbE/VN6l1mz+mGprXJBdIhUqOjbXxasfcVmyyutJUd2T77s1W6HJMlgSqToCKrurIecFSCIiya9O0/B6Jk0G8ptVtap307jiUCRorNyOnBlXu2BtmfctaDa94mLL6lZs1r5wrUwgXgVS4ssPckMBiAkMH/2py6ODLz6dv+fyUvGP36YN/vjM1PT6mNlz7SQ5lLkZV0ll+dkYNvz+gfvI//0y9+ep/1/RU46utl3/s32R33XOspIQYmAQiQIA9ughUErNoEeiWbtzTMoHUoNfVq5vu6FGX/9ItavXGzQpzeDTFEYCCuyCLTS6cO2mefO3vtaP/2/pakh25Tw6w84l8PpyGBOJDgD26+NRlnEuySwr3dbHW/WoahjrzziFzffqT2vT4eTU7Na7qGppVqq4hzgxWVDYouLHTx2TByZsKzMbPndKO7P1WXhoOzuWsnXKRXxf7Q7G5FV2QkUkgRASo6EJUGczKEgJt4vKC2G63Dz7+Ofze0aErP5lpmp2erBsf/kDlZ6at3p2eqnMHT+w5viE3dva4Gj7+ljk9PmqN4GBv0QN//vCYMTuz2QMM3LrFviF2QCwNCUSegLM1F/nCsACxIpCW0uwX2+VTquyFs8dvNhumr8GO+giDHVU+eOsn1q4qSf8SgvWR1NPvC49/Ns9LTw6bZuN1DbPOuPnVJ+67Iz89+RuCbK8PWzQwsAAIPekmnzB0JoHIEOAcXWSqKlEZxRDaK2LxwPUyT4kjvok2aXviVQRdGY+I0uu23fCyeePq9appzXqlp5IxeIH34KbGhtXk+bPykdS8jSIr78Y96vPKQI8Eekysn0I7KH5fEDskloYEIkmAii6S1RbrTHdL6fDlcb8HLxRcn1hP46XwELC5daNqal1nKb24vZowOZZTk6Nn3coNxQ5ScPC3DRoWGCJO2w6u/5ycbxO71+XOUxKIBAEqukhUU2IyiaEy9DC8DB626Fns8/J0u2Ue+vYmNVvfpRn63UpXeJBbBkoOPbyoKz18ld1WblhosmDkXTgtZbxkaMaLJb4P1yZpYAlm10JaSw/6xImrMpdyoUvICVDRhbyCEpI99N7Qo/B7yA6J3+fEDogt2aCXp/TZLvk89t0SucNOAEoPG0fXNTXLqs0W1biq1fYK3T++1Tc7NWmtMJ0YOa0WKTcZVpQh270qZT5fhq9/90jhOZQZujuAGVoJASq6ldBj3HIQSEsiWPiwoIBciWbl/A6xOZf7sk4tpafNbp3r6Znt7kTwTh5eVahrarG2G8N5Nef3sOckXoifmRwTpTZhWSg5D1NO5eZOnkOZbiI8jzQBKrpIV1/kM48HKpTcJp+SPCXuixad+IRblnPmq0+3K1OXzwLp12uG2eEc4nQmiH026xvFNq+2nBta1lr/dQ2Ny9qdBb0xKDEYKDRZESnnk9Zek9h30scc1gw1YOjmEVVn7itDz83nMgvObXLEocwFHDyIMgEquijXXrTzvlWyjwfpshadVKromYee6VCzeruutJtMZYoiFgWoNDz0q2myptIGlMofkW/lDPislqxWfnrkQhzKrBZtXqciBKjoKoKViRYggAfnTp8wOXHfJnavj3/VneeGO/PtugbFJyavXS/7iWyaz0hm/r+Uv8MSOCcvbktZtSOIaIhCU3XGQBV6aqXk0w6LcmMONW07uP5DV2eu/PGUBEiABKpGAL03DFWaPnZQ3DvE0oSPQJtkKajuUKe7xPr10MNXIuaIBEiABMpMIC3pHRLrp+QOiB8epjThJtAj2cNEYlA9psNdBOaOBEiABMpPAENfJ8X6PRz7xY89gfJzr1SKqM9BsX71OSx+XZW6ONMlARIggbAR2CoZCuoBoIdAEz0C6H1zKDN69cYckwAJlJkAFp2w1V9mqCFLjkOZIasQZocESKA6BLjopDqcw3IVDmWGpSaYDxIggaoQSMtVuOikKqhDdZFihjKflBxzLjZU1cbMkAAJlEqg0KITvIvFB12pVKMVvtBQJhpB7dEqEnNLAiRAAnMECi062UlQiSFQzFAm7hcaEiABEogMgaBFJ1hx2RWZkjCj5SLAocxykWQ6JEACNSXARSc1xR+Ji2+XXAa9XsKhzEhUIzNJAskksEmKXWjRCcLQkECHIDgqNuhVEw5l8j4hARIIFQE8uIJ2OuGik1BVVygyg6FM3Bd+yg7uXJUZiqpiJkiABNDyDhqK2klEJBBAgEOZAXDoRQIkUHsCvZIFvxY5lF9X7bPIHESAAIcyI1BJzCIJJI0AFp0EDTthGBMPLxoSKJYAhzKLJcVwJEACFSeABSVBi07ghzA0JLAcAhzKXA41xiEBEigbAfTS0FvzG65ELw+9PRoSWAkBDmWuhB7jkgAJLJtAoUUnvctOmRFJYCkBDmUuZUIXEiCBChLolbT9enFYdAIlSEMClSDAocxKUGWaJEACCwS46GQBBQ9qSIBDmTWEz0uTQJwJcNFJnGs3emXjUGb06ow5JoFQE0ALmotOQl1Fic0chzITW/UsOAmUj0ChRSePle9STIkElkWAQ5nLwsZIJEACINArlotOQIIm7AQ4lBn2GmL+SCBkBIpZdNIZsjwzOyQAAoWGMo9KmHaiIgESSDaBYhadpJONiKUPOYFCQ5l4BaY75GVg9kiABCpEAA+IQbF+w5V7xA+9PRoSCDuBYoYy+6UQvJ/DXpPMHwmUkUCXpIWWrp+S46KTMsJmUlUjwKHMqqHmhUgg3AR2Svb8FBx3Ogl33TF3hQlgTg5zc0H3eHfhZBiCBEggigQwbIONl/0eAMPix0UnUaxZ5tlNAPd6v1i/ex3u8Ec4GhIggZgQwKKTA2L9BB+f10mLpSGBOBHolsIEDdGj54ceIA0JkEDECRSz6AST+TQkEEcCUGQcyoxjzbJMJDBPoNCik10kRQIJIMChzARUMouYTAKFFp10JxMLS51gArjnOZSZ4BsARdcSXv5IFD/z0DMdakZrU5rZrmvaJmXoV5uamXZn/o2//e61J37246vc7qn6xpn227743Us+8am3ZcbuIPyzffdm3eF4TgJxIOCWl5Fjgze+/r2nPjs5dq7FXb76plXTv/J7f/JPzWs3TNt+mmbk5NF4xDDVJOXFphLtfyq6kNVfpufZjNJVh27oN4kyw1wbbNHmyJ4+dW7otYXwqy/5iPrkbz2gmlo3Lrg5DoZEqA8bpvZ/LYFuqzuY7d026fDnIQmEmkCx8mLMzqg3Xv1v6tTr/7CoPDf/7kOqbfP1i9wCTigvAXDC7EVFV8PayTz4bKcyocxSN2mG/OveS/0bV7VauaxvWq00XVd6Xb2qa1jSOLXCzEyMqVf77lHnP3hXXfHJW9Wv/t5/VKmGBjU7hdEbpabHR+f/x+TShnW86MfQBjRlHjZ08wiV3yIyPKkxgXLIy9A//o069D/+VOVnptUvbfmS2HuWlMrIT1NellCJtgMVXZXrL7PjuS26qd0pSmar0jVMmC8yDc1rlAynqLqmZusf56WaC2ePq7d+9Beq47d3BEadnZ5QM5MX1OzkuJqeOK+mLswpQXck6fXtNUz9JbU2tZc9PjcdnleSQCXkZfTUoBr42/+q/tVdf1JS1ikvJeEKVWAquipUR+arT7frRt3dpmF0i3LD+22WgUKzlFojlNpqZffcbP9a/EPxzYjiQ88Qx1CAF42Z00x9r6GM5znHd5EKj8pLgPJSXp5MjYtRKnYPZB769iY1W9+lKf1+ucjCPFtdQ7NqbrtEtazdqGSRSMWuX66E8zK3MTFyWo0Pf6jQonWYIU1pLxr67PPZb94/4HDnIQmUTIDyUjIyRiiBAHt0JcAqJihWfOl59Yhp6l12+JTMqTWt2aBa1l1q9eBs96j9Q9FB4UHxQQEuGEMdNDX1jWzfPXsX3HhAAkUQoLwUAYlBVkyAim7FCOcSmGuRNj0iCzm2w0XTdFFu62W14wbV3Lq+TFcJTzKTYzk1OXpWlN4Z56KWrFln7Mg+ft/h8OSUOQkjAcqLVSuUlyrdnFR0KwSd6e1v0kdndxqG2qlpWqNYtXrjlWrV+iuUnkqtMPXwR8fKzYmRs+r8h+8u9PJMpT2l6iYfzT7+wKnwl4A5rCYBygvlpZr3m30tKjqbxDL+Mzue2a4Z2iP2ApOWtkvVmkuvUhiqTJqBwhs7c9yypin7SBvmpJZS3zBa677OlZpJuxu8y0t5uciF8nKRRTWOqOiWQRkvqUrPDXtGWotMsFqy9bJ0pOffloHBMwrm7s5/+J4az30452+Yp0xd25Hddc+LnhHoGHsClBf/Kqa8+LMppw8VXQk0MeyiRmcf00ytB9GwghI9uDjOwZWAxTMoXk0Y/WDo4rt5htpnNkxt43CmJ65YOlJeiq9WykvxrJYTkoquSGp4t0czUi9I8A5rHk621lojc3E0wQQmRs+p0VO/mJu/m+vdbZPe3b7gWPSNOgHKy/JqkPKyPG6FYsV/tUQhAkX4y+4MW5Wh7RUFl0YvbsPVN0gvbkMRMRmkXl6Gb157icpPjavZmanV0rK669pbbm8aPPjyD0knngQoL8uvV8rL8tkFxWSPLoiO+Mn+ej0yVGl9w61ZNkZee/m1iVhNWQDLsrzPy2IVzN/BCNPdRpv+ZS5UWRbK0EaivJSvaigv5WNJRRfAMrPjO0/a78W1Xna1Wr3hioDQ9CqGAPbTPPf+gCw6y2sK83Za6gvZvm25YuIyTLgJUF7KXz+Ul/IwpaLz4fiZnu/0y2dyujEf13bldVxw4sNpOc6YeD/33lH7vbvDppm6jcpuOSTDE4fyUrm6oLysnK2+8iTilwJappaS01PmhvQnqOTKXMXYyHrjNZ+UvT6tjzd0aGb+BWuFXpmvw+SqQ4DyUlnOlJeV86WiczH8zIPP9mK4Ej05WXSiLeczOa4keepBABtab0z/0pyy09UWfXQGK1ppIkaA8lKdCqO8rIwzV106+GUe/E63fGx0lyg5c91H2rXGVWsdvjwsNwE9VSf7gbbJy+WnsZnKDelf+3zb0IG//n65r8P0KkOA8lIZrn6pUl78yBR25xzdPKNMT39aM2eP4mOoXHhS+MYpZwh88+7M4GtWkqLxZL7u3mw502da5SdAeSk/02JTpLwUS+piOA5dzrPAPBGUXNPqNq6uvHh/VOUIw8P2y/eaqV6Qh2hbVS7MiyybAOVl2ehWHJHyUjpCKjphhnkGpatObMa89oqPlU6RMVZMYPUlm5U1HypfYNfN/JMrTpAJVIwA5aViaItOmPJSNCorYOKHLvFdLG26YRC9uXWbr+cKy9Lun7KGxoddT79zRL5vZyr5rt3N/K5dWfGWJTHKS1kwliURykvxGNmjyzf8EZQcNmaO6ubMH7u0Wd1w+SpVn4p2uwXbq61af7l192qzen/xtzFDVo1AxOWlpSFlycrVG6xXW6qGrRIXorwUTzXaT8biy+kZ0vrK8UzjkLxJ0HjJtTdG5jM7v3L1GvWvb1inoOAguG7z7tlJ9f3Xz6kfvxm9DUfwna4P3/qJ9TK5dOzuyPbds9ddPp7XhkAU5QXyseWX16sbN6+25MWLHOQE8gK5iZqhvBRXY3XFBYtpKGmdQsmhJ4eXMsNurmhrVA/cdqUq1BqF/323XqF+88YNqvflITU+nQ970Rbyp2m6wvzDyMlBJXXziHhQ0S3QqfFBxOTllo+2qrs6N6m1zcGPuVuva1OwPzw6rPr/4WSNIZd2ecpLcbwSO3Rp7cRhaF8AJnxTLuwGw5I9v765oJJzlgOK8f5PR29/Tnypff4r7R2Zh57pcJaJx7UhEDV5wWjHfbdeWVDJOWlilAQKL2qG8lK4xoKbOoXjRzfESL5LegyX4evgGOsOu/n8TRsVFJfTzORNa3hyZGLWcsaQpru3B7dL1tSr0+dnnFFDfYxWKoQXu7ervHa3ZPZwqDOchMxFTF4wouGes4YM/N1bOau2MKR563Vrlwz9f/YT6yM35E95KSyAiVV0mqG+Iq8UqJZ1lxWmFIIQUFhu87W/GVJvfzix4PyXPzmten/rmiVzEViocvr8nIAvBA75QXPbJZai0/Jqq2R1R8izG/vsRUleMFTpbhSeyE2p/7DnFwqNQ9u8OjCsvnbHtYsUIuJBQTrD2eHD/E95Ca6dRA5dzm0gbHYATeOqdcGEQuLrFly0Tp1Kzs7mT4+N2YcL/y0N0atm9LKtnra8V8fhy4WqrMlB1OTFPaoBaD89dmGJ8oLyy43PjYbYYKHk6lOUF5tHXP6jV6PlID8624FXCrAARU8tXbVYjkuUOw33MExbS92ilqh9PS8h91KIdvgw/ze0zPdi81omzPmMfd4iJi+rGpc+1rwae+j5QY6cBsovSou3nHmnvDhpLD5eekcs9o/rWScKFqVNmyGATgPFd8tHF286jYl09xAn4kVx2TTK2tDSahVZN/SbnGXncdUJREpe3j27WFZAC7LiXH0J+cFCLXcD8p/fPV91uOW6IOXFn2QiFZ394KxrbPEnEzIfzCe4zZ2/eqklvJhYx+Q7rNs88+MTS4Zs3GHCel7fNFc/8j6d9aANaz7jnq+oyQsad26FBYUGeYHBikzMzeHdOqfBdADmuaNqKC/+Nbe43+4fLlY+8lHVNAqEbzxFxeAdH6y8dLZKcbzjNz4iE+8NS1aPYTL9v7x6zHMeLyplnv8wq2TXaItKnuOYzyjKCxSWe3QDIx6rGlNL3FFnGPXo+9v3I9soRBkoL6DgbRLZoxMU1oMzKvNzqLo5xSXL7V3Ga3cUtGh7Xx5c0qp1RQ396UL9yIKU0Gc23hmMnLxAce177dySWnErPwQ48M6o+trfvBupV3CWFEwcKC9eVObcEq7ootWhPXryQqDygjJ86f99aC2jds7LYWgTrxjYFu/VRcXMvziurO2nopLp+OVzXtFFS17++siZwB4aGoR/uu899e39xxYtQIF82LKCf/c8Xpirl/LiXTvRunO9y1C6q2E2yarL0uPVMAaGKTF57p5XcGbpn4bOKwi32/z2v7jE2u/PdofCRAs2EkbDqlh52X2mJfq78EYCuEcmIygvkBOvxSbO0qFR6PU6zh//27S1yYIdFuG85Mr2D9U/5cWzOhLao9NznjRC6ogWJl4ED1JyyDr29rMn3J1F8Vpa7fQP83F+ZtLKXrZv21CY8xnvvEVLXjAX94dbrlo0n+1VP7//mc2eMuV+PSFKPTrKi1dNy7Cut3PMXXXzFEo4O710GXLYSo6enLuFiTz6vTaABStuZYcJeKeJyq4P2Jl9zpiRapg4WcfiOELygsag1+pjrMJ03/dQYFjM5WxAYpgf1mnOjEVj+zzKi7PWFh8nUtHJdkaWort4YyyGEqYzKC73nBpeAMd2Rhh+hMJzG8SxhR3CfMPli1+jOJGbdkcJ5bkxaz9gNCq6GtZQVOQF9/pdnUu39MOw464fvG9ZN0a3svPacCEq+8RSXty1e/E8kYpOpcw3gGBmItwvh0IIsaO62+BTImidYgeHx7//nudqMQzfPHDbZvUv02uWtFAxRxcFMz0xl09NMw5HIb+xzWNE5AX3unurPCzKwhwbDObjsPjEq2eHoU7IDL5d5zQI+/aH406n0B5TXvyrJpGKzjA068E5PT7qTyYEPvYGs86sQHCdKyrR2vzP3xta5GaHx5wdlJ3TQHC9JuCdYcJyfLEhoh0JS56SmI+oyMtV65euV3K/OI57H707t7JDvWIUxP36AcJ7hQ3jfUB58a+VRCo6ebUyCyTT40s3QPZHVX0f91wBcoBenttA2WEY06kA3WHsc7x4HhXBnR6f63Ebhsra+ed/LQhEV168ZAjKC1/+KGZPS8hLVAzlxb+mEqnoZAVfThnaAObopkM8fOk1/4ZennvODtULocVL4nj5NchEZZl0XubnZibGTGWYsuyyjkOXQZVaYb+oyMvJkaXz1e75aRsV5rl7Xx7yHPa3w2CIPyqjH5QXu9a8/xOp6IBCSxkv4X98eG78HsdhM/igqv1RVWfeMBzp3ArM9kNPDXtiBvXYfv8zpX112U672v/juQ+VqUxNS5n7rAdttTPA6y0iEAV58drMGYtL3KuQ7YKdPj+98CFW2835j5fF8Q6q1yiKM1wYjikvwbWQzBfGhYmRmn5Km218ZGLktGq9LH1x+5xgXlX3RQ/srs7FO2Bh26++rR9XGFZxDr90Xtu6ZDLenWEI7+O/+1H5ivKIOviLkdDuhTmRm9tc1zD0591l4Hn1CURBXtADw/C9e+UkViF3Xrt2kVJDQxGLV7wajE66UHSQq4O/GLVeGg9qRDrjVfuY8hJMfPELI8FhY+U79H++N3btr/1mh2lq7XpdnXwSZukXvMNQYAjutZc0q8taGxZlJyU7u0DhObcqWtNUXLsFH5ZEXF3TArcUW3TBKp5gOHns7Alpjcj7juvq/mAo+1eLv45ZxbzwUnMEoiIv75yesDZOcH88Fe+SOmUFMtVUX9yAFuQKcV8/Ma7C+E4d5aWwlBZX04XTiWQIu7dwQR6qGOMOo0ELEqvE3KvHiskr5hd2vPSWtaTaawi0mDRqEWbk5KB1WTOlXsz2bpvbGqUWGeE1FxGIgrygYYiFWaXe75AzfPHgvu++EZ3tvuZrh/Ky6Db1PElsjw40hg6+PHDNLb+VMQ0jjbWMjavbPCHV2tEwlTV0cvTkuPWZkbmvi3u3USDg/zg4qvAduu/97KwMbRrqg9FplX0jZxXj+k0XXx7HcMybH4TrHaGJ0XPqwrmTc725trrPszdX67vv4vWjIi+QgR/8/Jwam8pb75CuX+W/iTkU4/dfPyeftDpuLTyBwnv9xNzm6RgCdcZFuFIV6EV6lTmivBTHdela9eLixSZU5qFnOrRZ/ZAmw3iXfvxXlL37d9gLCCF0L53GKs1Cgog5Cful2rC9OI5VsGcGX1MzkxdkGYq5I/vEvX1hr4ek5S+K8oLFJB+79GIDz66zYu5/yApkBnLltQraTqsW/5SX4qknXtEB1WcefGaPaepdza3r1brN1xdPjyHLSmD0g3fn5uaks22uTd3AYcuy4i1bYpSXsqFcUUKUl+LxeY9/FR8/FiGN1MyXTdMcsYYBhq1tMGNRrigVYnIsZys59Oa+QCUX3tqjvNS+bigvpdUBFZ3wyj7+gGg3rRvoRk8NyVcNJnBIUyUCWAg0cuJt62qaZj4qQ5YHq3RpXmYZBCgvy4BWxiiUl9JhJnoxihMXJtqv7bw9LS8pd0yezykMY+qp4pbrO9PhcWkEMM9w7r2BucaFoQ7u77v3i6WlwNC1IEB5qQV1pSgvy+POHp2Dm9Gmf1lOs/h44dl3jyojn3f48rDcBCC0w++/YW/DNmRqqS+U+xpMr3IEKC+VY+uVMuXFi0pxblyM4uKU6elv07T8fnHuqG9apTZc/YnQ7priynrkTnMn3lHYukjaqTnTrLuZXxGPXBUqykv16ozysnzW7NG52GFfRbNu6nPiPIRl7mfffT20L5O7sh6ZU6tleuyNi0quzryNSi4y1bcoo5SXRTgqckJ5WTlW9uh8GEpLNS09uz3i3ZGqb5KeXbuqa2j2CU3nYglgODh3/E2FVWNWTw5K7vH7Dhcbn+HCSYDyUpl6obyUhysVXQBHa1jGzL+idNWp6Slz3ebrtKaQ7p4SUIzQeGE16/Cxt6wXwiVTQ2adcQeVXGiqZ8UZobysGOGiBCgvi3Cs6ISKrgC+TG9/kzYsPTtdbUHQNRuvVGsuvapALHq7CYzL1whGTg3KKExes74FqOmf43Clm1L0zykv5alDykt5ONqpUNHZJAr8Z3Y8u1NT2mOGvPPVtAY7qHxcpeobC8SiN4ZeRj+Qrzlbi07kbUVT220ofQfmdkgnvgRseUEJG5rXUF6KrGqnvExfGFGNLW2UlyLZBQWjogui4/K7+d/t/PW3sy98r23zdfUfz2w1V62/XFu9cTNXZbo44RQT6GNnT6qxM8fnenGysvLs0NGv/XTPE58Qb7zGwa8SAFSMzVWf+vwXP/j5P/TfePsfpGQUhPISUNdueXn7x38xefxIdsqYncZIEjdQCGBXjBdfGC+G0lyY9KnX//470sq6cvTkL+RBrrRVG66Qnsop+RI2Wq2rFTaGplFqYvSMOve+LDg5fxYaD1CyP9vb98TggZf/kxx3iv2Y2P8llia+BDpGjr/5Un56ouWDnx+Y3nDNjXVK0ykvHvXtlpdTr//da+/8/V9eIcP8TRL8LrEiSOqfPKLSqUgCVHTFgeqQYK+IbbeD52R5vKzCHGjddM1GDDFMjJyVocx6Vd+4dJd0O07c/6cujMqKyresz+yYhnwr1dAGRM19MbvrnrzMOXxTyg/BhfllsSNi2VIFjfgZNGZ+ILYNRZMHdurkz/7u/LrN7T9rXLPuCsoLqCjlJS/HX/vRH7/xg+/+jnjbsoLtmX5T7CaxPxTLjxALhFINuyCFiUFooeQsoXUFn7zxd7767zdcdcMfijuUocJL5q2XpVXjqlZX0Pie5memrHk4bIptGfkyuKnLnpW77ntKztNij4q1BVcOLTMpv3hfMWud8ScuBLZIQfBajru+Ub5sZsdz35CHzmNyTHnxlhdsVpER62UOiuMdYk95edLNnwAVnT8b+HSJfUGsl9DmxB03XVasyux4ZrtmaI8oXUPLy5qAb27bKHtmXhLbOTwMuUyODltDlSizMsxJLaW+YRh1fa7FJlvFFxzdBgJ7s1gKrptMNM+3SLb9lNxh8btNLOSG8gII3vKC5wcYdiKIh4Gs4Llz0MOPTj4EqOh8wIhzt9h+H2/cbOiNQHgXDJZW66OzO2X+7iuyvrDN9mhu3aiaWteJ0ttoO0X2f3rivJrInRHldnrRXqDWasr6yYfndrb3LN4uce3x8IHA4gE46eFHp+gQ6JKs+jUKIScLSs4uEuXFV16ahBHkZbvNyuN/h7j1ebjTyYMAFZ0HFHHqFfuIt5caEHcouSEffwUBVqPGVs0075YwGTucnkpZPTz09LDkOioGQ5N4PWBcFBw2vF4wmINLGU+r1PSLAQrODg7hxRBwxnZw/ENgIbg00STQLdn2axRmxQ89kJxYT0N58cQCRyg6KDzIjpd5URy3iXUIpVcwulHRLb0HILDdS50tl4PyCyXnK7TueNgaSWmzWzVDv1vpZrvtj23FWkTh1TWuEqW3KlTv5OFdHuzzOT0+oqbGRuyvC8xlHfNvKfWi0oyns9+8H0q/FLNJAh8Si3+3gcDudjvyPPQEuiWHfkpun/hByU2KLcpQXpZg6hSXPWK9ZAaBD4sF4yGxND4EqOgugkGrCTfUlotOi45KFtpFseUk89AzHWo2db9sDbLVObSJcKk6WbEpC1nq5TWFeunt4RhulTZ4f2d6fMxSZrOT4/I/trjXhgxgLkFpew1NvZTtu2fvCvMEwd0vFrydZlJObhELwaWJBoHtks0nfbJKeSmPvADvJrF4NkF2vAwa3lB2WS9PusnTlhAsAm3yi2E1vxtpt/ihx1E2k+l5rkvXzQ55zezTsgC7w634cCH0+hqaW6TX1yKvIKVE+a22rt/Qgnf2SvvwBObWTMMUJTZlKbL8zLTVa0PPbYkRxSaLag6KcjtoKPOIMlP7XItLlkQp0aFHwu/yiDMkbjeLheDShJtAr2TvEZ8s7hV3fFtw0se/ZOeEywt4oWEImUHjws/sEI8+P88ku1PRzS1/h5Jr97kRHhX3Xh+/sjlbQzYq31FI+ZXtgosTypqaeVgp/YhK5Q9XaaNlDHd1L86GdbZPfjE8TBNeAr2SNT8lt1v8ytoolPSWmATKi80Aig4KD4rPy7wojuBftkaG10Wi5pZ0RdchFYYhgbRPxeGG2e3jV3HnufmKfKeuzc3tmXntU0q3bvC0XBy2SGPmpMcoigxdeO2gzK9NyX6TQ1VUal75hKAeEIs6cJtHxaHX7cjzUBB4THKx0ycnu8UdMlMTE3N5cTLtlBM8tzY5HR3HkHXO2zmAJPkwI4UfFmt62Alx6xJLU1kCaUnerw7Iv7Lsl5M6euFe8gI3v7m65VyHcQoTgJJDQ9GvPiBXGbE0CSawVcoOZeZ1k+AGQYuJpjoEtshl/OohXZ0s8CpFEOiXMF71BLfeIuIzSPkJYFQEDQy/eoF7T/kvyxSjQGC7ZNLvxhgUv/YoFCJmeeyV8njVyVFxhzDT1I4A+PeL9aofuPWKpaktATzT/BruqKMXxFKOaltHVb065hf8BPaQ+KWrmhtezElgj5x41Q2ElKY2BPBwfEWsV73ArVcsTTgIYBTqpFi/uuLzLRz1VPFc9AfcBPvFr63iOeAFggiA/6BYL0Hl8EsQucr4FVJy3ZW5LFNdAQHO260AXtSjFhJYduvDU8PtkhWvIRi4ZcKTzdjnBI2OoJ5cd+wJRLeAeN49KdarwWi7seEY3fr1zDkEFl12u4Ld/7ghaMJFAAuF3PWEcwzLoMVKU1kChWSmu7KXZ+plIrBd0kED0UuW4MYGfplA1zqZtGRgUKxfRe+sdQZ5fV8Cu3zq7YC4o8VKUxkCQUoOD82uylyWqVaIQKekiwai3zOQ83YVAl+tZDsCKhgC212tjPA6yyIAZbZfrJeAQgnSlJ8Aest+ox+QmS3lvyRTrAIB1CsaiF6yBLdhsRmxNBEjAIFE5XlVLAU2OpUJAfVrjXZHpxiRyGlacjkoljITieoqOZNoOD7pU792nfeUnCoj1IzAVrkylJldec5/KD/09GiiQ6BTsupVn3BjXZanHtOSzKBYp6zYx5AZ1AFNPAhsl2J4yZNd3y+IP5QiTYgJoEViV5j7f1D80iHOO7PmT8CvXlGnbf7R6FMEgXYJA45uecE5G4ZFAIxgEDRc/EZKUO+HxKbF0oSQwGOSJy9htSuOD8QQVloJWUJL06t+95eQBoMuJtAhp1BmXlyp5BazitvZJikQZMer7uGG+s+IpQkJAXSz+8X6Vdgr4kclF5LKWkE2UM9HxXrVMxo5NKURCFJyg5IU/GniT2CXFNFLpmy3nfFHEP4SQoFBkdmV4v7vFz+ON4e/HovNYVoC+vVAuopNhOGsOTc/joPCJ01GiSKwVUobNG+3R/zxrKWpAQGAPyTWrdzsc7bya1ApVbgkFJpdx85/PLgx30QTTGCLePs91AbFLx0cnb4xJdAh5UL9O2XKeYzRFMpXlSs/LdcLqpSeKueHl6sugV65nFMI7WMII3vw/nURpOTQaEz7R6VPAgig87BfrC1P7n80JtHQpKkCAbQ8ANxdCThHSxXdcJr4E3hFiuh1D+yJf9GXVUI8oCAfXsyg5PCQoyEBENgl1us+sd16EYimcgTQIvVTcnDPVO7STDlkBPBgHhRrC5/zvydkea11drp9OIEZlVytayec1+e8XQ3r5YBc2/lAs49PintHDfPFS9eGAOrcr5eSqU2WQnlVKDNbVpz/kCc0GGhIwIsA5GtQrPOesY/RseCcnRe1MrhBKN3gj4pbugxpM4loEuiWbNvC5/xH4yctlmZOmbnlBkO/nM/k3VGIAJ65+8U6ZQvHXYUi0n9lBNISHQ8xwGaLVCDQ+M4p4P7gw3zuBknL36BYyA2VnECgKYnALgmNewe2VyxNFQigS/2CWD7EqgA7ApfAfQClZgui/Y9hzc4I5L9aWUzLhZ4US7mpFvF4XQfzdnju0pAACdSIwCa57kmxtpIblGM0iGhIgARIgARIIDYEMlIS9OL2i8XcAg0JkAAJkAAJxI5AJnYlYoFIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIIKEEtISWm8UmARIgARJYOYEOSaLNlcxBOZ90udX0NCqKrl0oPSYWUNNibZOTg8Nivy/267Yj/0kgYQS6pbx3im0qstxDEu5dsfvE4qFEQwLFEsCzuEvs7WI7AyLhvvorsbvFnhJLUwSBFySMWcBCCdKQQNIIbJICT4gtJB9+/oMSd7vYNrE0JOBHAPdZv1i/+yjIHZ2UJr+E6T5HAICKEeRdBEYCCSSwVcoc9JAp1m9Y0mFjMYE3UBFFxj1WzDM46F7bX8R1Eh2kW0ofBND2O5loSskpPFqW6OEXI3iDEg4CBtsrdovYuJluKZAtAyv9H5S0wJeGBGwCPXKw0vvKjs97y6bq8f9KCaAzHvHpFC8CGGazBWc5/0clfrfYuAyloCzL4eAX54CkR0MCINAt1u8+WY57WtKj8SCAFkAxLXcb+pMeadApXgT6pTh2fa/k/5CkE4d5qe4AHuK1yLTLGXq1e8QGsUuLP02yCaSl+BjODrpP0GjEM7dbLO4tDH1nxPaKhXy546bFjcaDwHZxc8PCOVqdXu6omCaxNPEl0C9F86r75bi9EgNM3QE8gooXxLErKCL9EkEAshEkU2gsFXrWZiSM81mdlnMaDwL7xc0Ne0Lc0Hpwu9vnWzzSoVN8CPT71P1Jcd8/b53CZd8Xfv+PRRxNt+Tfr2xBRUNv1i/erqCI9Is9AfTM/O4NuJd6f/RInBdiT22ZBUxLPC/YNjC/h5ntv8zLMlrICfT73Bdwdxs8zLeKPSTW616CG/yibLol835lK1Suoz5xvVgWSov+8SGwx+e+iKy86CGuGzygvAxeQoSx/+fOLv52yWGhLvXF0DyKM4GcFO5FsbeIHfApaIe4J/V+mfRhgpfJaZJJAI1DPEP9zKN+HmF2D7Oiu90DHARz77w7HmBeBg+toIryikO3eBPAffNwQBE7A/zi6gU5afcp3EEfdzrHn0AmoIinxM9+/gYEC59XWBUdBNDr4QPIeGjBDIn1E8g7EYCGBBwEBhzH7sM2t0MCzh+RMjZ5lPOwuO3zcKdTMgh8OqCY3wrwC7VXWBXdVh9q7uFK97kdbYscJPHhZZef/6URGCoteKRDQy4wB7fToxST4rbDw51OySGQCSjqQIBfqL3qQpo7rx4ZhHCvK78vyvljLjecoqXaJXa3WBoSAIEOHwynxD2yAuxTJtt5v30w/59xnTtPc3LyBbFZpyOPE0egLaDEQwF+9CqRQKeENz2s32rKAx5hEd8t5OJEEwMC/VIGr/sD7n4GwntSrFe8Hr9IEXHv9imXV1n93PZLGkEPuIigYDbLQGBY0vC7TyJ7j4Rx6NJrEQrqz2+Y0s89I3E2ISJNYglAMLeKxTJ6r3vhsLg/JTbpJiMADonF6AhGQ2iSS8BPmeUECSxNmQgMSjruFsWEuPkJYNojvB2/R/xo4kWgX4pj1+9K/vdLOn5CHSVi3WXiYbOEwkuLpUkeATxj7fvA/T+YPByVK3HGB7TfsKWdE7/hS7jTxItAvxTHLYSlnKPR1BsjJN1SFr/y7xc/20KB+YVzu5+UsH4NS/GiiTEB971gnw/HuMxVL9qTckUbrPMfw09BZqd4OsM7j9NBEekXOQL9kmNn/S73eFDSwX0TddMtBfBj4Fe2jHj0B8RDervE0iSPABo5pd5PyaO0ghKjBekHeYv4ZQJst/j5VU4cHmZSPJp5AoUe0H73gZ/7Hkk3ykOY3ZJ/v7LNI/P96wqIi55vlLn4FpoegQQGxdfvfmoPjEnPoghAmfkBXon70aKuzkBRIdDvc5+gkbTfZYu9b6Dsomq6JeN+5SymTH48kSZkkiZZBCALfvdToZG10JIK06rLOytECa0QtkQqBDdEye6TvNzmspqcw2Kvy71i/Qx6Nkl9qPutWgYryo3fHRNf9yMBRavUMzrgkuXxCouia5LiVLK1cHd5cDGViBI4KPm+Q+yjAfn/owC/OHsNBRSOQ5cBcGLqlQ0oFxqEHQH+ofUKi6IDQCi7SplKKtFK5Znplp9AryQ54JNsJAXYpyylOKcDAvuxCohCr4gTQKMwF1CGRwL8QusVli3AbvchlBX3H/n4eTl/Vhw7PTzS8+6oRJpkE8hK8ds9ELTNuyft4R40HJU0Fh63ReKcJqXEu8X2+JS8S9y3i33Kx9/LOSOO94vdJhbpJ9LgATMh1msCdEuJRLb6pIO0d5WYFoOHk0C/ZMvrXoF7MaZXAnnFh1tHMQmELEy35MevPIWyigeWX1ws7mkqlAD9Y0kgLaXyuy9s9xckDJ7dQaZdPJ2LWzqDAlfSLww9OrQQvAQqJ+7ZEgu/V8KjxeCVHpTgjhLTY/D4Ebg+oEgDAX5R9Mr4ZBoPIPTk/PwR7RtiIUs0ySMwJEXuE9sTUHQ8TzvFHhT7htisWJj0vP2s/MPfabyey07/WB+/IqWzWwnO//5llhotDWc6zuPMMtNktPAQwH3hrFP7GO6FTJsEOCnWjuP8P1oockj9u33K4yxbqceDkmaiH0ohretqZgv1f0hsqfdOUPhMNQvgvFatF6NsksxscWbIcRy07NkRbMlhULy7l4SmQ1IIQMlhGAX3nJfZ5+WYQLchKfNtYicTWHYW+SIB1D9WKg9ddFrxUWLvqe2CzqsFgDm75bYoEQ/xvdIdFneaaBPol+x71S1GBjIeFvfYLrGoe694cMP9sklsFM1WybRfuUp13y9ppaMIgXmuGAHIxSGxpd5L7vAHKpbDCCS8xwcghh9XYhDfDdo+71xJwoxbcwL9AXVr13Gp/4/VvFTLzwB6qn4Nu2I52I2E5eeCMeNMAJ0HzNedFFvsPWWHQwOzV+xyOy4SdeWm1otRvi9FyIiFsNomKweP2ifL/Ed8tEQyrvhZOR9yufE02QR2S/EfjjCCnOT9y2LvFFvsw+SwhB0Re1BsVuykWBoS8COA+6NP7FNiu8V+WuwWsc7ntpwumFNylBX7I7G7xfL+Egg0JFAKgSclsN1aXMk/Wpo9pVyYYUmABBYRgKLLOGznIl+ekAAJLJvAVom5EgU3KPF7xfq1RsWLhgRIIE4EtDgVhmVJBAEMz3WLvV0sjoPMkHi+Ox9gQP6zYjGsQkMCJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACUSfw/wHFOD2CYAIyIwAAAABJRU5ErkJggg==)"],"metadata":{"id":"iN_0HlHBEUWS"}},{"cell_type":"markdown","source":["\n","\n","之後會讓大家試著寫程式，將 infix 輸入的 Boolean expression，轉換成 syntax tree。\n","######*注意*：我們假設輸入的 Boolean expression 不包含空白字元，讓問題單純一點，把重點放在如何分析語法。\n","\n","\n","#####Left Association \n","忽略`&` 和 `|` 的符號運算優先順序，只考慮出現的位置。\n","Left association 的意思是，`A|B&C` 要解讀成 `(A|B)&C`，而不要當作 `A|(B&C)`。\n","\n","考慮底下的語法規則\n","\n","\tEXPR = FACTOR | EXPR OP FACTOR\n","\tFACTOR = VAR | (EXPR) \n","\n","意思是 expression `EXPR` 可以有兩種，一種由 `FACTOR` 構成，而另一種是可以繼續遞迴展開，`EXPR OP FACTOR`。\n","而 `FACTOR` 則是定成 `VAR` 也就是單一變數就可以被視為是一個`FACTOR`，另外一種情況則是 被左右括號框住的 `EXPR`，而`EXPR`根據第一個語法，又可以再繼續展開。\n","\n","\n","\n","李哲榮老師提供的演算法如下：\n","\n","\tParsing EXPR = FACTOR | EXPR OP FACTOR\n","\t1. Find a factor from the end of expression\n","\t2. If there is an OP in front of the factor \n","\t \t2.1 Let factor be OP’s right child     \n","\t \t2.2 Parse the remaining expression recursively and make it OP’s left child\n","\n","\n","底下是依據上面的演算法寫成的範例，函數空缺的部分，請大家補上 `???` 的程式碼\n","\n","```c\n","#include <stdio.h>\n","#include <string.h>\n","#include <stdlib.h>\n","#include <ctype.h>\n","\n","#define MAXEXPR 256\n","\n","char expr[MAXEXPR];\n","int pos;\n","\n","typedef enum {VAR_A, VAR_B, VAR_C, VAR_D, OP_AND, OP_OR, END\n","             } TokenSet;\n","char sym[]=\"ABCD&|()\";\n","\n","typedef struct _Node {\n","    TokenSet data;\n","    struct _Node *left, *right;\n","} BTNode;\n","\n","BTNode* EXPR();\n","BTNode* FACTOR();\n","\n","/* create a node without any child.*/\n","BTNode* makeNode(char c){\n","    int i;\n","    BTNode *node = (BTNode*) malloc(sizeof(BTNode));\n","    for (i = 0; (unsigned int)i < strlen(sym); i++)\n","        if (c==sym[i]) node->data = i;\n","    node->left = NULL;\n","    node->right = NULL;\n","    return node;\n","}\n","\n","/* clean a tree.*/\n","void freeTree(BTNode *root){\n","    if (root!=NULL) {\n","        freeTree(root->left);\n","        freeTree(root->right);\n","        free(root);\n","    }\n","}\n","\n","/* print a tree by pre-order. */\n","void printPrefix(BTNode *root){\n","    if (root != NULL) {\n","        printf(\"%c\",sym[root->data]);\n","        printPrefix(root->left);\n","        printPrefix(root->right);\n","    }\n","}\n","\n","/* FACTOR = VAR | (EXPR) */\n","BTNode* FACTOR(){\n","    char c;\n","    BTNode *node = NULL;\n","\n","    if (pos>=0) {\n","        c = expr[pos--];\n","        if (c>= 'A' && c<='D'){ // apply the rule FACTOR = VAR\n","            // make a new node for VAR\n","            ???\n","        } else if (c==')') {  // apply the rule FACTOR = (EXPR)\n","            // get the node pointer from recusive call of EXPR()\n","            ???\n","            if(expr[pos--]!= '(') {  // the left parenthesis is needed\n","                printf(\"Error: not matching parenthesis!\\n\");\n","                freeTree(node);\n","            }\n","        }\n","    }\n","    return node;\n","}\n","```\n","\n","\n","```c\n","/* parse an infix expression and generate a syntax tree. \n"," EXPR = FACTOR| EXPR OP FACTOR */\n","BTNode* EXPR(){\n","    char c;\n","    BTNode *node = NULL, *right=NULL;\n","\n","    if (pos>=0) {   // if the expression has length > 1.\n","        // get the pointer to the right child from calling the function FACTOR()         \n","        right = ???\n","        if (pos>0) {\n","            c = expr[pos];\n","            if (c=='&' || c=='|'){  // apply the rule EXPR = EXPR OP FACTOR\n","                // make a new node for the OP\n","                node = ???\n","                // set the node's right child as ...\n","                node->right = ???                    \n","                pos--; // this step is important\n","                \n","                // set the node's left child from recursive call of EXPR()\n","                node->left = ???\n","            } else node = right; // apply the rule EXPR = FACTOR\n","        } else\n","            node = right; // apply the rule EXPR = FACTOR\n","    }\n","    return node;\n","}\n","\n","int main(void)\n","{\n","\t  size_t len;\n","    fgets(expr, sizeof(expr), stdin);\n","    len = strlen(expr);\n","    if (len > 0 && expr[len-1] == '\\n') {\n","        --len;\n","        expr[len] = '\\0';\n","    }\n","    pos = strlen(expr) - 1;\n","    BTNode *root = EXPR();\n","    printPrefix(root);\n","    freeTree(root);\n","    return 0;\n","}\n","```\n"],"metadata":{"id":"7J_JdWZEdqKD"}},{"cell_type":"code","source":["%%writefile E06_02.c\n","# include <stdio.h>\n","# include <string.h>\n","# include <stdlib.h>\n","# include <ctype.h>\n","\n","# define MAXEXPR 256\n","\n","char expr[MAXEXPR];\n","int pos;\n","\n","typedef enum {VAR_A, VAR_B, VAR_C, VAR_D, OP_AND, OP_OR, END\n","             } TokenSet;\n","char sym[]=\"ABCD&|()\";\n","\n","typedef struct _Node {\n","    TokenSet data;\n","    struct _Node *left, *right;\n","} BTNode;\n","\n","BTNode* EXPR();\n","BTNode* FACTOR();\n","\n","/* create a node without any child.*/\n","BTNode* makeNode(char c){\n","    int i;\n","    BTNode *node = (BTNode*) malloc(sizeof(BTNode));\n","    for (i = 0; (unsigned int)i < strlen(sym); i++)\n","        if (c==sym[i]) node->data = i;\n","    node->left = NULL;\n","    node->right = NULL;\n","    return node;\n","}\n","\n","/* clean a tree.*/\n","void freeTree(BTNode *root){\n","    if (root!=NULL) {\n","        freeTree(root->left);\n","        freeTree(root->right);\n","        free(root);\n","    }\n","}\n","\n","/* print a tree by pre-order. */\n","void printPrefix(BTNode *root){\n","    if (root != NULL) {\n","        printf(\"%c\",sym[root->data]);\n","        printPrefix(root->left);\n","        printPrefix(root->right);\n","    }\n","}\n","\n","/* FACTOR = VAR | (EXPR) */\n","BTNode* FACTOR(){\n","    char c;\n","    BTNode *node = NULL;\n","\n","    if (pos>=0) {\n","        c = expr[pos--];\n","        if (c>= 'A' && c<='D'){ // apply the rule FACTOR = VAR\n","            // make a new node for VAR\n","            node = makeNode(c);\n","        } else if (c==')') {  // apply the rule FACTOR = (EXPR)\n","            // get the node pointer from recusive call of EXPR()\n","            node = EXPR();\n","            if(expr[pos--]!= '(') {  // the left parenthesis is needed\n","                printf(\"Error: not matching parenthesis!\\n\");\n","                freeTree(node);\n","            }\n","        }\n","    }\n","    return node;\n","}\n","/* parse an infix expression and generate a syntax tree. \n"," EXPR = FACTOR| EXPR OP FACTOR */\n","BTNode* EXPR() {\n","    char c;\n","    BTNode *node = NULL, *right=NULL;\n","\n","    if (pos>=0) {   // if the expression has length > 1.\n","        // get the pointer to the right child from calling the function FACTOR()         \n","        right = FACTOR();\n","        if (pos>0) {\n","            c = expr[pos];\n","            if (c=='&' || c=='|'){  // apply the rule EXPR = EXPR OP FACTOR\n","                // make a new node for the OP\n","                node = makeNode(c);\n","                // set the node's right child as ...\n","                node->right = right;                    \n","                pos--; // this step is important\n","\n","                // set the node's left child from recursive call of EXPR()\n","                node->left = EXPR();\n","            } else node = right; // apply the rule EXPR = FACTOR\n","        } else\n","            node = right; // apply the rule EXPR = FACTOR\n","    }\n","    return node;\n","}\n","\n","int main(void)\n","{\n","      size_t len;\n","    fgets(expr, sizeof(expr), stdin);\n","    len = strlen(expr);\n","    if (len > 0 && expr[len-1] == '\\n') {\n","        --len;\n","        expr[len] = '\\0';\n","    }\n","    pos = strlen(expr) - 1;\n","    BTNode *root = EXPR();\n","    printPrefix(root);\n","    freeTree(root);\n","    return 0;\n","}"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"Oc5YmeWkODkB","executionInfo":{"status":"ok","timestamp":1666099245651,"user_tz":-480,"elapsed":786,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"9054eb6a-a900-4135-97ed-28b9cc7a9831"},"execution_count":11,"outputs":[{"output_type":"stream","name":"stdout","text":["Overwriting E06_02.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc -o E06_02 E06_02.c\n","./E06_02"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"F06oSvqOQPf9","executionInfo":{"status":"ok","timestamp":1666099382066,"user_tz":-480,"elapsed":28436,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"82fac144-da04-4825-9b83-79c178818b40"},"execution_count":15,"outputs":[{"output_type":"stream","name":"stdout","text":["(A&B)|(C&D)|A\n","||&AB&CDA"]},{"output_type":"execute_result","data":{"text/plain":[]},"metadata":{},"execution_count":15}]},{"cell_type":"markdown","source":["以`A|(B&C)`為例，分析之後得到的語法示意圖如下："],"metadata":{"id":"Oz-QLax6ewUq"}},{"cell_type":"markdown","source":["\n","\n","![image.png](data:image/png;base64,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)"],"metadata":{"id":"Yb8Su_fFeZsx"}},{"cell_type":"code","source":["\n","\n"],"metadata":{"id":"oIPZQy_kLCy3"},"execution_count":null,"outputs":[]}]}