{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"provenance":[{"file_id":"1AB3RNlLfkZBSZKu6_Wh20CkIpbxfJIve","timestamp":1663461789208}],"collapsed_sections":[],"authorship_tag":"ABX9TyO33vU68dYoccLvjwYKkJXP"},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"}},"cells":[{"cell_type":"markdown","source":["#計算機程式設計二\n","#第二週上課內容"],"metadata":{"id":"9xoK4OIjIfZA"}},{"cell_type":"markdown","source":["###GitHub 教材參考資料\n","\n","[https://github.com/htchen/i2p-nthu/tree/master/程式設計二/Linked Lists](https://github.com/htchen/i2p-nthu/blob/master/%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88%E4%BA%8C/mid1/2-linked_list.md)\n"],"metadata":{"id":"05G1Fqg6GRZX"}},{"cell_type":"markdown","source":["##Example 1\n","##Linked Lists\n","\n","我們可以利用 C 語言的指標 (pointers)，將資料串起來，造出 linked list 這種資料結構。最標準的形式是 singly linked list，長得像底下這樣：\n","\n","Singly linked list (from wikipedia)"],"metadata":{"id":"mviKuWaapY32"}},{"cell_type":"code","source":[],"metadata":{"id":"A-XCv6MXrT2M"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["![612px-Singly-linked-list.svg.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAmQAAAA+CAYAAACFmwcEAAAABmJLR0QA/wD/AP+gvaeTAAAU7klEQVR4nO2de7xe05nHv45LIgnqLqOISJgYdalblc6Eca9pOzodpKkqRVWLjiFJGdc0LtOhhvkEKZHWVOp+G+JSUvchJUrLuBUh4lIhEc1Ick7/+J3ds9993su+rPWuvfM+389nf443znnW2u9ez7N+e12eBdBj13J/nUNnMZ7w37ld/q9OJvR3b5f/q9PidpyOjOErxb6A84p8exViXO/PTrvfTqTTnnGn3a/Rec+80+63Uxnc+/Mj4Brg/YB18c3uwE7Rh05T4j3Ao6Er0UY67flC39tVpzCDzrrfTnu+9eg0v7a43VlEPv4O8AYwMmx1vHE+us9HgJ6uwJUxDMMwDMOoxx7AKsB9wIjAdXHNucBJwGTgNgATZIZhGIZhlJFngT2BAcD9wGZhq+OMSWha+jLgWHpH/E2QGYZhGIZRVn4L7AUMRKJseNjqFGYiMAGYAhxDbPmFCTLDMAzDMMrM00iUDUKibNOw1cnNWcApwBXA0STWwpogMwzDMAyj7MxGomwIEmXDgtYmO2cA/wZcCRxJnY1JJsgMwzAMw6gCTyFRtjpa6L9x2Oqk5jTgdGAqDcQYmCAzDMMwDKM6PAnsDayFRso2CludlpwCnAlMQ2Ksu9EvmiAzDMMwDKNKzEIjZWsjUfbpsNVpyAS0iP9q4AhgWbNfNkFmGIZhGEbVeALYB1iHcoqycSi9xS+Aw2ghxsAEmWEYhmEY1eR/gf2AddGasg3DVucvnIQSv04HDiWFGAMTZIZhGIZhVJdHgf2B9ZEo+6uw1eFEdCTStcBYUooxMEFm+GEUsGroShiGJ7qAbUJXwjA8siXViuGPIFE2FImyoYHq8QPgx8B1wBgyiDEwQWb4YRFadLl36IoYhge6gaOAS4BPBa6LYfhgIdWL4Q8jUbYhEmUbtLn8E4ALgOvJIcbABJnhh9fR3P5dwINUJ1eMYaTlfHQG3Xy0RmSFsNUxDKfMoZox/CEkyjZComz9NpV7PBJjNyAxtjSPERNkhi/O6f25G/Ac2nGySrjqGIZTXgMe7/3vaagj2DpcdQzDOVWN4Q8iUbYJEmXreS7v+8CFwE1IjC3Ja2glVzXywNponcZIYE00/DcfeBENpS4KVzUjBS8CPwW+jc4fOxc4HPgu8KuA9WrFYGBXdCzH2sAC4C30tvhmBewb7eNg1M5XBHZGCSsvRkekfBiuWnXpAkb0XhujTOcro/b3Djor8AWaJK00Oo6qxnCAB5AouwOJst2Bdz2UcyxwEXALcAjwSVGDPfQp4VasAGyOAtF5wD3Ae702omt6gbrsghbEPZOwmbyWADci5Z6VHrQro1PI8nxdMxwN3UbPLfrv6fjdCTOeBkdTNGFLVK//p36b60ZvXnvmrJNP+zPIfr9VJs/z9cUV6GUx/hzfBr6O32nMNH69HnA26pw+onlM7QHeQHmT1sxQj5dS2E1zrdOiHIvbYahSDK/H7mjw5hmUGsMl30H+fgvFRw7/cr9pH/yV6G2qlWPlEWRdwMspbNfrxCaTbaTPHLu9XElth9XT+3kROlJigIcyszrzd9CbTdp2dwnZpvt92zdBFo5khxW17x60yHg7T+Wm8evRpG9z8esdlHAzDS4E2TJgtRblWNwOR6sY7mMa06WP/z2q62xaC/+0REcg3Y6b+88syGaRzrnyCLKVGth6C7gb+G+U7fYx6nds15P+bTSUYw9GUxvtJrRjb0b/DisS0z3AK8A/Oi4zizMfV6duz6M1ASeiQ2Fvo3+7+8+S2IdwgmxF1K7bTZkEGcBV9O+welC77wYuw11HEJFHkH2MpiZvAX4G/By4E5hbp+6fkG601oUg+58U5VjcDkeaGP4Vx2W69vG9Uft/Ci0VKcIR6N7vwJ0YLSTIFvd+vhw4mdqHVFSQPYsWD27W4HeHonntZOM4MmVZ7XLsIWgb7Ez6pguWosXAlwE7taEOUA7Hnkb9Div6TnqQqNjSUXlpnXlH+g/Hf4/6o1Nb0H8q/WuB7Ue0U5Dtgtrv6/Td20eonZ+A2r1vyibIRlK/w4qPJixAi39drdtN49efQ53G94FtaSwsVkBTO09TW+85wMAWZWyAjqzJcl2XKCdNZ25xOyxljeFZ2Af4E1rruVZOG4cjMXYnbmd3Mguy49F5TNtQG1TWwY0ge5D0w+QApyfKfTXl37XDsQ+i/ltn8rqB/A0jLWVw7M1p7Mxxp16CpuuKjiakdea7EnX4XovfXxeYF/v9l2n+huTbfkQ7BNlaqL22atNzgX/yXJeyCTLQaFMzURaNJjwPfNFBeT78egjwO2rr/VXHZaxO7Xq2N0knUi1uhyVLDL+Y9sXwrOyLBpR+Q7a1kgDfQt/BDFq/qGQlsyBrhAtBlocutBU3XvZWKf7Ot2OfSl/wTXO9iLbn+qIsjn01rR066rgWoLUJeTNFp3HmDRPl/i6l7aMTf/f1QPbj+BZkw1A7Tdumu5Ef+KKMgmwL0rXvSLT9GtihQHm+/HoMtfU9z7H9YxL2J6b8O4vb4ckaw3+I3xiel/3Q5qpZpE/sfBjy3bvwc4JB5QUZKFjEy/5Sir/x6diHkt6h49dv0bZiH5TFsf+a9AEv+r030RBx1nx5aZw5+azSCog1qA1KNweyH8enIBuC2meedj3WU53KKMhAa12bjZIlhVk3Whs7LEdZvvx6FLX1vMKx/SdjtpeR/t4tbocnTwx/A38xvAj7I1H2BIq5zTgU+evd+Hve44GeqieGfSfxOeTZW+uiodo8fAa9TSzPPI/EeprjJKINGhugDuEFlAvH5Zz98MTnJ1P+3YdoEWvEvtQfvvZtv12cgtpnHlxMP1eJiaTveFZE7fwgNNoyFXfrb4qQjKHvObS9I7W7Tu8h/VITX1jcTk+eGD4UxfD/w30ML8IdaDp+a9QOG4mysWiX6Uy01vFjn5WquiBLHucwN0gtxIlofURefkD2Oe2qkaXDIva7mwJT0ELyk2n9RpOG5BqQ9zP8bfx3B6A3x3bbbwdroV2ieVkDtetO4TngWrKdYdeF1lAdijY03Qp83n3VUrN/4vNMh7aPSny+3KHtvFjczkbeGD4cxfDXgJNwE8OLcjvaOLUNmopM1mkM2kH9AJp98yrGoNqCrAv4cuzzIjT8GIqiC5kH0T8YLm/8HqUoyXroatRO10XT1G+hEYUiHdefEp+zjEIlRxHqrV30bb8dHEDxIfp/dlGRCpG1w4roQqMK+6P8Zc+iTSC+F4/H2RVNnUQ8iabDXbAaSigeMQ+Jz9BY3M5G0Ri+HjoH1kUMd8GtaJR6O7RzMhJlB6PUMA+hOOhdjEG1Bdkh1C6qvAHtngjBUBqn6cjCFxzYKDtnk7/dRcPgqwLfQB3XC8CZZD9HMHmMRnKKsRFd9F/MOyKA/XawqwMbI2jfAb9l4Fl0ikjWDisiSk0xCk2lzUWjbgfROnlqK7rQi0F0DUGzDF9EneOv6csr9wYS067W8YyhNiXKVHIewOwQi9v5KEsMd8XNSE9sj6Yyv4k2MDyMxHZbxBiU+yzLZmyIzo+KWIweaCg2dGTnQNwEiCQHU2xHl2sWUHzIOuq4RqLkqqf1fr6QdFMIydHUvdFagVbsTP8pjnpTHr7tt4Ohjuzcip65K4b1/rzHoU2XDKF4MtGowxuA4kKUk+4R4JqcNveg9Xe2BKXwGIfb9WPx6coeNH0VGovb+XEZw0eQL4a75Eb00vBLlGvxUdosxqCaI2Sroi8vnm13PLULoY3OIe8b/GPUHgB9IBJ3rRhX59/qJUP1bd8wXPMBan/H4VaM7QB8Nvb5XuAPDu0b1aaMO6aDUaW0FyuhYz/i5V2X0YaP7dNDSbcVuNV1qeN6Qfm2T3+GbPl+mqUN6EE7f06jdp1V2i3TExM2Z9P8ANrkqRTRdXUg+xG+0l5c1qA+WS/XU5ZlTXsRcT3p0180uqLUJ4tRTP0atcdU5fHrPVOW/T79F+AX4fKE/TzrtixulwfXMfw58sdwVxyI0mA8jKYsl6IpfF9pLpJULg/ZimioPl7Wr8ieEsCHY4ObM93GeKhX2Rz7WvJ3VlEQWIS2Uu/SoIy0zrw6EnTxMt5Ei6k3RVnyPwXsRe2LwMLE30wOZD/ClyD7BvmeU/x6wUO9yizItqJYZxX5xmzUThpNC7nw64HoKKMD0ALmJYm6nF/QPmh0N96e5wEr57Bjcbs8uIrhP6V4DHfBV5AYe4TaRf1L0S7jdoiySgmyFVECxXg595Pvi/Ll2JMo5tQf4WfevEyOvSX5OqtotGAe2jLdanFzFmfeAqXTSFuXhegIjfi/TQpoH/wJsjVR4CzSrn/koV5lFmTTyddZLUO+cQuNO6k4Pvz6s/Q/OqjoodFHJeydm9OOxe1y4CKG/ytuY3gRvoTE2GPUT3uxFLgP/6KsMoJsJbTQLl7GTGqH77Pgy7HXQWuG8jr2WR7qBOVy7F+QrbOKnPglsiUVzOrM66Kp71aBZhbwN2hXWvzf/yWwfZ+Z+ot0WB9Qu9bTFWUVZKPI3lktQyNTU8mWGNaXX+9A7UkRswvamxWz1U3+xe8Wt8tB0Rie5mxeaI+PH4DE2OM0Twy7FK179CnKKiHIVkYL+JNirMgX48uxIf8Uz2yW/yM4ynZ0Uj1Gocz0dwJPo40ij6HkgPvRtysosh9dowPb9ynIBpH/6KQ053DmoayCLO/RSWlTosTx6dd3U1vXT+e0s13Czr0F6mRxOzxViOFpKeXRSVBeQTYAuC1h+36KfyE+HRuyH1L7Av1PHHBJWRx7eTmYFpTGId6x5h2tdWXf9+Him6B2mrZNdyPh6YsyCrI8h4tvX6A8n36dHBUdndPOpQk7RZIEW9wOT9YYPoFyxnA7XDwjA+nrZKLL1Tyub8cG7SJKrsWo12ivw3++lTI49ua0duSlaOrmIoqff+jTmddAuWmiej9YAvu+BRkoY/z1tO605qIz4nxSRkH2c5qPjkXf2/OoQyiKT78+i9q6757DxhDUKUc23iH9dFU9LG6HJUsM/wnljeH7op3LvyH7M/wW+g5m4P584dIKskFoaDtu817cqdJ2ODYoIB2PRvWiwLQETVNdCuzUhjpAORx7Go2dOerEZuDuzEafHfbx1NZ/bAnst0OQReyE2u8f6NuVtwC18+NoT860sgmykbQWYx8C38VdMm6ffp1cszsqh40jEzaK7ti0uB2WtDF8C0fl+fDxfdCRdk+S/0iyw5E/34nbg9JLKcgGI0eI27sbt0OE7XLsJIMJk4g3tGNvRv3OKhoxeAX4B8dl+uqwNwDm03cP83DrlHntt1OQxenC/XRtGsomyK6ifmcVrRP7L4qPGCTx5dfrU5um4n3yicgnqPX1NEmRm2FxOxxpYvgBjst07eN7o5mHpyi+0egIdO93UGzUN854oKdMmfqHoBscHfu3GWhbavKg5iqyCD3ETuMU+s4vi+hGz3QCGhW7rd2VysHaqH3G1xwci9YiVMG+D7pRu+5khqNRzHgsjfz8YbRO7FjcZr5PwwCyn4E6CK0Tio9y3kj2Mye3pfbIn5nAixltlIVOjdtx0sTw29tdqQzsBdyE1v3tBfyxoL0rgKPR9OdNuBNlmd58BlA/y3hyHnZV6u/KWQK83cD2IDQEuFvs3x5HiRGzvFkuwO2ZeUYxhqMdKlFntQztJJyOctG8Fahecaagt6Zb0I6gJANRlvRJ1Lbra9CB9qHtG2FJdlY9SHydgNp5qJG81dB6tRvRFORdKGdWPQaiF9+zqJ1yWgicnqPsoxOfL89hwygHVYjhzdgDHR7+EhJjrl6MpqDvZDKK018FPnFhOO3Q6GiaL+hrdT3bxPYOBW1HV5qkg6GGvkMRcuh7CrXP53nyLRDOSpbh7niepJfRm97PkCC6n/qJUW8m/VuRb/sQbsoyFGWZstyUvqmcpb3XBbROeumCVn6dXEqyDI1S3YFSbUxFi9Mfp3YTSXQtRvnwsjKY2rxe7+JmBMHidhiqEMMb8Xcovj5D8yPrinAMGi0sOlI2HuhxtcDUMJKMRIkAQQH/TLT7xslbhCeG0zwn1DLgYnTm5JIS2jfayy/pyx33GArOz4SrTlO60BRmmmnMF5HvPpCjnIPRkWER0yi3zxuNqWIMj/hb9PLxKhole9dTOZPRTONF6CX7EAp8PybIDF9M6P35EDqCYk7AujTjKtRZbUv/dRIRH6Ep9YkoSWqZ7Bth2ATYsfe/v4nSXpRh1C5iPppG+TLqkFold41GoKb1XnnXLiYPJZ+S044RnqrE8CRfQGLsNfyKsYiLUYy/EI0+H0LOF+osgmwmjTuUoszyaNtoPxsDO6NtxncHrksrLum91kRT58PRluhlaM3jHHTo7OKS2jfCcDLaPXkqOiKqbCxD68du7P28EUpfMQxtHFkFvQh8iNbXzEZrxoqyswMbRng2ojoxPM5uSIzNQWKs0bp111yENExclGXdDGMjZIYXBiPxUaXdsfOBeyps32gfXWih+tOhK5KBOVRnhMMIz2pUL4bvisTYm0iMzWtz+T9BouwCNOJ8CHoxSo0JMsMHz4WugGF4pJtqiTHDyMrvQ1cgI59HYuwtJMZC7f68EL2w/RiJsjFkEGUmyAzDMAzDqCq7IDH2NhJjc8NWh/9Aoux89PI2lpSizASZYRiGYRhVZGe0IepdJMbq5XoMwb8jUXYuEmWHkkKUmSAzDMMwDKNq7IgSHr+HcqO9EbY6/TgPibJJSJQdRgtRZoLMMAzDMIwqsQPaJPVHyinGIs5BomwiEmWH00SUmSAzDMMwDKMqbI/E2PtIjJV99/CPkCg7C4myb9NAlJkgMwzDMAyjCmyHxNgHSIy9HrY6qTkbibIz0O7LI6iTSNoEmWEYhmEYZWdbJMYWIjH2WtjqZOZMlKfsdDRSdiQJUWaCzDAMwzCMMrMNEmMfIzH2atDa5OcMpLtOQaLsaGKizASZYRiGYRhlZWskxhYjMfZK2OoU5lQ0fTkBibJjov9hgswwDMMwjDKyFXAvOux+d+DlsNVxxg+RKBuHRNkcMEFmGIZhGEY5uQ/4BCV9fSlwXVwzHomyk4BHoU+QjUeLzTqFz6EMusbyTac84316f3bK/Y4LXYGSYHHbWN5ZFbgZ7UpcHukGHkfHP9WMkHVakOu0++1EOu0Zd9r9Gp33zDvtfjudIWg3YkfwZ73/XrXlpipDAAAAAElFTkSuQmCC)"],"metadata":{"id":"dlf9i3hrqu80"}},{"cell_type":"markdown","source":["最後面的方框代表 `NULL`，用來標記 linked list 的結尾。\n","\n","也可以讓最後一筆資料再接回開頭，形成環狀的結構，像底下這樣：\n","\n","Circular linked list (from wikipedia)"],"metadata":{"id":"jEVQ9mwIrJ4Y"}},{"cell_type":"markdown","source":["![525px-Circularly-linked-list.svg.png](data:image/png;base64,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)"],"metadata":{"id":"6LnifkttrNWf"}},{"cell_type":"code","source":["%%writefile Class02_01.c\n","#include <stdio.h>\n","#include <stdlib.h>\n","#include <string.h>\n","\n","typedef struct t_List {\n","    int id;               // 4 bytes\n","    char str[10];         // 10 bytes\n","    struct t_List * next; // 8 byptes \n","} List;\n","\n","List* getData(void);      // read an input and create a list node to store that input\n","List* addToLast(List* head, List* np); // head-->n1-->n2-->...-->np-->.  append\n","List* removeFirst(List* head);\n","void showList(List* lst);\n","List* freeList(List* lst);\n","List* addToFirst(List* head, List* np);\n","List* removeLast(List* head);\n","\n","List* getData(void)\n","{\n","    List* np;\n","    static int ID;\n","\n","    np = (List *) malloc(sizeof(List));\n","    if (np!=NULL) {\n","        printf(\"Enter a name: \");\n","        if (scanf(\"%9s\", np->str)==1) {\n","            np->id = ID++;\n","            np->next = NULL;\n","        } else {\n","            free(np);\n","            np = NULL;\n","        }\n","    }\n","    return np;\n","}\n","\n","List* addToLast(List* head, List* np)\n","{\n","  List * q = head;\n","  if (head == NULL) return np;\n","  \n","  while (q->next != NULL) {\n","    q = q->next;\n","  }\n","  q->next = np;\n","  return head;\n","}\n","\n","List* removeFirst(List* head)\n","{\n","  List *q;\n","\n","  if (head == NULL) return NULL;\n","\n","  q = head;\n","  head = head->next;\n","  free(q);\n","  return head;\n","}\n","\n","void showList(List* lst)\n","{\n","  while (lst != NULL) {\n","    printf(\"{%d, %s, %p}-->\", lst->id, lst->str, lst->next);\n","    lst = lst->next;\n","  }\n","  printf(\".\\n\");\n","}\n","\n","List* freeList(List* lst)\n","{\n","  while (lst != NULL) {\n","    lst = removeFirst(lst);\n","  }\n","  return NULL;\n","}\n","\n","List* addToFirst(List* head, List* np)\n","{\n","  np->next = head;\n","  return np;\n","}\n","\n","List* removeLast(List* head)\n","{\n","  List *q, *p;\n","  if (head == NULL) return NULL;\n","  if (head->next == NULL) {\n","    free(head);\n","    return NULL;\n","  }\n","  p = head;\n","  q = head->next;\n","  while (q->next != NULL) {\n","    p = q;\n","    q = q->next;\n","  }\n","  free(q);\n","  p->next = NULL;\n","  return head;\n","}\n","\n","int main(void)\n","{\n","  List *head = NULL;\n","  List *np;\n","\n","  showList(head);\n","\n","  np = getData();\n","  head = addToLast(head, np);\n","  showList(head);\n","\n","  np = getData();\n","  head = addToLast(head, np);\n","  showList(head);\n","\n","  np = getData();\n","  head = addToFirst(head, np);\n","  showList(head);\n","\n","  head = removeFirst(head);\n","  showList(head);\n","\n","  head = removeLast(head);\n","  showList(head);\n","\n","  head = removeLast(head);\n","  showList(head);\n","\n","  head = removeLast(head);\n","  showList(head);\n","\n","  return 0;\n","}\n"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"915H9TTpiD-W","executionInfo":{"status":"ok","timestamp":1663678674850,"user_tz":-480,"elapsed":294,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"90ecbc17-d78d-4631-98b7-d7d106d5c18b"},"execution_count":28,"outputs":[{"output_type":"stream","name":"stdout","text":["Overwriting Class02_01.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc Class02_01.c -o Class02_01\n","./Class02_01\n"," "],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"FhEUV7ElpYAI","executionInfo":{"status":"ok","timestamp":1663678686658,"user_tz":-480,"elapsed":8516,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"12b91ff9-477b-4cef-e8b7-12d92733bcc7"},"execution_count":29,"outputs":[{"output_type":"stream","name":"stdout","text":[".\n","Enter a name: Bob\n","{0, Bob, (nil)}-->.\n","Enter a name: Joe\n","{0, Bob, 0x555b36544040}-->{1, Joe, (nil)}-->.\n","Enter a name: Ken\n","{2, Ken, 0x555b36544020}-->{0, Bob, 0x555b36544040}-->{1, Joe, (nil)}-->.\n","{0, Bob, 0x555b36544040}-->{1, Joe, (nil)}-->.\n","{0, Bob, (nil)}-->.\n",".\n",".\n"]},{"output_type":"execute_result","data":{"text/plain":[]},"metadata":{},"execution_count":29}]},{"cell_type":"markdown","source":["\n","#### Singly Linked List 實作\n","\n","首先要定義底層的資料型態，假設我們想記錄的每一筆資料，都是由一個整數欄位和一個字串組成，在 C 語言裡面通常使用 `struct` 搭配 `typedef` 來達成，我們替它取個簡化的名字叫做 `List`。其中 `id` 和 `str` 都是要儲存的資料，`next` 則是指向 `List` 結構的指標。透過 `next` 我們就能讓每筆資料記住下一筆資料的位址，進而將所有的資料串連。\n","\n","```c\n","typedef struct t_List {\n","\tint id;\n","\tchar str[10];\n","\tstruct t_List* next;\n","} List;\n","```\n","\n","\n","定義了 `struct`，接下來就要想想看需要哪些函數，讓我們能對這樣的 linked list 做一些基本的操作，例如\n","\n","```c\n","List* getData(void);\n","List* addToLast(List* head, List* np);\n","List* removeFirst(List* head);\n","void showList(List* lst);\n","List* freeList(List* lst);\n","```\n"],"metadata":{"id":"9yNvA8KIt_R1"}},{"cell_type":"markdown","source":["#####讀取資料\n","\n","首先要能夠讀取資料並存放到 `List` 裡面，我們把 `getData` 定成\n","\n","```c\n","List* getData(void)\n","{\n","    List* np;\n","    static int ID;\n","\t\n","    np = (List *) malloc(sizeof(List));\n","    if (np!=NULL) {\n","        printf(\"Enter a name: \");\n","        if (scanf(\"%9s\", np->str)==1) {\n","            np->id = ID++;\n","            np->next = NULL;\n","        } else {\n","            free(np);\n","            np = NULL;\n","        }\n","    }\n","    return np;\n","}\n","```\n","\n","主要是用 `malloc` 取得一塊足夠存放我們自定的 `struct` (也就是 `List`) 所需的空間，將這個空間的位址用指標變數 `np` 記住。如果 `malloc` 失敗了，無法取得空間，`np` 的值會是 `NULL`，這種情況就甚麼都不能做，直接 `return np`，也就是 `return NULL`。如果 `malloc` 確實能夠取得足夠的空間，則 `np` 的值不會是 `NULL`，而是取得的那塊記憶體的位址。因此，接下來就可以讀取資料，把資料存到 `struct` 的對應欄位中。假設我們讓使用者輸入一個長度不超過九個字元的字串，用 `scanf` 讀取並存到 `str` 欄位裡，如果使用者確實出入了一個合法的字串，我們就繼續設定其他欄位，包括 `id` 和 `next`。其中 `id` 的值是從 `static` 變數 `ID` 取得，`ID` 的值每次會增加一，而且由於 `ID` 是 `static` 變數，所以 `getData` 函數結束之後，`ID` 並不會消失，下次 `getData` 再被呼叫的時候，我們就可以繼續使用 `ID` 並取得當時保存的數值。至於 `next`，我們就先讓它指向 `NULL`。這樣後函數最後 `return np;` 就會把新產生的 `List` 的位址傳回去。\n","\n","如果使用者不想輸入，按 `Ctrl-Z` `Enter` 結束，這種情況就應該把剛才用 `malloc` 取得的記憶體，再用 `free` 還回去，並且把 `np` 的值設為 `NULL`，表示沒有讀到任何資料。\n","\n","順便回顧一下，`np->id` 也可以寫成 `(*np).id`，也就是先用 `*` 符號，取得指標記住的位址裡面所存放的 `struct` 資料，然後再用 `.` 符號取得對應的欄位。雖然兩種寫法都可以，但是一般都會採用 `np->id` 的寫法，比較簡潔。"],"metadata":{"id":"qftz6OCiuDtH"}},{"cell_type":"markdown","source":["#####在既有的 linked list 加入或移除資料\n","\n","接下來我們來寫底下這兩個函數，分別是把一筆新的資料加入既有的 linked list 的最後面，以及把原有的 linked list 的第一筆資料移除。這種 linked list 運作方式很像排隊，所以通常稱作 queue。這裡只是舉例，當然也可已依照需求，用其他的規則加入資料，例如把資料加在 linked list 的開頭位置，移除時也從開頭移除，對應的程式寫法就稍有不同。我們主要只是要用這個例子，來示範如何調整指標，達到我們想要的加入或移除的效果。\n","\n","```c\n","List* addToLast(List* head, List* np);\n","List* removeFirst(List* head);\n","```\n","\n","先看看 `List* addToLast(List* head, List* np);` 該怎麼寫\n","\n","```c\n","List* addToLast(List* head, List* np)\n","{\n","    List* ptr = head;\n","    if (head==NULL) {\n","        head = np;\n","    } else {\n","        while (ptr->next != NULL) {\n","            ptr = ptr->next;\n","        }\n","        ptr->next = np;\n","    }\n","    return head;\n","}\n","```\n","\n","傳入的兩個參數都是指標，第一個指標 `head` 指向要被修改的 `List`，第二個指標 `np` 則是指向要被加入的資料，我們想將 `np` 所指到的資料加入 `head` 所指到的 `List` 的最後面。\n","1. 假如 `head` 是 `NULL`，也就是原本的 `List` 是空的，這種情況就讓 `head` 指向 `np` 所指的那筆資料，如此一來就有等於得到了一個 `List`，而且這個 `List` 只包含一筆資料。\n","2. 假如 `head` 所指到的 `List` 原本已經有資料，則要先從頭開始，走到 `List` 的最後，我們利用迴圈來達成\n","            while (ptr->next != NULL) {\n","                ptr = ptr->next;\n","一開始 `ptr = head`，然後持續做 `ptr = ptr->next`，讓指標移到下一筆資料所在的位址，當指標找到最後一筆資料，這時候 `ptr->next` 的值應該會是 `NULL`，所以迴圈可以停止，然後做 `ptr->next = np;` 把新的資料加在原有的最後一筆資料後面。(我們已經假定 `np->next` 會是 `NULL`，所以整個 `List` 經過 `addToLast` 後，仍然是一個具備正常結尾的 `List`。)\n","3. 最後做 `return head;`，將新增資料之後的 `List` 的開頭位址傳回去。\n","\n","再來是 `List* removeFirst(List* head)`，將 `List` 的第一筆資料移除。 \n","\n","```c\n","List* removeFirst(List* head)\n","{\n","    List *ptr;\n","    if (head == NULL) return NULL;\n","    else {\n","        ptr = head->next;\n","        free(head);\n","        return ptr;\n","    }\n","}\n","```\n","\n","傳入的參數是 `List` 的開頭位址，傳回去的則是拿掉第一筆資料之後，剩下的 `List` 的開頭位址。\n","1. 如果原本的 `List` 是空的，就甚麼都不做，`return NULL;`\n","2. 否則 `List` 裡面至少有一筆資料，先用另一個指標 `ptr` 記住下一筆資料的位址 (下一筆資料的位址也有可能是 `NULL`；假如 `List` 裡只有一筆資料，則 `head->next` 會是 `NULL`)，做完 `ptr = head->next` 之後，就可以放心地把 `head` 所指到的那筆資料，透過呼叫 `free(head);` 移除。\n","3. 最後把 `ptr` 記住的位址傳回去，`return ptr;`，成為 `List` 的新的開頭位址。"],"metadata":{"id":"aEhG7Bi2uG-A"}},{"cell_type":"markdown","source":["\n","#####顯示 linked list 的內容\n","\n","接下來要寫的函數是 `void showList(List* lst);`\n","做法很簡單，只要用迴圈把整個 linked list 走過一遍，依序將每一筆資料的內容顯示出來就行了。\n","\n","```c\n","void showList(List *lst)\n","{\n","\tprintf(\"[\");\n","\twhile (lst != NULL) {\n","\t\tprintf(\"%d:%s,\", lst->id, lst->str);\n","\t\tlst = lst->next;\n","\t}\n","\tprintf(\"]\\n\");\n","}\n","```\n","\n","關鍵還是 `lst = lst->next;` 這句。"],"metadata":{"id":"4PdAgHN9uK7a"}},{"cell_type":"markdown","source":["#####清除整個 linked list\n","\n","利用前面已經寫好的 `removeFirst`\n","\n","```c\n","List* freeList(List* lst)\n","{\n","    while (lst!=NULL) {\n","        lst = removeFirst(lst);\n","    }\n","    return NULL;\n","}\n","```\n"],"metadata":{"id":"01K8k7dUuODK"}},{"cell_type":"markdown","source":["\n","\n","#####完整的成示範利及執行效果\n","\n","######*程式碼*"],"metadata":{"id":"AnwyzpxJs5IX"}},{"cell_type":"code","source":["%%writefile E02_01.c\n","\n","#include <stdio.h>\n","#include <stdlib.h>\n","\n","typedef struct t_List {\n","    int id;\n","    char str[10];\n","    struct t_List* next;\n","} List;\n","\n","List* getData(void);\n","List* addToLast(List* head, List* np);\n","List* removeFirst(List* head);\n","void showList(List* lst);\n","List* freeList(List* lst);\n","\n","int main(void)\n","{\n","    List* head = NULL;\n","    List* np = NULL;\n","\n","    while((np = getData()) != NULL) {\n","        head = addToLast(head, np);\n","        showList(head);\n","    }\n","    showList(head);\n","    head = removeFirst(head);\n","    showList(head);\n","    head = freeList(head);\n","    return 0;\n","}\n","\n","List* getData(void)\n","{\n","    List* np;\n","    static int ID;\n","\n","    np = (List *) malloc(sizeof(List));\n","    if (np!=NULL) {\n","        printf(\"Enter a name: \");\n","        if (scanf(\"%9s\", np->str)==1) {\n","            np->id = ID++;\n","            np->next = NULL;\n","        } else {\n","            free(np);\n","            np = NULL;\n","        }\n","    }\n","    return np;\n","}\n","\n","List* addToLast(List* head, List* np)\n","{\n","    List* ptr = head;\n","    if (head==NULL) {\n","        head = np;\n","    } else {\n","        while (ptr->next != NULL) {\n","            ptr = ptr->next;\n","        }\n","        ptr->next = np;\n","    }\n","    return head;\n","}\n","\n","List* removeFirst(List* head)\n","{\n","    List *ptr;\n","    if (head==NULL) return NULL;\n","    else {\n","        ptr = head->next;\n","        free(head);\n","        return ptr;\n","    }\n","}\n","\n","void showList(List *lst)\n","{\n","    printf(\"[\");\n","    while (lst != NULL) {\n","        printf(\"%d:%s,\", lst->id, lst->str);\n","        lst = lst->next;\n","    }\n","    printf(\"]\\n\");\n","}\n","\n","List* freeList(List* lst)\n","{\n","    while (lst!=NULL) {\n","        lst = removeFirst(lst);\n","    }\n","    return NULL;\n","}"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"8h6tk8Sus6O6","executionInfo":{"status":"ok","timestamp":1663591025914,"user_tz":-480,"elapsed":309,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"676d1aa9-c88d-4f1d-a6c3-edf13085e0bc"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Writing E02_01.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc E02_01.c -o E02_01\n","echo \"Bob Alice Cathy\" > input\n","./E02_01 < input"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"dAkcrmfXwFrG","executionInfo":{"status":"ok","timestamp":1663591747010,"user_tz":-480,"elapsed":291,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"7859603b-10c5-4a6b-b7cd-d3b642a13fdd"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Enter a name: [0:Bob,]\n","Enter a name: [0:Bob,1:Alice,]\n","Enter a name: [0:Bob,1:Alice,2:Cathy,]\n","Enter a name: [0:Bob,1:Alice,2:Cathy,]\n","[1:Alice,2:Cathy,]\n"]},{"output_type":"execute_result","data":{"text/plain":[]},"metadata":{},"execution_count":12}]},{"cell_type":"markdown","source":["\n","\n","相關的函數前面都已經解釋過了，只剩下 `main` 要再稍微看看。其中讀取資料的方式是\n","\n","```c\n","\twhile((np = getData()) != NULL) {\n","      head = addToLast(head, np);\n","      showList(head);\n","  }\n","```\n","\n","每次把新的 `np` 加到原本的 `head` 所指到的 `List` 的最後面，然後再呼叫 `showList` 把目前的狀態顯示出來。\n","*有一個細節非常重要，必須特別注意*：在 `main` 的開頭 `List* head = NULL;`，一定要記得設定初值 `NULL`，因為之後呼叫 `addToLast` 會來當作判斷依據，如果沒有設定初值，程式會當掉\n","\n","之後還有 `head = removeFirst(head);` 把第一筆資料移除，並且更新 `head` 指標。最後是\n","\n","```c\n","    head = freeList(head);\n","```\n","\n","將整個 `List` 清除，並且把 `head` 設為 `NULL` 表示是空的 `List`。\n","\n","######*執行過程*\n","\n","\tEnter a name: amy\n","\t[0:amy,]\n","\tEnter a name: bob\n","\t[0:amy,1:bob,]\n","\tEnter a name: cathy\n","\t[0:amy,1:bob,2:cathy,]\n","\tEnter a name: danny\n","\t[0:amy,1:bob,2:cathy,3:danny,]\n","\tEnter a name: ^Z\n","\t[0:amy,1:bob,2:cathy,3:danny,]\n","\t[1:bob,2:cathy,3:danny,]\n","\n","***"],"metadata":{"id":"50DRQf9YtPL7"}},{"cell_type":"markdown","source":["##Example 2\n","\n","#### Circular Linked List 實作\n","\n","Circular linked list 的最後一筆資料會再接回第一筆資料，而非指向 `NULL`。每次加入或移除資料之後，都必須保持 circurlar 的性質，不能讓 linked list 斷掉。\n","\n","為了操作方便，除了既有的資料結構，我們另外定了一個 sentinel node，包含兩個指標 `first` 和 `last`，分別指向第一筆和最後一筆資料。\n","\n","```c\n","typedef struct t_List {\n","\tint id;\n","\tchar str[10];\n","\tstruct t_List* next;\n","} List;\n","\n","typedef struct {\n","\tList* first;\n","\tList* last;\n","} Head;\n","```\n","\n","\n","需要定義的函數包括\n","\n","```c\n","List* getData(void);\n","Head addToLast(Head head, List* np);\n","Head removeFirst(Head head);\n","void showList(Head head);\n","Head freeList(Head head);\n","```\n","\n"],"metadata":{"id":"Mp5lAOxDodYd"}},{"cell_type":"markdown","source":["\n","#### Circular Linked List 實作\n","\n","Circular linked list 的最後一筆資料會再接回第一筆資料，而非指向 `NULL`。每次加入或移除資料之後，都必須保持 circurlar 的性質，不能讓 linked list 斷掉。\n","\n","為了操作方便，除了既有的資料結構，我們另外定了一個 sentinel node，包含兩個指標 `first` 和 `last`，分別指向第一筆和最後一筆資料。\n","\n","```c\n","typedef struct t_List {\n","\tint id;\n","\tchar str[10];\n","\tstruct t_List* next;\n","} List;\n","\n","typedef struct {\n","\tList* first;\n","\tList* last;\n","} Head;\n","```\n","\n","\n","需要定義的函數包括\n","\n","```c\n","List* getData(void);\n","Head addToLast(Head head, List* np);\n","Head removeFirst(Head head);\n","void showList(Head head);\n","Head freeList(Head head);\n","```\n","\n","\n","#####讀取資料\n","\n","首先是 `getData`\n","\n","```c\n","List* getData(void)\n","{\n","    List* np;\n","    static int id;\n","    np = (List *) malloc(sizeof(List));\n","    if (np!=NULL) {\n","        printf(\"Enter a name: \");\n","        if (scanf(\"%9s\", np->str)==1) {\n","            np->id = id++;\n","            np->next = np;  // 這一行不一樣，指向自己而不是NULL\n","        } else {\n","            free(np);\n","            np = NULL;\n","        }\n","    }\n","    return np;\n","}\n","```\n","\n","和 singly linked list 的版本只有一個地方不同，原本是 `np->next = NULL;` 改成 `np->next = np;`，這樣新產生的只有一筆資料的 `List`，`next` 指標指回自己。"],"metadata":{"id":"kCKunX5QucoP"}},{"cell_type":"markdown","source":["![single_node.png](data:image/png;base64,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)"],"metadata":{"id":"xeBb1R4bugj6"}},{"cell_type":"markdown","source":["\n","`main` 的內容如下\n","\n","```c\n","int main(void)\n","{\n","    Head head = {NULL, NULL};\n","    List* np = NULL;\n","\n","    //head.first = head.last = NULL;\n","    while((np = getData()) != NULL) {\n","        head = addToLast(head, np);\n","        showList(head);\n","    }\n","    showList(head);\n","    head = removeFirst(head);\n","    showList(head);\n","    head = freeList(head);\n","    return 0;\n","}\n","```\n","\n","注意到 `Head head;`是一個一般的變數而不是指標，不過 `head` 包含的兩個欄位 `head.first` 和 `head.last` 都是指向 `List` 的指標。一開始必須手動把兩個指標都設定為 `NULL`，也就是 `head.first = head.last = NULL;`\n"],"metadata":{"id":"dBYrUzBlum0z"}},{"cell_type":"code","source":["Head addToLast(Head head, List* np)\n","{\n","  if (head.last == NULL) {\n","      head.first = np;\n","      head.last = np;\n","  } else {\n","    np->next = head.first;\n","    (head.last)->next = np;\n","    head.last = np;\n","  }\n","  return head;\n","}\n","\n","Head removeFirst(Head head)\n","{\n","    if (head.first != NULL) {\n","      if (head.first == head.last) {\n","        free(head.first);\n","        head.first = head.last = NULL;\n","      } else {\n","        head.first = (head.first)->next;\n","        free((head.last)->next);\n","        (head.last)->next = head.first;\n","    }\n","    return head;\n","}\n"],"metadata":{"id":"a3m7oaxrBpQq"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["\n","#####在既有的 circular linked list 加入或移除資料\n","\n","由於我們有兩個指標可以同時記住開頭和結尾，事情會變得簡單很多。先來看 `addToLast`：\n","\n","```c\n","Head addToLast(Head head, List* np)\n","{\n","\tif (head.last == NULL) {\n","    \thead.first = head.last = np;\n","\t} else {\n","    \tnp->next = head.first;\n","    \t(head.last)->next = np;\n","    \thead.last = np;\n","\t}\n","\treturn head;\n","}\n","```\n","\n","傳入的參數是 `head` 和 `np`。由於 `head` 裡面藏了兩個指標 `first` 和 `last`，我們利用這兩個指標就能輕鬆把 `np` 加入既有的 `List` 的結尾，並且維持原有的 circular 性質。\n","\n","1. 如果傳入的 `head.last` 指標的值是 `NULL`，表示原本的 cirular linked list 是空的，這時候 `np` 就成了第一筆資料，同時也是最後一筆資料，因此 `head.first = head.last = np;`。\n","2. 否則原有的 circular linked list 已經有其他資料，那就要找到最後一筆資料，並將 `np` 接在其後。由於要維持 circular 性質，所以還必須讓 `np->next` 指向第一筆資料。我們用底下三行程式來達成\n","        \tnp->next = head.first;\n","        \t(head.last)->next = np;\n","        \thead.last = np;\n","    \n","---\n","用圖形表示上列步驟，"],"metadata":{"id":"XFTchHZQurR9"}},{"cell_type":"markdown","source":["![addToLast_1.png](data:image/png;base64,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)"],"metadata":{"id":"VK8VoBf7uvbX"}},{"cell_type":"markdown","source":["![addToLast_2.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAh8AAAEMCAYAAABk99R5AAAAAXNSR0ICQMB9xQAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAAZdEVYdFNvZnR3YXJlAE1pY3Jvc29mdCBPZmZpY2V/7TVxAABP7klEQVR4Xu2dCbyM1RvHD0oLkUrJ1o5SWUuJIlptkYpSqKgUJXtpX7Ro3zcRSkpKydIiKloIkRTZQhEpor+k+c/33PPe+94xc+/cZdb7+34+rznnzDv3zh3znvd3nvMsxQJBjBBCCCFEnCjuHoUQQggh4oLEhxBCCCHiisSHEEIIIeKKxIcQQggh4orEhxBCCCHiisSHEEIIIeKKxIcQQggh4orEhxBCCCHiisSHEEIIIeKKxIcQQggh4orEhxBCCCHiSoHFx4oVK8yGDRtcL/mgdM2qVavMxo0b3YgQQgghEkmBxMfKlSvNYYcdZq655hqzfft2N5pcrFmzxtSsWdN069bN/PXXX25UCCGEEImiQOLDExxYFXbu3Gnbyca2bdus6OA9/vvvv25UCCGEEImiQOKjRIkS9rFkyZKmWLFitp1seO9xt912S9r3KIQQQhQlCsXhFL8K3diFEEIIEQ3FgsIh4Np55qeffjJHHnmkadGihXnvvfesY+fs2bNN8eLFzdFHH22qV6/uzswOv3LBggXmhx9+sFshRx11lDn22GPNnnvu6c7IYu3atWbx4sVm2bJlpkyZMqZKlSqmVq1aZu+993ZnZOH9XM7fa6+9TP369c0ee+xh9t9/f3P66aebt956y5QtW9adLYQQQoiEgPjIL0uXLkW4BFq2bBl45ZVXAkFhYPsclStXDgwfPtydmZ3LL788EBQHmefutttugY4dOwZ+//13d0YG/Mxq1aplnuede9lllwXWr1/vzsrg77//DvTq1StQrly5zHODwigwbNiwQIkSJQJB8RH4448/3NlCCCGESBSFsu0yZcoUExQE5uKLLzbff/+9GTp0qFm9erXp0qWLOyOL1q1bm6AgMNdff71ZtGiRWbhwoRk8eLB57bXXzPnnn+/OyoBz9t13X2tNmT9/vvnxxx9No0aNTFCUmPvuu89aOjweeugh8/jjj5vdd9/dzJo1y8yZM8cccMABJih0rDMs1hghhBBCJAEZGiR/eJaP4A0/MGbMGDeawVVXXWWfGzt2rBsJBL744gs7dumll7qRLIJCxT63bds2NxIIbNmyxbWy2Lx5sz2vYcOGmZaSxYsXBypVqmTH//nnHzvm0alTJzvevHlzWT6EEEKIJKBQzAHBG7tp376962WAvwV899139hHeffdd+3jaaaeZoEiwyck4aJOLA9555x37CKVLl3atLIiswfcjKDzs6wDfEfJ5XHjhhdby4WfIkCH28b///rOPQgghhEgshRbtsmPHDtfLwHPs3LJli32EpUuX2scHHnjANGjQwDRp0sQeJ554oh0DHEz9sH1y8803W2GBwOnYsaPZvHlzZggtsMUDNWrUsI9+PIEihBBCiOSg0MQHRzj8vhabNm2yj+edd57p3r279ce44oorTOfOnc0tt9xirRSICw98Qxo2bGjuvfde8+eff9rIFfJ1eHjhvV7mUqwioUR6X0IIIYRIDHH1wvRCb9mmISX7jTfeaHr37m2Pnj17moEDB5qDDz7YnjN37lxz3XXXWUGBgMCpdfTo0Wbs2LGmXLly1onUExYVK1a0j8uXL7ePfgi5FUIIIUTyEFfxwfYK+P06IkEUzN9//206dOjgRjLAesJWjj+p2RFHHGFFyqRJk9xIFiNHjrSPinYRQgghkoOY35H9IgEhUapUKfP888/b0NjffvvNjlMjZurUqaZHjx62D54145NPPsn0FeERvw8Sk/m3X+rUqWNOPfVU6y8yYMAAs379erNu3Tq7XYM1xUNZWIUQQojEUyDx4RWWI2IltLCc52jqL2WPYPjoo49sJtO+ffvarKbVqlWzx1lnnWWeeeYZd6YxzZo1M1deeaUVHIgLsqBybN261WZPRWh4Tq78PIQGwgbHVTKgEj2Do+qIESOsVYT3GOoUK4QQQoj4U6D06ogPEntxoz/33HPdaAb4X4waNcqcffbZ5oQTTnCjGbCdgghh+wURQfpzEow1btzY7Lfffu6sDCZPnmwdT4EkZjirTp8+3SxZssRccskl2Xw6cDwdM2aMGTdunKlcubLp16+fFTYvv/yyDc8lwVloKK4QQggh4kuBxIcQQgghRF6RF6YQQggh4orEhxBCCCHiisSHEEIIIeKKxIcQQggh4orEhxBCCCHiisSHEEIIIeKKxIcQQggh4orEhxBCCCHiStTiQ7nIhBBCCFEY5JrhdNWqVaZPnz5mxYoV2Yq5CVGY/PPPP+a0004z9913n63FI4QQIn3JVXz06tXLPPHEE64nRGxZvXq1qVSpkusJIYRIR3IVH1dccYUt7HbggQeapk2b2rL0ubykSEPhum+++cYsWrTI9in1X7VqVVXUjUDx4sVtpeIJEybY/po1a0zFihVtWwghRHqSq/jo1q2befHFF2112kmTJrlRkRN33XWXufXWW2172rRppkmTJrYtwrNu3TpToUIF25b4EEKI9Cdqh1NWp1u2bHE9kRO///67a2XcWEXO/PHHH64lhBCiKKBQ2xjA1pSHvy2EEEIIiQ8hhBBCxBmJDyGEEELEFYkPIYQQQsQViQ8hhBC7MHLkSNOqVStTr149G7FHAsDNmze7Z4UoGBIfQgghLOQjIqkkjvKXXXaZee+992zeounTp5tBgwaZsmXLmnbt2tnoRyEKQlzEx+TJk83dd99tc1+89NJLblSE49133zWPPPKIWbp0qRsRQhQlKGXx999/u15G7puc5gNKYGzbts31MrIEL1y40PWiZ/v27TavE1mtc2L8+PHmnHPOse9LiPwSc/Hxzjvv2C/qLbfcYh5++GFz5ZVX2vGPPvrINGvWzCrrZOHjjz82ffv2Ne3btzcXXnihufrqq83bb79t/v33X3dG7EF43Hjjjebrr792I8kBApKVD5/NBRdcYK6//nozduxY899//7kzhBAFhVxKWBaefPJJs379enutnXzyyXaubNGihZkzZ447MwNEB+c8+uij5tdff7XzFuc3b97c1kpiMRMtQ4cONSNGjHC9nPn000/Ntddea/73v/+5ESHyCBlOcyIoFsiAGmjcuHFg8+bNbjR6eG3JkiUDb775ZiD4RQ0Ev7R2vGvXrva54AVi+4VF8GYYmDJlSmDDhg1uJHeCF23g1FNPDZQoUcK+p9CjevXqgS+//NKdnTu9e/fOfO3rr7/uRqOjdevW9nXjxo1zI7Fh3rx5geDqyPUis2PHjkCtWrUy/57Qo3LlyoHFixe7s/MHr/d+XnA15UaFKHowF+2xxx72mjvkkEPsNXHDDTcEDjvsMNuuWrVqYNOmTe7sQGDjxo2BUqVKBWrWrBmoUqWKPadnz56BunXr2naxYsUy59ycWLt2bWC33Xazr8nLERQr7icIkTfisu2Cs9L5559vgheVadSokR1jdT9w4EAzatQo2y8sUPpnnXWWue2229xIzsyfP9+m9p4xY4bZuXOnG83ODz/8YBo0aGAeeughN5LaYNbl/yE4QWUz14bCZ0mtGj6jSGDirVGjhnnuuefciBAiv1A5vHTp0vaaq127tq2jhTV02bJl5qqrrrJbLP5rjdpIQfFhvvvuO3PMMcdYS+Tjjz9uLSTDhw+3r2crJTd4TX4svFg/c5pDhIhEXMTHPvvs41pZHHvssWbIkCEmuHJ2I4XDUUcdZR+5IeYGab0plhctbMlgbkx1Dj74YBNcVZngasrsvffebjQ7S5YsMd27d3e93GGfGKc0IUT+QSwgAijk+cILL7jRDM444wz7GOr/waKpXLlydsvEn1GZRRgLjMWLF+fqIPryyy+7Vt5g0aYSEiI/xER88EW//fbb7f4jfPXVV3Zfkn1LrAiAzwd7mB9++KHte7BXibJHwV933XW2Kiz+IjhDAXuhZ555pr0QORdfBNi0aZPp0aOHPYBieFhb2rRpk1kxNRR+Pq/LC1T5TQRYGHr37m1D3/i7+bv4G8Mxe/Zsc/HFF5vTTz/d+tvccccdmQ5srKLOPfdcs3LlSvsz+Tn0CaP7559/7Dl4vCMM2UOOFl7L72HyFELkH+Y+xET58uXdSAZ77bWXfQy1NHA+USgHHXSQG8kAi+6RRx5p27mJj/wKCHxUvLlZiDwRvFnkSH58PtiHPOWUUwLFixfP3BvcZ5997OMXX3xhz7n33nttPygsbN+DsXbt2gWCwiXztcFVgPU96NChg+0HL8pAnTp17N4o/V9++cX6ClSsWDHTb4PfzV4obX5XKMEbr/VX4Pm8HgsWLHA/JTyF7fMxbdq0zJ/H316jRo3MflBsubMyCIo5O87nULt27UBw8rH9oLiwz3fq1CnztRxlypSxj0FBZ//fICgQ7e/xnxftMWvWLPsz8oJ8PoTI4LfffrNzJddtKO+//769RoILCzcSsP4fQaFi/T127tzpRrPo3r27fc3PP//sRsLjXX/5OQrq8yWKJjGxfOy3337ms88+y/ShOO+882xymuDvs74TULJkyWyPft566y27l0gJf1Q1+51sd4wZM8Z6guMFTuw5ntZTp041e+65py3DTujXBx98YH8GPh9//fWX/Z1EaYRCZEtQtLhe3hg2bJhrxQcsFESZ8HdzfP/992bDhg12j/fpp5+2+8AeWJtYMfG3zZ07126fBMWS/T8AEgfxWran2Hb5888/7Wc0ZcoU+/8GvC44Cdp2Xvnkk09cSwiRX/JakDK42LD+H6F413G4rW8/edl+9sP2LT4qQuSVuPh8cHPLK6+++qo5++yzrTjBoSqo3O045kg/bL/su+++rpfhgOV/jAQ/L5KDaW4sWrTIteJDp06dzBtvvJHNDLv//vtnThh+h1DK+TPRlClTxo1k+NdUr17d9YzdU+b/hIMtllD4Gfll48aNriWEiAfMdfivsZXqB98QQvZxGmdbJidyy+0RCRaDlSpVcj0hoicu4oObPPuS0VK/fn0rPPy0bNnSihCSlN100032YguHJyhyExYFyd2BpSWRYNXAH8Pz48CS4YGFBEtR27ZtrTNYOPhsEB78n4T7f8lNuOVEOEuWECI6orF4hJ6D1YP5sGvXrtaS6YF/l2c1zQ38wzz/kGjBWd2zqAqRV+IiPvIK4WaodT9sCXgJdnCGxArQuHFj288PWAPyKyIIgYs3WDd4z3w2bDERseJt//gnI7amcCBly4okQ1iK5s2b557NILcJju2Y/IKTmxAif2CJZDvZ2w714zl2hjqPch5CYObMmdYKfMopp9hHtmSxeDBf5gaW0meeeSZPi4e77rrLBgQIkR+SUnx4WwKhsHXAOCFltWrVsn4l3EjDpfnN7QZL1MgRRxzhenmjf//+rhUfxo0bZwUPFo/HHnvM+rlg1SBSJRRWQRMnTrQ+MdRmwO+lTp06tl6Dh/fZYuEI9zkRnnfccce5XvQwARLVJITIHwcccIAVD/huhV6bVatWtdlLOfwgWLBasOWJlYOIQiJfyAvy448/Wr+MaCCKjshAFjbRQB6ggmzRiqJNUoqP3OCmSjgpZkbwO4B62wi5batgWclP2Oyll14aMTdGrCB1MuD3QUpj/Fyw+hx99NF2PJxQQ3Ag0ghpBtLcI0T8REqNzATYoUMH14seUufL8iFE/sGyOW3atGyLBQ8WBVg3Qhc/iBRSBrAtzRyBAzpO5s8++6zNF5IXyA3y+eef2+s/1AJKTiZ8PDz/EZzLWQwJkR9SRnyEi0xhewG8/BTgOT/5/SAiQd4M1H60YClJRCZPLDtc8H6nUUCAgbdCwiwb+jn5zaKeIMO0isMqfiORzKz9+vXL/HyjgcgbXiOESAzeIoTFUUF8rxAdr732mrVsUNuK6MM333zT9rHCUgPGgwVOXvIBCeERF/ERzvkzJ8dQzyHSz7333mtvcCh7ok3YWvBudl7KdvBW3qRtJwkXmfu4YCKBRSAa3xFMkVx8XqKfWOF9Hn5HUKwY7AGTOAzBwcoI06yXoM17DX4hhNCS7As/DypbellKDz/88MyoIELj8BuBnj172jBbkrf5nXixDL3++ut2eysaMO8SBiyEiB8sKNh2wQ8kL0790VCzZk27tYvzOgkbPV83rzgoEGFDanch8kzwJp8jhVFYjoRhwYvEjWTwxBNP2OeCKtqNZMBYs2bNdvld48eP3yXxVfHixcMm8Xr88ceznXfTTTe5ZyLDz6c4U3DVYAvhea8tVqxY4NFHH3VnRUdBkoxdcsklgaA4CASFjhsJBLZs2WI/E+9ncjRv3jwwffp0myRs5MiR7sxAICgysp3Hce2117pns6CwXFDMZZ7TpEkTm+AoHM8++6xN9MZnExQl9iDBG6/3JzwLCrNAUIC4V0WPkowJkT+2b98eOP744wNBcRA2yViseOihhzKv2RYtWrhRIaKnGP8Ev0ARoSgRFgSsA1gbcktWEwqrdByeWHn7wTmKZFnUYMHHwAMnUrYEGA91uGL1z34kvgvsb+J45SXGCoVVPxYSVvmkY2cvNRpmzZplE5ANHjzY9nHyCo2fzw2K5hHmBlgPvDTz0cB+LdssOHyGJu/hsyF0DucywpGBfVdWJP5cJ+wL8zNwKOVzx3ISDram+JlsW/FZVqlSxT0THv4v+X/jK8M2EJ8rYA3y/EfYZ8bRLS/gIOfV4uF9e1YZIURygqXT2wZmLoiU+kCIiCA+cqKglo9UZNmyZZnlqbGuBEWMeyY6CmL5SEX8q6BGjRq50eiR5UOI1GLr1q22xIV33X777bfuGSGiIyWjXWINDlde9lD2UfH1EJFhX9jzgMeSIoRIb3BqPemkk1wvIxJPiLwg8REBMv552z7Dhw+PKnqmqIIzrj+qhq0XIUR6468Hg8O6EHlB4iMCJCHzIj3wTcF3Q4SHVVCzZs1cL0OsCSHSG/IMeakN8BvzpzwQIjckPiKAI+sll1ziesaG7CqbX2QIg/YcZMk1EimBmRAiPSDpmOd0Sp0pQvaFiBaJjxzo27evaxlbV4bUwyI87P96KdlJOkRklBAifSHCzitRgW+cxIfICxIfuTBy5EjXyi5GciKQc/RyWkIItldDAvPrt99+a9tCiPSFkH/PN45q2kVx7hP5I2rxQZ6MPfbYw/WKDp06dcrMQ0KOC/Ke5Ib/c0p0+f14gpOuB3kAos24WJBU0EKIxHHCCSdk5loiRxGHENEQdZIxFK5Xcrmw0/gmMyTQwt/j/vvvdyPGPP/887ZcPSmNQxOhITzuu+8+88orr9j+gw8+aM477zyzZcuWXc5NJ/i7SRZGCnj2f9kLpjgWkTA5FflD1JI47ZxzzrF9JRkTInUgtTvX+vLly+0ijVowlH4QIjdyFR+s/EePHm1vnOXKlStSwgPIEsrNc/PmzW4k44bJZ8F46MfH+QgNLkpAvHCk++fmCSuqa3qQ+4PPI5evmH2t9zqEiOdBL4RIfgiz//TTT209KCLdWIAIkRu5ig/ityk+VtThJhpOQEQa927Gud14RXbWrl1rrSVCiNTgpptuMkOGDLHtAQMGWMuvELmRq/gAMnyyMmXFX1Rvpqh6Qm2vueYaN2Ks9WPYsGHWyqEY9wyn07Fjx1pLGVANs2PHjvbzye17gxWJ+i4NGjRwI0KIVIDspl79KizlzInMl0LkRFTiQ2SBD0f//v1dz9iS9c8995zrCYrPeY6n7dq1M+PGjbNtIUR6Mn/+/Mxy+zigTpo0yRYHFSInJD7yAdtQ/nTCrVu3Nu+8847rFW3Wr19vDjroINvGOZmcH1iIhBDpCVXGy5cvbxMLku2YMHsv/4cQkVCej3xAFEfv3r1dz9jkYw0bNjQrVqxwI0WXAw880LWUclmIogCZjStUqGDb27Ztsw73QuSGxEc+efjhh83AgQNdz5hZs2bZDJ/vv/++Gym6nHzyya5lzKJFi1xLCJGueGnWAadxIXJD4qMA4OF9xx13uF6G+bFFixbWD4RidEUVf4XbDz/80LWEEOlK3bp1XcuYefPmuZYQkZH4KCC33nqrmTx5sq1z4PHCCy+Yxo0bm5YtW5qVK1e60aLDGWec4VrGzJgxw7WEEOmK53AKs2fPdi0hIiOH00ICq0efPn1s9tNQKD1Nhdxjjz3WhpPiF0EeEJKP8fGnWwp2tlpq1qxp2/yt69ats20hRHpChtPDDz/ctkkSSLJAIXJC4qOQoZrrPffcY+bOnRu2rDy5UvAIJzkZeTEQITirYilBpNSrV8+UKVPGnZ2aUGCKvwVnU4QVwqxEiRLuWSFEuvHHH39ki2rTbUXkhsRHjECEkOOCvBd5iYJp3ry5OfPMM80FF1xgDj30UDeaWhBu26RJk0y/F8TIYYcdZttCiPSD8hPUdvHKSpA0UAsOkRMSHzGEtOuYHz/77DOzcOFC63zJjTkaPxCEB74T4bZxkh0sHYgnfGFg5syZ2SJghBDpBcUk8fugmjX89NNPmdswQoRDDqcxhK2VqlWr2kJL9957r/nqq6+sFQS95x1Uxn3qqafstovf94PzcFxlm2b69OluNDUg7v/II490vYy/RQiRvlDVmlQDHkuWLHEtIcIj8ZFg8P/o0aOHjQr55ZdfzNNPP53tIt65c6fdwiCpmb+ybrLjj/7BGU0Ikb6w0DrqqKNcTwsOkTsSH0kEN2wK13300Ufm2WeftVYTj0cffdScffbZZtWqVW4kufFnOi2K4cZCFDUqV67sWrrmRe5IfCQh1Em46qqrzJw5c8xFF13kRjOyqLI9w1ZNslOxYsXMbSStgoRIf7DielABXIickPhIYvAeHzNmjHnsscfciLGWjzp16piff/7ZjSQnCCjymECqWGuEEPnHnyJg48aNriVEeCQ+UoBevXqZsWPHmt133932ceZq1qyZWbx4se0nI2XLlrV5TABPeBWYEyK9QXxQyRokPkRuSHykCISuvvrqq66XIUAYS1Yn1FKlSmVaPhAeGzZssG0hRHrCYoPrHhAfyuIgckLiI4Vo3769effdd13P2Nwhl112meslF0xC3h4w4uO3336zbSFEeoL4IMweyHi6fft22xYiHBIfKQbF6kaOHOl6xrzzzjs2PDfZQHx4e8Ckmf/1119tWwiR+pBAMRRyfXgLDiwf4cTHtm3b7CGExEcK0qlTJxuS6zFgwADzxRdfuF5ygPjA7wMkPoRIL0gH8Pnnn7teBggPb8FBfqJQkUH47f33369IGGGR+EhR7r77blO3bl3bJp35oEGDkuqipq6DfyKSA5oQ6UP16tXN9ddfb4YPH+5GjHU29cLrsYz4r/n58+fbmlUkI/PnAxFFF4mPFGW//fYzjzzyiOsZ88knn9gaMpHg4o93plFv/xci+Xz8+eefckwTIsUgAeJ5551nunbtam688UY75t9qRXxs2rTJtqnzcuqpp1oxkqw+aiL+SHykMFzQmDE92IoJtxeLMLnzzjtt3pBYgKiZMGHCLiLCX6sGB7RQqF3zxhtvmGLFirkRIUSqcMUVV5jjjz/eLoJq1qxpo9tILghYO7ds2WImTZpkjjnmGBuVh6VE1a2Fh8RHikFyMX/Srv79+2euNtauXWtee+012/bA4kBOEMykXt6NwoYKvEThnH/++dlCakk05hEqTNgmothex44d3YgQIpU4+OCDzXXXXWfbixYtsuUh5s2bZ/ssKG699VZrHSHaDX+QG264wT4nBEh8pBgIiL59+5oRI0a4EWMeeOAB1zJm4MCBrpXhcU49GCYComRiBT//5ptvtk5oCJ25c+facfZ2PauGP8nYhRdeaO677z7rKOvlBRBCpB5su5xwwgm2zRbq119/bdtYYCkP4V33nBerxY9ITSQ+UgxWFx06dDDdu3c355xzjvn2229tHRhSrsPq1avN66+/btudO3c233zzjaldu3a2SrmxAOsHlXd5PwieyZMnW3Mr4XewY8cO6xjbqlUru9WCJaZFixb2OSFEarLbbruZO+64w/UiQ2FMIfwUC8jbLyW55ZZbbMQL4PBVoUIFM3jwYLvSQGxQgO6JJ56wz1Oy/6mnnrLtWEJcP3u6v/zyi52UsIJMnz7dhtpWqVLFesPjfAae5UMIkfpUq1bNZl0OB74eEh8iFImPFIaMp+PGjXO9yHz55ZfmxBNPdL3YMnr0aJuHJCfwlCcvCXvGQojUhy2W+vXru14W+KPNmDHD1KpVy40IkYG2XVIYLBt+p85IxEt4wCWXXGLFRU5ceumlEh5CpBH16tUzbdu2db0sqD9FRIwQoUh8pDDcwPGfyAkS+8Qbb7snEt52kRAifejZs2emjxeQ5+eiiy5SKL0Ii8RHinPaaafZsNVIkN8j3pxxxhmmSZMmrpedyy+/3LWEEOlE06ZNzcUXX+x6xpxyyil2LhAiHPL5SANw6GzTpo2ZOnWqG8mAVQjhtokIZ504caJp165dthDb3Xff3SxbtkzplYVIU4iuI/nh1q1bzbRp0yIuQoSQ5SMNIJPo0KFDbcSLH8JaE5VHgxUP0S5+rr76agkPIdIY6k0RQl+jRg0JD5EjEh9pAnk8ECB+GjVq5Frxh7BaQn8pJAWkXm7durVtCyHSlwcffDAh270itZD4SCOINOnVq5dtH3jggeass86y7UTRsGFDc+6559p2ly5dTPPmzW1bCJG+EO1GlIsQOSGfjzTg33//NW+//XZmXYV77rnHFnhCjJDsiyJP8YavFVs+1KJ56aWXbN0XsrCSglne76kJ/jtY2AiVxn9HpBckBxw5cqRZt26dnTeEKGxIu481nJpeEh9pAOXyyWoqRDwgdX6irWqicOGmQCbSJ5980o0IETts3S+Jj9Rn5syZNqwNGjRoYP7++2/bFuFhVUe5by8dNKnoKfkvi0x4WKlgPaNyKY+jRo2yVjWRPmDVogItJfDJz0GJ/G3btumaiABzyObNm83SpUttn0SORB2KyPCZYfn2SmxIfKQBpCo/+eSTbXvTpk22eiRbMSI8hCAPHz7cVtoELgEmX10K4cF5+Pvvv7dRDCtWrLCFC6lMLNIH5gvKNbzzzjvWX2Ps2LG6JnKAOYRQ4tNPP932WcwQdZiILe5Ugc/shRdesEVRQeIjDfCLD9S3P8ugCI+/Bo0ugdzBSkQSqTVr1kh8pCF+8YEFZPz48e4ZEQlq1pDkERAdXmSfiIx/0adPK82Q8o4OCY68gU+AKBro2ogO/zWheTc6/N8tiQ8hhBBCxBWJDyGEEELEFYkPIYQQQsQViQ8hhBBCxBWJDyGEEELEFYkPIYQQQsQViQ8hhBBCxBWJDyGEEELEFYkPIYQQQsQViQ8hhBBCxBWJDyGEEELEFYkPIYQQQsQViQ8hhBBCxBWJDyGEEELEFYkPYXnvvfdMy5YtTfXq1c3xxx9vunbtahYuXOieFUKI3KHM/IMPPmjnkfbt25vly5e7Z4TIjsSHMN27dzetWrUyEydOND/++KNZsGCBGT58uGnYsKGZOnWqO0sIISLz0UcfmaZNm5r+/fvbeWTChAlm8eLF7lkhsiPxUcR59dVXzQsvvGDblSpVMn369DEdOnSw/S1btpjWrVvbthBCRGLIkCGmRYsWZsaMGW7EmL333tuULFnS9YTIjsRHEQexAXvttZd58cUXzdChQ81LL71kLrroIju+fft2u4IRQohI3HTTTXauuOaaa8wRRxxhx4oVK2YPIcIh8VGEWbNmjdmwYYNtn3rqqaZx48a2zYrFb/G49dZbXUsIIXalZ8+e1kfs6aefNmXLlnWjQkRG4qMI891335mdO3faNlsupUqVsm3Yb7/9TOnSpW07EAjYRyGECMfjjz9uatasadv//vuvfRQiJyQ+ijArV67MFBae0PA44IADTJkyZWwbD3YRHxCDWKM2btxo/vzzT7Njxw73jBBCpA8SH0WYn3/+2bWMKVGihGtl4N+v1Q0w9gwbNsyGJjZv3tzUq1fP1K9f35x44ommSZMmpkuXLmb69OnuTCGESH0kPoowodYOP37xsfvuu9tHUbhs3rzZXHjhhfZzvuKKK8y4cePMJ598YlatWmVWrFhhwxVnzpxpRowYYUUI5z3xxBPmn3/+cT9BCCFSE4mPIsyBBx7oWhnmfj9//fWX+fvvv23bEyGi8HjggQesY94bb7zhRqKjV69epm7duubDDz90I0IIkXpIfBRhDjrooExhgY+Bn19++SVzbJ999rGPonAge+yAAQNcL+/gKNy2bVszatQoNyKEEKmFxEcR5rTTTsv09ZgzZ4759ddfbRv8qdVZbYvC4ZJLLrHZYwsKlqlLL73UvPnmm25EiOTAm1OKFy9u8weJ2EEwwNdff23uuusumxySrNQcLHCIQJo3b547M/mQ+CjCkM/DC48jDfJll11mli1bZp555hnz0EMP2XHwEo6JgoG1g4yyhckFF1xgfvvtN9cTIjFMmTLFvPLKK2by5Mlm06ZNdoxt248//tgKZGpHicKDxQf+YszhOKaTi+n11183s2bNsgcLnOuvv97UqVPHHHzwwaZfv37ulcmDxEcR56233jJ77rmnbX/wwQc2O2GPHj0y/T1wdhQFZ9KkSeaRRx5xvcKFyUeIRHLOOeeYzp0720ecpYE5ZPDgwVYgUzuKDKiiYFDyAisHW+H4i0XzmWLRJnP1kUceaZ3akyVvk8RHEefwww+3BeXOPvtsU7lyZTtWsWJFm+2UlQzWEFEwSLpE5sdYhSwz2ROqK0SiYP447rjjbIh46FGrVi1zxhlnmD322MOdLfLD2rVr7dZKfjNO//TTTzacP1kyVkt8CHP66adbRUxY5zfffGO+/PJL8+6771qfAlFwmDRibXamHg+mWCESAduJVLVl2wUrn//AosqWgCgYCLj333/f9fLP3XffnRRzu8SHsLB3WKVKFbtHiAVE9RkKj3vuuce1YseCBQvsXq8QiWDfffc15cuXN/vvv7/Njuw/GC9Xrpw7U+SHGjVqmEWLFrlewSFS7rbbbnO9xCDxIUSMef75510rdrAXPHfuXNcTQqQLN998s/nhhx9cr/C47777zIwZM1wv/kh8CJEmkJtFCJE+kPKgMELzw0GmZKIat23b5kbii8SHEDEknhc2BelUh0eI9GHMmDHWZyxW4KODr18ikPgQIoYsWbLEtWIPIXVbt251PSFEKrN+/XobiRhLsH6QoyURSHwIEUO8JG7xACdhhTMKkR5QYDIeGUqJdMRnLN5IfAgRQ3bbbTfXij1EKSmdtRDpQbx8uJYvX56QBHASH0KkCfvtt59rCSFSnU8//dS1Ys/mzZtdK35IfAgRY6666irXih2lS5dWmnUh0oh4Rq/F0qk1EhIfIpNQ0xuREzt37nS91AAHKj+8f9KbJxIKPMUaUls3atTI9YSIL6HXGPVDUiXyKvS9Uyk2Gd47Cdrixf/+9z/Xih8SH8JC7RHKvW/cuNH2KdNM1cQJEybYfipASngq8JJqHL777jtzxRVXWMsDkSCJgvo51MqJJeedd561fggRb/744w9bwr13795m6dKldqx///6mY8eO5sMPP7T9eEF0GZk7+/btG9W2xffff2+6d+9u5wjKE7D9QFIvaqgwByaSgw46yLVizzHHHONacSSoUEWK89VXX1Gm0B5bt251o9Eza9Ys+9pDDjkkEFTAgaDqD5x66ql2LHhDd2dlMG3atEBwJR8YNGhQ4N577w0EVw3umcTTq1cv+54PPfTQwD///BN4+eWXMz8XPiM/I0eOzHwuHrz55puZv6+wj7322sv9ltixePHiQKVKlezve/31192oSBe45tu0aWP/f3nMC/Pnz8/8Lo4fP96Oef1+/frZvgfX4cCBAwODBw8O3HLLLYEBAwYEnn/++cCkSZPcGQUjuPDI/N1BUeFGIzNixIjM83/44YfAwoULA+XKlbP9Bx54wJ0VHuZC77XMN4XNRx99lPnzY32sW7fO/dbYMmzYsMzfKctHGuBZK/JLixYt7GNwIrChmjfeeKNNu3vyySfbapV+WrdubR577DEzZMgQc9NNNyVVNVWvHk2pUqXM7rvvbutJFC9e3JafTnStmvPPP99ce+21rle4fP75564lRPyhLpT36LW9Wi7UfPGgxP7tt99u03pT3IzS8Pfff7+1PFCKn8iw4A3fnV1wihUr5lqRYW4oWbKkbVOXxj9X0E8kVatWzfw8YwnzfJkyZVwvfkh8JDn4MLBlwBYCNxm2Qbhgr776atO0aVNbcAgTYX7BRPn777+batWqmVatWtmxJ554wj5ys/SHilKhMrRyaqKLE/lh4gAv3JRJhPdfokSJbJNgohg6dKhp3ry56xUOTNYUAxQiUXg3SAS/l2fGEx/+rUD8KPz+Fcw3iI4GDRrYPv5ZLIAoepZfEBye6GDhkRu8P098EC3G3MHfAYm4Ifs5+OCDbSXbWHPZZZeZPffc0/Xih8RHEoDA2LRpk90vpSz1iBEjbCXUQYMGmU6dOtn9fIQGDoVt2rQxAwcONM8995z55JNPbMGhP//80/2kvPPMM8/Yx6OOOsrmiXjkkUdsH0IdniiLHQgE7E2+bt26dgyP7EhhWmTb9Dtu4dC6Zs2asA6gCCxEUCiIHVZM4eBn+/92T3x4FxKTB8KDSSjREwnwvkiXfO6557qR/MMEy+qxX79+bkSIxMD3mu8j15p34/asBv6VO9ehJwi4yb/zzju2RPwXX3xh+vTpY8eBpFeRYC5gzslLJl+cKVevXh02l4VfbPA30PcEVKIXLFhwmfv5XGMFc/4pp5zievFF4iPO/Pbbb9aCQbEgzI5XXnmlVf+nnnqqXRW3b9/eXH755Wbw4MHWPPnGG2+YL7/80r4uFnhbNp6AmDNnjn0E/02fUKxvvvnGtnm/3bp1s2149NFHXSsLUvbiZHnxxRfbPn8vfyNjZ555ZmbaYP4uHFsbNmxoxVXnzp3tOCB2MAnyuYRuLVDHpEuXLqZ27dqZ1hdP6HjOpUwk/A0Iu0Qo+3AwKfN/ynvPL0zgr732mnWMEyLRcPNmUcLigUfwLKSRFkac58+qiSXXY8WKFa6VBYssti5ZhHGz5BHncubGSGDJ+Pbbb81pp51m5x5e8+STT7pnM+BaYn7wYM7w3nMsb/rRwt9cvXp11yt8LrjgAhsplxCCXwIRA/74449AUNlbx6oGDRoEypcvHyhZsmSms02sjrw6nHbo0MG+LiiEbH/u3Lm2f9JJJwXWrFljx+Ctt94KBG/g9rngyiQwb968QPDitn3+vlCHK5xRea5s2bKBTp062bb/4LMYMmRIILi62OW54CRhf4bfeaxdu3Z2zCO4YgoEJz37XNu2be0Y7yEoPALBycP2IShuAuvXr3e9LOLtcBqOpUuXBo4++ujM9xHNcdVVV7lXxxc5nKY3BXE4Ba6x4EImsHPnTtsPLmbstbh9+3bbh6DYCJx99tn2d+y99972d3qMHj068zvep08fN5qB30kx3PHwww+7MzPOLVasmB3fZ599Mtv+w++I+t9//wWCC5lsc0RQjNj37v0tkYi1w6nHZ599FvbvKOiBY/62bdvcb4kP2f4v3ZgoRPhCM1nfeeed9mKrUqVKoHTp0tn+4wvzCK4aMtv5iXbJDf6ebt262Z/PRcCFxoXZvHlzO8ZEMnXqVHd2BkOHDs18Txw1a9a0ETL169fPNs7RuXPnQJcuXWzUBn1EzsyZM+3vrVy5sh2rUKFCYM6cOe6nBwI33nhj5us//PBDNxo9ySA+PIgA6Nu3b6Bq1aqZ78k7giszezN47LHHrKBNFBIf6U1BxUc0+MVHiRIl7Hf+7rvvto/e9/2iiy7KdkOcPXt2oFSpUvY5Fiq33XZbYOLEiYGePXtmuyHzs4GbG9eMN16tWjX7mq5du2aOcbAoKSjxEh/w7LPPZnv/BT1Y/K1YscL99Pgh8RFnUNV8UbnQzjvvvEK1gNStW9feGLx+LMTH2rVrA4cddpj9+SeeeKIbDdhQOe/33nzzzW40A7/4OOWUUwLLli2z40ws3jgT0JNPPmnHgYnHe46bLSBMvDFCZ4GbcO3atTPH80MyiQ+P3r17Z74n7zjiiCPcs4lF4iO9ibf4CHcwL/bo0cNaUDz8i4w77rjDjWZAyL/3nDeP+C0fzBHLly+34+C3wHrzS0GIp/gA/3xbkANxNmXKFPdT44tffMjnIw6UL1/eNGnSxO7Rv/rqqya40jWvvPKKadeuXaaTZH556qmnYp6ND2ctig8Bjq4e11xzTWZYGgl9/HunfvDjCIoX22ZP1YPkW/7U4/Xq1XOtDJ8OIKzXw0t4hgOZV+2xbdu29jEdYP85lGTYdxaisAkKBBu2j88B1zDzYPAGbpMdej4OOKZ78w5Ra8w3frwUAfDBBx+4Vhb4kR166KGuZ2wSRQ9SCaQad955p/VZCTdP5AUyuIZz+o83Eh9xhptvrVq1zKWXXmq9unH0nDVrlmnWrJk7I3pw/DzppJPMtm3b3EhseOihh1zLmBdeeME6hyEagiuRzC8xF3Mk569IFwsTkD+tr+d1DkGRbB8RN97rx48fbz3W33rrLduHhx9+2LXSEyYKIdIN5kHmv7Fjx9rrmcXGCSecYJ+jjYM6zuI///yzHUN8sIjz41/IzJ8/37Wy8OYQD7/TuZeJNdUg/cHKlSutk35BINgh0Uh8JBAiTQgzIxUxIbZ55d5777WPsb5BEXXiwcoE68fzzz9vH/0hb4iocIROAn78z0X6O/idHkR5eB7rlSpVSooQ2sIinOUoGfKTCFHYcK37F00lS5Y0N9xwg+tlhNtiDSHcFDg/NFSWvCAe5DsKJXTR41/tH3HEEa6VehAey5yM9ZeoOf52coIQIsznyEEbyzIRhCQrC4X7TqKR+EgAqG6EA/keCCXNT+nkHj162DDTWDN69GjXMrZqKqGzqG4OQt38IaPeaqWwIdTWExlsXf3444+2zXtJpzLy4SxEOQk3IVIVrJ6hW85+60WFChXsY8WKFe0jWzKE7/shjNbjrLPOcq0sFi9e7FoZ+OdZL7FZKoMF/eWXX7YpEMiXMnLkSJsjioP2tGnT7N8cKWss2+mJROIjjnABkR+DLRZuovh+5Ae2IijkFA/Y6gB+J3lHECPeFxy/Fb78XlKeVatW5Rh3n19Q+sTqA/lGWMGg7r0xIURq4IlpLBkUguQGyUGKdb9/F6Ub4Nhjj7WPQD4fT6CwXUMSRg9yI3kgbABrMgs8LLJkbSYztAdZPdMFtp9YiOI/Q7ZrDtqexQMLiH9L22Py5MmulRgkPuIA+5b4SHADf/HFF+1NuiDws+rXr+96sYO9xbffftu2mQS8rKbsnXIgAIBaMB78feA3ifrbfhBj/pW9/zy/Ey3ixktW5kEVxnhYfoQQhQOCw7uu2UJp06aNOf300+2BL5m3rXLrrbdmOqgjQry5jm0Grnn8P7C6elu+lC3wLKPMId727YEHHmhLQuB42qtXr8yfT7Vdz7JSFOAz47MIJRYLxbwg8RFDFi1aZEu6o0DxkfA7V4YDdcoXBQcsylOHg+gHv4KPJbNnz7Z+FewntmzZMjOyJRS8zrmYOXfhwoV2jNoOvI4U7aGl3ikVzXNVqlRxIxlwHmM8F7qdQrSQPxqGjIX8PiFEaoBAwEGeuYIolEMOOcTOjRzUJ/LK2OPI7oebJAsuzmOrhu1JbqZsWZMp2Z+anXTuzCH4QVB+ggyh/F7mTbZwiJjBaluU4L7i1drx4znzJozgylMUMmSku/LKK6POSkfyHDJ4jh071v2EQODaa68Ne+5TTz3lzsjCK4nPUZh5PohdJ05+1apVucaxU5KZc73SzP/++29g9erVNr9HcDVixzyI4//pp59sJkE/nLdy5cqIv699+/b2b9xjjz1shtOCkIx5PvjOeO/JO4KCyz2bWJTnI72JR54P4BoP3vQyD651jmggMRhl5smwvGDBAjeaHeYNfh7ziAfzIxlU/WOFQbzzfBSEWrVqZb5X7wgudN2z8UN5PmIENQF69uxp9xnZfgh+1u6ZyFx33XV2b5I9TPbpIPhFDhv5gPLH0TReoJhZobCSCLdn6IeVCOd65j1WGlgmMJ+GOlJi1WAfMjSSg/P4G8P9PmrOeLH5qHjCjIUQqQXXOD5c3sG1zhENWFHZoiE/kt8XxA/zBj+PecQDawvbtv6xokY4x3zuM4lE4qOQoDos2wWEgUaq8uoH0UE8O45Q+FL4k0mxbxkaVgbJEJudKAi9W79+vW2zBSSEECI6wm27JBqJjwJCKFPNmjWtRSK3MFOUPh7bOEQhOryy06EgPEKrQeJXwZ5oUYTPYu7cudbnBGtJpNAxIYQQu0LwQCheVFCikPjIJyTIwRMbx0ccS3MCR0myhCJUbr/99lz/0zGH+ctN491NKJoXXVLUwGGMhGbTp0+3n3UyqnghhEhWwqVTT/T9ROIjH5C8plWrVmbIkCFuJDzss3HTJAEM4aj+OgM5gQXljz/+cD1jfxd1EIoqiDX2a0mqw9aWEEKI6Am3jZ/o7MkSH3kEp0fCwj7++GM3Eh5SppOJE4tFuBjrnAi1fGAtEUIIIfIKC9lwAQzHH3+8ayUGiY88QEVasmpGytfBCr1x48bWckEujkg+HbmBSvUsH4iXRH9JhBBCpCbkXqKOWCiJjhiU+IiSRx99NFtJ5lBIavPSSy9Zy4i/emJ+wPLhFV3i9wohhBD5AQt8OJ8PQpATicRHFLz55pvZUoiHQujn1KlTC63eimdZYbvFXzZaCCGEyAtkjQ1HpIzV8ULiIxcIUSL5V6SEYY888ogtkBRtopxowN8DZ1VSswshhBD5gZxT1MQJpWnTpq6VOCQ+coEcHpGgousNN9zgeoUHyceoukheECGEECI/kBn6+++/d70skiFRo8RHDtxyyy2ZlRP9lCpVyrz++uumS5cubqRwISX51Vdf7XpCCCFE3qEoX2jCSqBQZ6KR+IjA6tWrrcAIx4MPPmguvPBC1ytc2N4hKVn16tXdiCjKRFMfKF4k03sRQuQMEZO4BIRCNeFkuL9IfERgzJgxZsmSJa6XBQWKKMscKwjX3WOPPVwv78hBNTqSMVtsuCgpSognA5Qqz624oEgPChqtV1QoXbq0a2UUtEs2KJk/c+ZM18uid+/e1nqfCPzzbrHgakbLmRCWLl1q83msXbvWjWTABIwJi3TnycQXX3xhTj75ZNseNmyY+euvv2xb7Apfdy48asU89dRTdmzChAlm2bJlu1TfjQe8H34v36nhw4dbM6mfo446ytYDIk4/EbUYeH+8N7735K7hEWF+0UUXuTNEOrBjxw7Tvn17ey1QMXbQoEHW9ywR37lkh2uCBeJ3331na3QB1240BUXjAe+PkhTPPvvsLvMJUBaEquK4FMTr/9ebd2fPnm3flzcoQnjuuecQZLscAwYMcGckF59++mnY96tDRyyOUaNGuW+eSBe2b98eaNmyZdj/bx06YnHI8hEC2UXJKEpiFj+kSP/ss8/sSjTZwD+Fire852Qy//HV4v38/vvvNusr9VlIdsOhFVUGfEaexeXXX381O3futG0PttHKly9vV6aJ/sx4D+QGeO+99+STlIZg0QousOwcWKJECTcqUgXmEuYILAxY78Pd2sm6zZzCPJOo+YQ8Vu3atdO2SyhUTg3nCUySMSrTJiv8h3KDT6abunchDB482JrscX4ixAvz5H///efOEphw58+fb83ea9ascaMZvPjiizazbqSU/vGEqYItmGTxQxGFD9tquiWkLt7is1KlSrtEuTA2bdo0W5wzXMbTeMHcT1E7iY8QuAGMGzfO9TJgxT558mRz9NFHuxGRF1C548ePt+1Ro0blmKa+qII1gerFoZAgiGq+QggRDeSIGjlypOtlcffdd5ubb77Z9RKPol1CCBUewOQv4ZF/8Lr26NSpkxUgIjuLFy92rSywMCTKK10IkXp8+OGHmQu9UJJJeIDEh49I/2nNmzd3LZEf1q9f71oZXHrppebJJ590PYEZcuzYsa6XBYWf8DUSQojcYCslUrQj4bXJhsSHj9dee821ssDxCmdOkT/wVVi3bp3rZdGzZ08JEAfpj8MVf8L3iJA5IYTIDfwVw93DSCp2xx13uF7yIPHhIzTCBaivotVn/sHpCe/5cCBAiDkv6owePdq1siCqpEGDBq4nhBCRwXoayUKPr0cyOolLfDgWLVpkfvvtN9fLQs6RBYPkWDkxZMgQc/vtt7te0SScBQgfo7p167qeEEJEJlK5jzPOOMOcf/75rpdcSHw4MH2TjyKUbt26uZbID+EcKUPBJDhw4MAiGeKH8NiyZYvrZcGkUa5cOdcTQojwkF01XKAEYbdkqk3WkhsSH45NmzaZf/75x/WyOPTQQ11L5IeFCxe6Vs6QB+SGG25wvaLDM88841rZ6dy5s2sJIUR4Vq5cabdVwtGjRw/TtGlT10s+JD4c/CeGJr5SkbaCM2vWLNfKnccff9x07NjR9dKffv362e2+UIgGOuKII1xPCCF2BX86aiz99NNPbiSLY445xjz66KOul5xIfAQh1WxoOChUq1bNtUR+CefEmxOkeO7SpYvZtm2bG0lP2I569dVXXS87kawhQgjhcd9994UtHAcvv/yyayUvEh9BCAelrkYoNWrUcC2RX/JT6XHEiBGme/fuSZFSPFb07dt3l6rJcM011yixmBAiRyZOnGjFRzjuuusuc+KJJ7pe8iLxEQTLRzh/Dzn8FZz81nAh/DRdy7Yjrpg8QqHoE1sxQggRiWXLlkWMwjz99NNTZg6R+MiB/N44RQbfffedLXaXXyZMmJCUVYQLAtstbCuFg/THhx12mOsJIUR2VqxYYZMPhhaNg8MPP9xu5VKoMhWQ+MgBr9S5yB8//PBDWItSXqA09CmnnBI2DDrVYOI488wzXS87bdq0KZLRPkKI6Pjjjz9sFJy/VpYfLKoHHXSQ6yU/urs6wuWY2LFjh2uJ/IAXNltaeYF09qHMnDnTtG3bNmwSuFQBEdarV6+wEwc+HoTLFStWzI0IIUR2unbtambMmOF62Rk6dKhp1KiR66UGEh9BSpYsafbdd1/Xy2LVqlWuJfJDJIWeE/379zevv/76LqGmXHSnnXZayjqhMnG8++67rpedl156yRx77LGuJ4QQ2SEFwdtvv+162aFoXJ8+fVwvdZD4CLLnnnvaGi6hsG0g8g+J28JBGG2LFi1cLzukW6cqI9stOFbRL1++vNltt91sFlqcgFPNInXWWWdFDKsdMGBA2jrWCiEKDgsyUhCEo2XLlubee+91vdRC4sNRsWJF18pClo/8g8AIlzvl1ltvtcnbHn74YesgFY4rrrjCnofzJWnX+TlTpkyxYahVq1Y1BxxwQJ7zhyQC0qZfffXVZurUqW4kO+3atTP33HOP6wkhRHYIm33wwQddLzv4wpETiMVzShIQltGjRweCq2scP7Id//77rztD5IU1a9YE6tatm+2zPPbYYwM7duxwZwQCX375ZaBs2bLZzvEf3bp1C+zcudOdncGGDRsCzz33XOCBBx4IbNy40Y0mH7zPs846K+zfxVGvXr3Ar7/+6s4WQojs9OnTJ+zcwXHwwQfbOSaVKcY/wT+myMN+PPtqW7dudSMZfPHFFyptng+wTGASXLJkiRsx5o033jDt27d3vQxmz55tTjjhBNfbFawfbL+EQggvWzEUT0o2sPqcfPLJ5ttvv3Uj2eE9BycOU6ZMGTcihBBZ4IB+yy23uF529t57bztvUvk6ldG2i6Nx48Zht14oeCbyDqGx/lj06667bhfhAfXr1w9bm8Bj+fLlNgpk/PjxbiQDtm6SUXjgLEv0SiThgeAg8kXCQwgRDradIwkPCp2SPynVhQdIfDiIdqlQoYLrZTF9+nTXEnmBmHSvPgt+Gjl5Y+P78emnn5oqVaq4kV3BP6Jbt245CpVEgki66qqrTIcOHdzIrlDsae7cua4nhBBZYM0lAeGwYcPcSHYOPvhgu7hJl0rrEh8+wpUf5iaqqJe8Q90SbwsLE2JuFwwx6u+//36Oiv7FF180Z599dtJVa3zsscfs+3r++efdyK6QRAyn2UhOtkKIogvWUKLiSBQWDiL+mB9ToWZLtEh8+OjUqZNrZUGK9VCTv8idX375xSZuQ0xQIj4ayHVBlUbqE0SCEFzi2sn5ESlvRrz4+uuv7XslM2lO0Tc9evSwMfrhwrmFEEUbEjEyn2H9jcRHH31kateu7XrpgcSHj0h1REaNGhU2l76IzLp16+wjDrt5YZ999rEX2gMPPOBGwkPSsdatW9uwW35HXjOpFgScaE866SS7Cpk2bZobDQ8hxU899ZTrCSFEFgsWLLBO9ZHmSbai58+fb4477jg3kj5IfIQQzsF00aJF1uQlooMspFgo7rjjjnw7VlKZkQuyYcOGbiQ8GzdutJElbOuQbAcfHfJrFCb8PfPmzTPPPvusOffcc021atWshSYneE9s12GlEUKIUN5880273RwpEzRRgJ9//rk5/vjj3Uh6oVDbEHBoPPLII10vC7YOXnnlFdcTOcGWy6BBg+xRvXp1N5o/cMKiJgr+HtFAwh1MmLVq1TL16tWzfjzsl+aHWbNm2boyHF999ZVZvXq1eyZn8FQnuufAAw90I0IIkQWLXObHSLffOnXq2G3lSpUquZH0Q+IjDOSnmDhxoutl8cknn9gbm8gZ0qpjLSIDX2GB6ZGbel78PKjZw8VLpUcibhAjiCFWEogU/Hk8EBZYKvg9WFywnuA0i2UlWnAYw9qjvDBCiEhcfvnl5uWXX3a9XcGP7LXXXkv7xYvERxhIh82NJBRuWtycROIgVJWQVpw9kwVCaNmSIVeMEEKEA6t6q1atbI2qSFx22WXWypuMOYwKG/l8hAFHwmbNmrleFiSOykmxitiDOZItEATiBRdckLDVAVkGeS8jR460SX8kPIQQkcAXjUVKJOFRvHhx62RPqG1REB4gy0cE3nnnHZuR899//3UjGVBVFRM9Nx+ReEgzzFYMUSc5haoVFmzfUIUWXxKsY0waQggRDu4fd955py0QFwkSXD733HPmwgsvdCNFA4mPHCBxFImhQrnkkkts+K1IHvAzIcIGAcKFTnK4woTMg23btrW5SJQoTAiRG1TjJuNxTuH4zCWUy8+pvlW6IvGRA6QHp05HOLjBDR482PVEMjJp0iRrxmSvFXFCMTccSf2Oph7Uj+FgFUIaY0J32VahJH46e5wLIQofIiM7d+7seuFh23js2LGuV/SQ+MiF22+/3UYwhFKiRAm7NdOiRQs3IpIdQoBJFkfad4QIYoOvP9Vx8R1hr5WkZRxCCJFX8P9iUUpG40gw37B4HThwoBspmkh8REHdunXDFgTbf//9rSNRzZo13YgQQoiiyDPPPGOGDBkSMWkYkEOKc8JV+C5qSHxEAWGdZ5xxRtgU66S/RYCQIlcIIUTRYvPmzXaLJSdrB+BQ+uCDD1qndaFQ26jAGYgvTThQuYTl4uwohBCi6IAzKU6juQkP6jtRDl/CIwuJjyjp1q2bLRIWjuXLl5tTTz3VZkAVQgiR3rDYbNOmjc1GmlMWZBamWEaobC2yI/GRBygS1qdPH9fLDs6MhGLihCqEECL9wFn9tttus4vNCRMmuNHwPPHEE/YcKnWLXZHPRz7o2rWrGT58uOtlh3oi1CBRGK4QQqQPo0ePNnfffbdZvHixGwnP0UcfbTNhq8ZTzkh85AOy1pF0ii9jJCi9Turt/fbbz40IIYRINbBqX3PNNVFZtW+99Va78CwqKdILgsRHAaBsOo5EkSBh1RtvvGGaN2/uRoQQQqQC5AJ6+umn7TZLblAx+6GHHlLV8zwgn48C8OSTT9oEZCQcCwcpvgnR7devX46x30IIIZIDLNuUtEdI5CY8iF5hK4YaUxIeeUOWj0LgrbfesqWQcUaKBOm6b775ZnPllVe6ESGEEMkE1bLvuece89lnn4Utw+DnxhtvtNZv5XjKHxIfhcSqVatsEaFZs2a5kfCQxvu9994rkoWEhBAiGfnyyy9tEjDm8dzAofSDDz5QzacCom2XQgLz28yZM82AAQNszZBIUOnwxBNPtNsxqOzt27e7Z4QQQsSLHTt2WCdSwmZPOumkXIUHouPZZ581ixYtkvAoBGT5iAHjxo2z+fvnzJnjRiJDohqqG7Zq1cqUKVPGjQohhIgVbJVT8Tq3XB2ATx85nvr27WsOOuggNyoKisRHjMDZFO9nnJGiAeVNkrJLL73UlnQXQghRuEyZMsUGCkyaNMns3LnTjUaGheHVV19tM5mKwkXiI8YQI84XN7fENB577LGH/cIPHTpUKlsIIQoBSl+Q4vz77793IzlDgMD7779vt1pEbJD4iBP4g5CaHcemaD9yEpTddNNNpkmTJuaII46weUOEEELkDgs+/OrYMsktcgVY+JGV9P7777eWaBFbJD7iyD///GPGjBljU+/mpQhdqVKlTP369c0pp5xi6tata84++2w7JoQQIjsff/yx9ekgwSMO/tFwzjnn2O2V1q1buxERayQ+EgBVDrGA4DnNRZIXSNtbq1YtW8aZpDY4rMrzWghR1GFRR0kLEn5t2bLFjeYMlg4s0i1btjR77bWXGxXxQOIjwRARQ6n+8ePHm7///tuNRg9ihH3Jpk2bmoYNG1pBIl8RIURRgIUcNbbYKlm5cqUbzR3mTOZdrMgiMUh8JBFcDK+88or56aefzF9//eVG8w4KnsJ2559/vqlWrZopW7asDePdf//9I6aCF0KIVGD16tX2oLTF5MmT3WjuMA8ef/zxZtCgQXabRSQWiY8khHAwLiqypWIZodZAQShdurQ56qij7HZN+fLlzTHHHGOqVKlis60ecMABCu0VQiQ1a9eutfPhjBkzzNtvvx1VJlIPIlfIo0QGaqzDIjmQ+Ehifv31VzNv3jx70WFaxCJSGOy2225mn332sdaQcuXKWf8RRAk1CtgDxalVCc+EEImGxdewYcPM9OnTzdKlS/OUEfqQQw4x/fv3t1vSCplNPiQ+UoT//e9/9nHUqFF2ewYhQvRMYcO2DCFnPBLqe+yxx1o/ElYMrCA80SKEELGAtOdsqTz++ON23qOfF2rUqGG3r+vUqWMXWiI5kfhIUfhv+/TTT60Zklh2xAjOVwXxFYkWLCQVK1a0FhMibQgDpo9Y2Xvvve02DwJF/iVCiJxgSxkL71dffWU+/PBDm4Ig2kRgfthGbt68uenVq5epXbu2GxXJjMRHmkAmVbZouHj//PNP8+OPP9qLmAs7XlBQD/8RRAmOrggTnFxLlixpI3B4jkRpPE+UTvHiqmsoRFGDRRJbycxXFGmjyvfvv//uno2eChUqWKss28Rdu3a1W8cidZD4SFOoLbNixQqzceNG8+2331ohgnUEUYKneLzB/IkQwSqClQRBQh9BcuSRR1qrCc6viBQcYemz/SOESH2+++47679BAjDmIvpbt251z+YNylW0b9/eNGrUyBx33HFuVKQaEh9FCPZOsYqsW7fOWkqWLFlixo4dayeFaJPyxAqsJmzTcLBlg0jBSoJIwVmMSYaIHSJ1sKjsueee7pVCiGSEDKOvvvqqWbZsmZ1r8pPHyA+FOslAyhaLFiapj8SHyIT6B2QHxAyK1YQtGw5SFG/bts2KF8/xNZmoXr26qVy5srWgIE6wniBOEC/4oGCeRcRwsN3jHdr2ESJ/UBGWOQHrBZZUQl+xZhAG+80337iz8o9nIWVb5a677lLixDRE4kPkCPuzCBDi7Ddt2mR++OEHO9kgSOgz6axZsybfJtRYgwhhL5haOCQZ4mBLhy0f2mzxEMHDwdYQ20CIEsL0SNamyB5R1OEWgfUCa6m3IFm4cKG1ZjAXkFk0LyGwkeCaIxcRVs5mzZqZevXq6fpLYyQ+RL5hq4YJiW0cfEsI/WVbZ/78+XZSQqgwMRXU3BovEB0IFR4RIQgXJj9ECJYSQLgwRpVhVmeYgHlka4jVIOdySSnSR6QSRJ0QKcf1itBAXOAfxrXLAuTnn382v/32m73OCxOczy+44AIbMUeILNeRrp2igcSHiAls0bAaYlLDQsKkhpUEr/YFCxbYSYytHcRLtJUnkw1Eird9g1Bh2wprCn0vogf/FMQKzrQ8YmGpWrWqFSiYkhnD3wURI0SsYIvEExBYMT2LJYuE5cuX20cvpwaLiIJmVc4JHEUp/0DWUa4TtkZF0UPiQyQcvoJMeogRshjOnTvXTohff/21FTBYFJgYOegzORaGmTcZYevHs57gy4Ilhr+/SZMmdmuLyZpkbwgWxIuXRIlHRA8CCNHj/QwOtpxYTdLmUc56qQX/b4gH/n955P8YiwTXDN8NQOAj6Ald5fmJEydaoc91lKgtUb53XvgrVWM7duyo9OYiE4kPkRIwgWIlYbW2YcMGaxJGhDDOHjTbPYzTZ2LGhEwbkZKMTrKxBCsM1hVWr9yI2CLiRkCfRwQMlz0HIoUxzkPA4APDI88hYhA43PSAMcSLZ93xpg6EEM69nsDxxtiO8sSRR7oKH0SBt13A3873ju0Kb4zPhfB3Pmc+O8QC4oHnEQ2cy+eNYOC7zDmM87wXNs/z3jYmlotkEuBY9hAaOHfj+M0WCkXcSPwlRDgkPkTKw+qPidjzvkds0GbSRoQgWnjkHLZ4mMAxP9PGFJ0qPinxgJueJyy48SEguJkCYzzH1pF3DvA820ec743xPE69iA3/FIO4CR0Lhee40fIzkwH+Fr5P+Dh5YsLDew4BzHvmvfN58J3i++U/H1HhiQ9PiHjn8p3lXARJKkDqchxDiS4jKgWBi1ClVhR+UULkhsSHKHJ4e9oc/jaTP2KEMdLWc1MgIRI3CvxUPEsLNw3P3C1EusL1gJA44YQT7LYfYa/4JnHLQBhiNQsVY0JEi8SHEPmAVS2rVZz3ECOEHbKKJVIAIYMDn7clxHaQf/uHlTKwymWc1/EaIWIJlhnv8LbECG9lu4QCkmydsCWHBQNHabZQhIgVEh9CxAEECpYTHglB5hGLCpYWzPA80gf2+j1BglChjYDBEkOb/X5uHPgJYMpnTJaYogv//wgILBFsdfHdwEKB7w+J9bxxtkjY9mJrhC0TXifLhUgUEh9CpAD4GyA+ECqe+GDMEx9YUbwU+fSJckC8cB5OjFhqaHO547TLI+cheDzHSMQRIgchw3NYalLFByGVwYeG/w/+bxER/F/gBIxg4P8CweAJCfLPcC4RT5zDweuwWiAy2Cbh9bJaiGRH4kOIIgCWFgQFIDKAPgLFExs8ImA4lxsa53mCBrzzGeN54JGtI0I8ec4b52exFcXWE2McCBmKG+L8650XDn4PQgsLUTJMT9zMybzJe/G/Hz4nxIKXtwX4G3HAPOywwzKFG4+cg3Dgc0EEEjFEm88BSwSv5+9GiPD7GPfEIo/e58U5QqQ+xvwfZHngq1qiHcgAAAAASUVORK5CYII=)"],"metadata":{"id":"lUOHd-Zgu0Lg"}},{"cell_type":"markdown","source":["![addToLast_3.png](data:image/png;base64,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)"],"metadata":{"id":"qCwxyeffu2N-"}},{"cell_type":"markdown","source":["![addToLast_4.png](data:image/png;base64,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)"],"metadata":{"id":"u3mMcAbUu340"}},{"cell_type":"markdown","source":["\n","有了 `first` 和 `last`，把資料移除的做法也變得簡單許多。\n","\n","```c\n","Head removeFirst(Head head)\n","{\n","    if (head.first != NULL)  {\n","        if (head.first == head.last) {\n","            free(head.first);\n","            head.first = head.last = NULL;\n","        } else {\n","            (head.last)->next = (head.first)->next;\n","            free(head.first);\n","            head.first = (head.last)->next;\n","        }\n","    }\n","    return head;\n","}\n","```\n","\n","1. 如果 `head.first` 不是 `NULL` 才有移除的必要，否則就直接 `return head;`\n","2. 接下來分成兩種情況：\n","2.1 如果只有一筆資料，也就是 `head.first == head.last`，就把那筆資料移除，`free(head.first)`。移除之後，`List` 變成空的，所以要設定 `head.first = NULL;` 而且 `head.last = NULL;`。最後會把更新過後的 `head` 傳回去。\n","2.2 如果有超過一筆資料，則 `head.first` 和 `head.last` 會各自指向不同的地方，這時候的移除需要三個步驟，順序不能亂掉，否則會遺失需要的資訊。\n","                (head.last)->next = (head.first)->next;\n","                free(head.first);\n","                head.first = (head.last)->next;\n","2.2.1 先是把 `(head.last)->next` (原本只到第一筆資料)，改成指向第二筆資料。第二筆資料的位址可以用 `(head.first)->next` 取得。\n","2.2.2 再來就可以把第一筆資料去掉，`free(head.first);`\n","2.2.3 然後更新 `head.first`，讓它指向原本的第二筆資料 (現在變成了第一筆資料)，該筆資料的位址我們剛才已經用 `(head.last)->next` 記住。\n","\n","上述的步驟就不再用圖形來說明，但是大家可以自己試著畫畫看，對於理解操作流程會有幫助。"],"metadata":{"id":"ON5aa--qu5j9"}},{"cell_type":"markdown","source":["#####顯示 linked list 的內容\n","```c\n","void showList(Head head)\n","{\n","    List* lst = head.first;\n","    if (lst==NULL) printf(\"[]\\n\");\n","    else {\n","        printf(\"[\");\n","        do {\n","            printf(\"%d:%s,\", lst->id, lst->str);\n","            lst = lst->next;\n","        } while (lst != head.first);\n","        printf(\"]\\n\");\n","    }\n","}\n","```"],"metadata":{"id":"BVvdMuP1u-UB"}},{"cell_type":"markdown","source":["\n","#####清除整個 linked list\n","```c\n","Head freeList(Head head)\n","{\n","    while (head.first != NULL) {\n","        head = removeFirst(head);\n","    }\n","    return head;\n","}\n","```\n","\n","完整的程式碼就不再貼出來占空間。如果想要測試，只要把上面程式碼片段整合在一起，一併編譯就行了。程式的執行結果和 singly linked list 版本相同。"],"metadata":{"id":"MWQ5t4C3vBVS"}},{"cell_type":"markdown","source":["\n","####將資料和 linked list 分開儲存\n","\n","最後再補上一個範例，用 linked list 來實作以 cons 方式構成的 list。在這個例子中，我們將資料和 linked list 分開儲存，另外用指標指向實際資料所在位址。由於時間的關係，這個例子應該不會在上課的時候講解，有興趣請自行研究。不過，無論如何，前面兩個例子，singly linked list 以及 circular linked list，一定要搞懂，而且要能夠自己寫出來才行。"],"metadata":{"id":"9pxTmw8pvQD8"}},{"cell_type":"code","source":["%%writefile E02_02.c\n","#include <stdio.h>\n","#include <stdlib.h>\n","\n","typedef struct {\n","    int id;\n","    char str[10];\n","} Node;\n","\n","typedef struct t_List {\n","    Node* data;              // 透過指標，記住資料所在位址\n","    struct t_List* next;\n","} List;\n","\n","Node* createNode(void);      // 用來產生資料\n","List* cons(Node* nodep, List* lst);   // cons 將資料加在 List 最前面   cons head tail\n","void showList(List* lst);\n","void freeList(List* lst);\n","Node* head(List* lst);       // 取得 List 第一筆資料\n","List* tail(List* lst);       // 取得扣除第一筆資料之後 剩下的 List\n","\n","int main(void)\n","{\n","    Node* np = NULL;\n","    List* lst = NULL;\n","\n","    while((np = createNode()) != NULL) {\n","        lst = cons(np, lst);  // 不斷用 cons 把新讀取的資料加在既有的 List 前面\n","        showList(lst);\n","    }\n","    showList(lst);\n","\n","    printf(\"%d: %s\\n\", head(lst)->id, head(lst)->str);\n","    showList(tail(lst));\n","    freeList(lst);\n","    return 0;\n","}\n","\n","Node* createNode(void)\n","{\n","    Node* nodep;\n","    static int id;\n","\n","    nodep = (Node *) malloc(sizeof(Node));\n","    if (nodep!=NULL) {\n","        printf(\"Enter a name: \");\n","        if (scanf(\"%9s\", nodep->str)==1) {\n","            nodep->id = id++;\n","        } else {\n","            free(nodep);\n","            nodep = NULL;\n","        }\n","    }\n","    return nodep;\n","}\n","\n","List* cons(Node* nodep, List* lst)\n","{\n","    List* hp;\n","    if (nodep==NULL) return lst;\n","    else {\n","        hp = (List*) malloc(sizeof(List));   // 產生一個 List 結構  並且用指標 hp 記住位址\n","        hp->data = nodep;                    // 把其中的 data 指標指向 nodep 這筆資料\n","        hp->next = lst;                      // 把 next 指標指向 既有的 lst\n","        return hp;                           // 把 hp 所記住的位址傳回去\n","    }\n","}\n","\n","void showList(List *lst)\n","{\n","    printf(\"[\");\n","    while (lst != NULL) {\n","        printf(\"%d:%s,\", lst->data->id, lst->data->str);\n","        lst = lst->next;\n","    }\n","    printf(\"]\\n\");\n","}\n","\n","void freeListHelper1(List* lst)\n","{\n","    while (lst != NULL) {\n","        if (lst->data != NULL) {\n","            free(lst->data);\n","            lst->data = NULL;\n","        }\n","        lst = lst->next;\n","    }\n","}\n","\n","void freeListHelper2(List* lst)\n","{\n","    if (lst == NULL) return;\n","    else {\n","        freeListHelper2(lst->next);\n","        free(lst);\n","    }\n","}\n","\n","void freeList(List* lst)\n","{\n","    freeListHelper1(lst);   // free 要分成兩步驟， 先把 List 裡面記住的每筆資料清除\n","    freeListHelper2(lst);   // 再把 List 本身清除\n","}\n","\n","Node* head(List *lst)\n","{\n","    if (lst != NULL)\n","        return lst->data;\n","    else\n","        return NULL;\n","}\n","\n","List* tail(List *lst)\n","{\n","    if (lst != NULL)\n","        return lst->next;\n","    else\n","        return NULL;\n","}"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"BHeSQPTYvRO8","executionInfo":{"status":"ok","timestamp":1663590946848,"user_tz":-480,"elapsed":388,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"f151b09b-5187-4fb4-ec56-8f9060484292"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Writing E02_02.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc E02_02.c -o E02_02\n","./E02_02\n"],"metadata":{"id":"f1ClwjOzsdsQ","colab":{"base_uri":"https://localhost:8080/","height":502},"executionInfo":{"status":"error","timestamp":1663590990773,"user_tz":-480,"elapsed":38505,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"8d612c34-912d-4fb2-9c02-62b95b1dc167"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Enter a name: BB\n","[0:BB,]\n","Enter a name: EE\n","[1:EE,0:BB,]\n","Enter a name: \n","\n","\n","\n"," \n"]},{"output_type":"error","ename":"CalledProcessError","evalue":"ignored","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mCalledProcessError\u001b[0m                        Traceback (most recent call last)","\u001b[0;32m<ipython-input-3-620ee69c0c78>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mget_ipython\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_cell_magic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'shell'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m''\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'gcc E02_02.c -o E02_02\\n./E02_02\\n'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m","\u001b[0;32m/usr/local/lib/python3.7/dist-packages/IPython/core/interactiveshell.py\u001b[0m in \u001b[0;36mrun_cell_magic\u001b[0;34m(self, magic_name, line, cell)\u001b[0m\n\u001b[1;32m   2357\u001b[0m             \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuiltin_trap\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2358\u001b[0m                 \u001b[0margs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mmagic_arg_s\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcell\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2359\u001b[0;31m                 \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2360\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2361\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.7/dist-packages/google/colab/_system_commands.py\u001b[0m in \u001b[0;36m_shell_cell_magic\u001b[0;34m(args, cmd)\u001b[0m\n\u001b[1;32m    107\u001b[0m   \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_run_command\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcmd\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclear_streamed_output\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    108\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mparsed_args\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mignore_errors\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 109\u001b[0;31m     \u001b[0mresult\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcheck_returncode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    110\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    111\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.7/dist-packages/google/colab/_system_commands.py\u001b[0m in \u001b[0;36mcheck_returncode\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    133\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreturncode\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    134\u001b[0m       raise subprocess.CalledProcessError(\n\u001b[0;32m--> 135\u001b[0;31m           returncode=self.returncode, cmd=self.args, output=self.output)\n\u001b[0m\u001b[1;32m    136\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    137\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m_repr_pretty_\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcycle\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0;31m# pylint:disable=unused-argument\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;31mCalledProcessError\u001b[0m: Command 'gcc E02_02.c -o E02_02\n./E02_02\n' died with <Signals.SIGINT: 2>."]}]}]}