AE.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Artifacts Evaluation Instructions: #2405 Combining Structured Static Code Information and Dynamic Symbolic Traces for Software Vulnerability Prediction\n",
    "\n",
    "## Preliminaries\n",
    "\n",
    "This interactive Jupyter notebook provides a small-scale demo to showcase the program representation, vulnerability detection, and prediction of vulnerability detection discussed in the paper.\n",
    "\n",
    "The main results of our ICSE 2024 paper involve comparing the performance of our vulnerability detection with prior machine learning-based approaches. The evaluation presented in our paper was conducted on a much larger dataset and for a longer duration. The intention of this notebook is to provide minimal working examples that can be evaluated within a reasonable time frame.\n",
    "\n",
    "## Instructions for Experimental Workflow:\n",
    "\n",
    "Before you start, please first make a copy of the notebook by going to the landing page. Then select the checkbox next to the notebook titled *AE.ipynb*, then click \"**Duplicate**\".\n",
    "\n",
    "Click the name of the newly created Jupyter Notebook, e.g. **AE-Copy1.ipynb**. Next, select \"**Kernel**\" > \"**Restart & Clear Output**\". Then, repeatedly press the play button (the tooltip is \"run cell, select below\") to step through each cell of the notebook.\n",
    "\n",
    "Alternatively, select each cell in turn and use \"**Cell**\"> \"**Run Cell**\" from the menu to run specific cells. Note that some cells depend on previous cells being executed. If any errors occur, ensure all previous cells have been executed.\n",
    "\n",
    "## Important Notes\n",
    "\n",
    "**Some cells can take more than half an hour to complete; please wait for the results until step to the next cell.** \n",
    "\n",
    "High load can lead to a long wait for results. This may occur if multiple reviewers are simultaneously trying to generate results. \n",
    "\n",
    "The experiments are customisable as the code provided in the Jupyter Notebook can be edited on the spot. Simply type your changes into the code blocks and re-run using **Cell > Run Cells** from the menu.\n",
    "\n",
    "## Links to The Paper\n",
    "\n",
    "Preprint of the paper can be found at: https://github.com/HuantWang/HuantWang.github.io/blob/main/ICSE_24.pdf\n",
    "\n",
    "For each step, we note the section number of the submitted version where the relevant technique is described or data is presented.\n",
    "\n",
    "The main results are presented in Figures 7-9 and Tables 3-5 from Sec 5.1 to Sec 5.3 of the submitted paper."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Demo 1: The Concoction Model Architecture (Section 3)\n",
    "\n",
    "This demo corresponds to the architecture of CONCOCTION given in Figure 3. Note that This is a small-scale demo for vulnerability detection.\n",
    "\n",
    "## Step 1. Program representation\n",
    "\n",
    "The program representation component maps the input source code and dynamic symbolic execution traces of the target function into a numerical embedding vector. \n",
    "\n",
    "### *Static representation model*\n",
    "\n",
    "#### --program:\n",
    "Input a program source code that you want to convert to vectors. Candidate parameters:\n",
    "\n",
    "test_a.c, test_b.c, test_c.c. (You can also rewrite these files to define your own programs.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-01-02T15:05:51.307477300Z",
     "start_time": "2024-01-02T15:05:51.253957700Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Showing the static information:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Static information extracting...\n",
      "Showing static information of program ok_png.c-ok_png_read_data.c.txt :\n",
      "-----label-----\n",
      "1\n",
      "-----code-----\n",
      "static bool ok_png_read_data(ok_png_decoder *decoder, uint32_t bytes_remaining) {\n",
      "    ok_png *png = decoder->png;\n",
      "    size_t inflate_buffer_size = 64 * 1024;\n",
      "    size_t num_passes = decoder->interlace_method == 0 ? 1 : 7;\n",
      "    uint8_t bits_per_pixel = decoder->bit_depth * OK_PNG_SAMPLES_PER_PIXEL[decoder->color_type];\n",
      "    uint8_t bytes_per_pixel = (bits_per_pixel + 7) / 8;\n",
      "    uint64_t max_bytes_per_scanline = 1 + ((uint64_t)png->width * bits_per_pixel + 7) / 8;\n",
      "    size_t platform_max_bytes_per_scanline = (size_t)max_bytes_per_scanline;\n",
      "\n",
      "    // Create buffers\n",
      "    if (!png->data) {\n",
      "        if (decoder->allocator.image_alloc) {\n",
      "            decoder->allocator.image_alloc(decoder->allocator_user_data,\n",
      "                                           png->width, png->height, png->bpp,\n",
      "                                           &png->data, &png->stride);\n",
      "        } else {\n",
      "            uint64_t size = (uint64_t)png->stride * png->height;\n",
      "            size_t platform_size = (size_t)size;\n",
      "            if (platform_size == size) {\n",
      "                png->data = ok_alloc(decoder, platform_size);\n",
      "            }\n",
      "        }\n",
      "        if (!png->data) {\n",
      "            ok_png_error(png, OK_PNG_ERROR_ALLOCATION, \"Couldn't allocate memory for image\");\n",
      "            return false;\n",
      "        }\n",
      "        if (png->stride < png->width * png->bpp) {\n",
      "            ok_png_error(png, OK_PNG_ERROR_API, \"Invalid stride\");\n",
      "            return false;\n",
      "        }\n",
      "    }\n",
      "    if (!decoder->prev_scanline) {\n",
      "        if (max_bytes_per_scanline == platform_max_bytes_per_scanline) {\n",
      "            decoder->prev_scanline = ok_alloc(decoder, platform_max_bytes_per_scanline);\n",
      "        }\n",
      "    }\n",
      "    if (!decoder->curr_scanline) {\n",
      "        if (max_bytes_per_scanline == platform_max_bytes_per_scanline) {\n",
      "            decoder->curr_scanline = ok_alloc(decoder, platform_max_bytes_per_scanline);\n",
      "        }\n",
      "    }\n",
      "    if (!decoder->inflate_buffer) {\n",
      "        decoder->inflate_buffer = ok_alloc(decoder, inflate_buffer_size);\n",
      "    }\n",
      "    if (decoder->interlace_method == 1 && !decoder->temp_data_row) {\n",
      "        decoder->temp_data_row = ok_alloc(decoder, png->width * png->bpp);\n",
      "    }\n",
      "    if (!decoder->curr_scanline || !decoder->prev_scanline || !decoder->inflate_buffer ||\n",
      "        (decoder->interlace_method == 1 && !decoder->temp_data_row)) {\n",
      "        ok_png_error(png, OK_PNG_ERROR_ALLOCATION, \"Couldn't allocate buffers\");\n",
      "        return false;\n",
      "    }\n",
      "\n",
      "    // Setup inflater\n",
      "    if (!decoder->inflater) {\n",
      "        decoder->inflater = ok_inflater_init(decoder->is_ios_format,\n",
      "                                             decoder->allocator, decoder->allocator_user_data);\n",
      "        if (!decoder->inflater) {\n",
      "            ok_png_error(png, OK_PNG_ERROR_ALLOCATION, \"Couldn't init inflater\");\n",
      "            return false;\n",
      "        }\n",
      "    }\n",
      "\n",
      "    // Sanity check - this happened with one file in the PNG suite\n",
      "    if (decoder->decoding_completed) {\n",
      "        if (bytes_remaining > 0) {\n",
      "            return ok_seek(decoder, (long)bytes_remaining);\n",
      "        } else {\n",
      "            return true;\n",
      "        }\n",
      "    }\n",
      "\n",
      "    // Read data\n",
      "    uint32_t curr_width = ok_png_get_width_for_pass(decoder);\n",
      "    uint32_t curr_height = ok_png_get_height_for_pass(decoder);\n",
      "    size_t curr_bytes_per_scanline = (size_t)(1 + ((uint64_t)curr_width * bits_per_pixel + 7) / 8);\n",
      "    while (true) {\n",
      "        // Setup pass\n",
      "        while (decoder->ready_for_next_interlace_pass) {\n",
      "            decoder->ready_for_next_interlace_pass = false;\n",
      "            decoder->scanline = 0;\n",
      "            decoder->interlace_pass++;\n",
      "            if (decoder->interlace_pass == num_passes + 1) {\n",
      "                // Done decoding - skip any remaining chunk data\n",
      "                decoder->decoding_completed = true;\n",
      "                if (bytes_remaining > 0) {\n",
      "                    return ok_seek(decoder, (long)bytes_remaining);\n",
      "                } else {\n",
      "                    return true;\n",
      "                }\n",
      "            }\n",
      "            curr_width = ok_png_get_width_for_pass(decoder);\n",
      "            curr_height = ok_png_get_height_for_pass(decoder);\n",
      "            curr_bytes_per_scanline = (size_t)(1 + ((uint64_t)curr_width * bits_per_pixel + 7) / 8);\n",
      "            if (curr_width == 0 || curr_height == 0) {\n",
      "                // No data for this pass - happens if width or height <= 4\n",
      "                decoder->ready_for_next_interlace_pass = true;\n",
      "            } else {\n",
      "                memset(decoder->curr_scanline, 0, curr_bytes_per_scanline);\n",
      "                memset(decoder->prev_scanline, 0, curr_bytes_per_scanline);\n",
      "                decoder->inflater_bytes_read = 0;\n",
      "            }\n",
      "        }\n",
      "\n",
      "        // Read compressed data\n",
      "        if (ok_inflater_needs_input(decoder->inflater)) {\n",
      "            if (bytes_remaining == 0) {\n",
      "                // Need more data, but there is no remaining data in this chunk.\n",
      "                // There may be another IDAT chunk.\n",
      "                return true;\n",
      "            }\n",
      "            const size_t len = min(inflate_buffer_size, bytes_remaining);\n",
      "            if (!ok_read(decoder, decoder->inflate_buffer, len)) {\n",
      "                return false;\n",
      "            }\n",
      "            bytes_remaining -= len;\n",
      "            ok_inflater_set_input(decoder->inflater, decoder->inflate_buffer, len);\n",
      "        }\n",
      "\n",
      "        // Decompress data\n",
      "        size_t len = ok_inflater_inflate(decoder->inflater,\n",
      "                                         decoder->curr_scanline + decoder->inflater_bytes_read,\n",
      "                                         curr_bytes_per_scanline - decoder->inflater_bytes_read);\n",
      "        if (len == OK_SIZE_MAX) {\n",
      "            ok_png_error(png, OK_PNG_ERROR_INFLATER, \"Inflater error\");\n",
      "            return false;\n",
      "        }\n",
      "        decoder->inflater_bytes_read += len;\n",
      "        if (decoder->inflater_bytes_read == curr_bytes_per_scanline) {\n",
      "            // Apply filter\n",
      "            const int filter = decoder->curr_scanline[0];\n",
      "            if (filter > 0 && filter < OK_PNG_NUM_FILTERS) {\n",
      "                ok_png_decode_filter(decoder->curr_scanline + 1, decoder->prev_scanline + 1,\n",
      "                                     curr_bytes_per_scanline - 1, filter, bytes_per_pixel);\n",
      "            } else if (filter != 0) {\n",
      "                ok_png_error(png, OK_PNG_ERROR_INVALID, \"Invalid filter type\");\n",
      "                return false;\n",
      "            }\n",
      "\n",
      "            // Transform\n",
      "            ok_png_transform_scanline(decoder, decoder->curr_scanline + 1, curr_width);\n",
      "\n",
      "            // Setup for next scanline or pass\n",
      "            decoder->scanline++;\n",
      "            if (decoder->scanline == curr_height) {\n",
      "                decoder->ready_for_next_interlace_pass = true;\n",
      "            } else {\n",
      "                uint8_t *temp = decoder->curr_scanline;\n",
      "                decoder->curr_scanline = decoder->prev_scanline;\n",
      "                decoder->prev_scanline = temp;\n",
      "                decoder->inflater_bytes_read = 0;\n",
      "            }\n",
      "        }\n",
      "    }\n",
      "}\n",
      "-----children-----\n",
      "1,2\n",
      "1,3\n",
      "1,4\n",
      "3,4\n",
      "3,5\n",
      "3,6\n",
      "5,6\n",
      "5,7\n",
      "6,7\n",
      "8,9\n",
      "8,10\n",
      "11,12\n",
      "11,13\n",
      "12,13\n",
      "14,15\n",
      "16,17\n",
      "16,18\n",
      "16,19\n",
      "16,20\n",
      "16,21\n",
      "16,22\n",
      "16,23\n",
      "16,24\n",
      "16,25\n",
      "16,26\n",
      "16,27\n",
      "16,28\n",
      "16,29\n",
      "16,30\n",
      "16,31\n",
      "16,32\n",
      "16,33\n",
      "16,34\n",
      "16,35\n",
      "17,18\n",
      "18,19\n",
      "18,20\n",
      "19,20\n",
      "21,22\n",
      "21,23\n",
      "21,24\n",
      "24,25\n",
      "25,26\n",
      "25,27\n",
      "26,27\n",
      "29,30\n",
      "30,31\n",
      "30,32\n",
      "31,32\n",
      "33,34\n",
      "33,35\n",
      "35,36\n",
      "36,37\n",
      "36,38\n",
      "39,40\n",
      "40,41\n",
      "40,42\n",
      "41,42\n",
      "43,44\n",
      "43,45\n",
      "45,46\n",
      "46,47\n",
      "46,48\n",
      "46,49\n",
      "47,48\n",
      "47,49\n",
      "48,49\n",
      "48,50\n",
      "49,50\n",
      "55,56\n",
      "56,57\n",
      "56,58\n",
      "57,58\n",
      "59,60\n",
      "59,61\n",
      "61,62\n",
      "62,63\n",
      "62,64\n",
      "63,64\n",
      "63,65\n",
      "64,65\n",
      "67,68\n",
      "67,69\n",
      "68,69\n",
      "70,71\n",
      "70,72\n",
      "71,72\n",
      "74,75\n",
      "75,76\n",
      "75,77\n",
      "76,77\n",
      "78,79\n",
      "78,80\n",
      "80,81\n",
      "81,82\n",
      "81,83\n",
      "82,83\n",
      "83,84\n",
      "83,85\n",
      "84,85\n",
      "88,89\n",
      "89,90\n",
      "89,91\n",
      "90,91\n",
      "92,93\n",
      "92,94\n",
      "94,95\n",
      "95,96\n",
      "95,97\n",
      "97,98\n",
      "97,99\n",
      "98,99\n",
      "99,100\n",
      "99,101\n",
      "100,101\n",
      "100,102\n",
      "101,102\n",
      "101,103\n",
      "102,103\n",
      "102,104\n",
      "103,104\n",
      "106,107\n",
      "106,108\n",
      "107,108\n",
      "110,111\n",
      "114,115\n",
      "115,116\n",
      "115,117\n",
      "116,117\n",
      "118,119\n",
      "118,120\n",
      "120,121\n",
      "121,122\n",
      "121,123\n",
      "122,123\n",
      "122,124\n",
      "123,124\n",
      "126,127\n",
      "128,129\n",
      "128,130\n",
      "129,130\n",
      "130,131\n",
      "130,132\n",
      "131,132\n",
      "134,135\n",
      "134,136\n",
      "134,137\n",
      "135,136\n",
      "135,137\n",
      "135,138\n",
      "136,137\n",
      "136,138\n",
      "137,138\n",
      "137,139\n",
      "138,139\n",
      "142,143\n",
      "143,144\n",
      "144,145\n",
      "144,146\n",
      "144,147\n",
      "144,148\n",
      "144,149\n",
      "144,150\n",
      "144,151\n",
      "145,146\n",
      "145,147\n",
      "146,147\n",
      "146,148\n",
      "147,148\n",
      "151,152\n",
      "151,153\n",
      "152,153\n",
      "155,156\n",
      "155,157\n",
      "156,157\n",
      "159,160\n",
      "159,161\n",
      "160,161\n",
      "163,164\n",
      "163,165\n",
      "164,165\n",
      "167,168\n",
      "168,169\n",
      "168,170\n",
      "169,170\n",
      "172,173\n",
      "173,174\n",
      "173,175\n",
      "174,175\n",
      "177,178\n",
      "177,179\n",
      "177,180\n",
      "178,179\n",
      "179,180\n",
      "179,181\n",
      "180,181\n",
      "182,183\n",
      "182,184\n",
      "184,185\n",
      "185,186\n",
      "185,187\n",
      "186,187\n",
      "186,188\n",
      "187,188\n",
      "187,189\n",
      "188,189\n",
      "191,192\n",
      "191,193\n",
      "192,193\n",
      "195,196\n",
      "195,197\n",
      "196,197\n",
      "199,200\n",
      "200,201\n",
      "200,202\n",
      "201,202\n",
      "203,204\n",
      "203,205\n",
      "205,206\n",
      "206,207\n",
      "206,208\n",
      "207,208\n",
      "207,209\n",
      "208,209\n",
      "211,212\n",
      "213,214\n",
      "213,215\n",
      "214,215\n",
      "214,216\n",
      "215,216\n",
      "217,218\n",
      "219,220\n",
      "220,221\n",
      "221,222\n",
      "221,223\n",
      "222,223\n",
      "222,224\n",
      "223,224\n",
      "226,227\n",
      "226,228\n",
      "226,229\n",
      "227,228\n",
      "229,230\n",
      "231,232\n",
      "233,234\n",
      "233,235\n",
      "234,235\n",
      "235,236\n",
      "235,237\n",
      "236,237\n",
      "239,240\n",
      "239,241\n",
      "240,241\n",
      "241,242\n",
      "241,243\n",
      "241,244\n",
      "241,245\n",
      "242,243\n",
      "244,245\n",
      "246,247\n",
      "249,250\n",
      "251,252\n",
      "251,253\n",
      "252,253\n",
      "252,254\n",
      "253,254\n",
      "253,255\n",
      "254,255\n",
      "257,258\n",
      "257,259\n",
      "258,259\n",
      "258,260\n",
      "259,260\n",
      "262,263\n",
      "262,264\n",
      "263,264\n",
      "266,267\n",
      "266,268\n",
      "267,268\n",
      "268,269\n",
      "268,270\n",
      "268,271\n",
      "268,272\n",
      "269,270\n",
      "271,272\n",
      "273,274\n",
      "276,277\n",
      "278,279\n",
      "278,280\n",
      "279,280\n",
      "280,281\n",
      "280,282\n",
      "281,282\n",
      "284,285\n",
      "285,286\n",
      "285,287\n",
      "286,287\n",
      "286,288\n",
      "287,288\n",
      "289,290\n",
      "291,292\n",
      "292,293\n",
      "293,294\n",
      "293,295\n",
      "294,295\n",
      "294,296\n",
      "295,296\n",
      "298,299\n",
      "298,300\n",
      "298,301\n",
      "299,300\n",
      "301,302\n",
      "303,304\n",
      "305,306\n",
      "305,307\n",
      "306,307\n",
      "307,308\n",
      "307,309\n",
      "308,309\n",
      "311,312\n",
      "312,313\n",
      "312,314\n",
      "313,314\n",
      "313,315\n",
      "314,315\n",
      "316,317\n",
      "318,319\n",
      "319,320\n",
      "320,321\n",
      "320,322\n",
      "321,322\n",
      "321,323\n",
      "322,323\n",
      "325,326\n",
      "325,327\n",
      "325,328\n",
      "326,327\n",
      "328,329\n",
      "330,331\n",
      "332,333\n",
      "332,334\n",
      "333,334\n",
      "334,335\n",
      "334,336\n",
      "335,336\n",
      "338,339\n",
      "339,340\n",
      "340,341\n",
      "340,342\n",
      "341,342\n",
      "341,343\n",
      "342,343\n",
      "345,346\n",
      "345,347\n",
      "345,348\n",
      "346,347\n",
      "348,349\n",
      "350,351\n",
      "352,353\n",
      "352,354\n",
      "353,354\n",
      "353,355\n",
      "354,355\n",
      "354,356\n",
      "355,356\n",
      "355,357\n",
      "356,357\n",
      "360,361\n",
      "361,362\n",
      "361,363\n",
      "362,363\n",
      "365,366\n",
      "366,367\n",
      "367,368\n",
      "367,369\n",
      "368,369\n",
      "368,370\n",
      "369,370\n",
      "372,373\n",
      "372,374\n",
      "372,375\n",
      "373,374\n",
      "375,376\n",
      "377,378\n",
      "377,379\n",
      "378,379\n",
      "378,380\n",
      "379,380\n",
      "382,383\n",
      "382,384\n",
      "383,384\n",
      "386,387\n",
      "386,388\n",
      "387,388\n",
      "387,389\n",
      "388,389\n",
      "388,390\n",
      "389,390\n",
      "389,391\n",
      "390,391\n",
      "391,392\n",
      "391,393\n",
      "392,393\n",
      "395,396\n",
      "396,397\n",
      "396,398\n",
      "397,398\n",
      "400,401\n",
      "401,402\n",
      "401,403\n",
      "402,403\n",
      "405,406\n",
      "406,407\n",
      "406,408\n",
      "407,408\n",
      "407,409\n",
      "408,409\n",
      "408,410\n",
      "409,410\n",
      "413,414\n",
      "414,415\n",
      "414,416\n",
      "415,416\n",
      "418,419\n",
      "418,420\n",
      "419,420\n",
      "420,421\n",
      "420,422\n",
      "420,423\n",
      "420,424\n",
      "421,422\n",
      "423,424\n",
      "425,426\n",
      "428,429\n",
      "430,431\n",
      "430,432\n",
      "431,432\n",
      "432,433\n",
      "432,434\n",
      "433,434\n",
      "436,437\n",
      "436,438\n",
      "437,438\n",
      "438,439\n",
      "438,440\n",
      "439,440\n",
      "439,441\n",
      "440,441\n",
      "443,444\n",
      "443,445\n",
      "443,446\n",
      "443,447\n",
      "444,445\n",
      "446,447\n",
      "446,448\n",
      "447,448\n",
      "450,451\n",
      "450,452\n",
      "451,452\n",
      "454,455\n",
      "454,456\n",
      "455,456\n",
      "458,459\n",
      "458,460\n",
      "459,460\n",
      "460,461\n",
      "460,462\n",
      "461,462\n",
      "464,465\n",
      "464,466\n",
      "465,466\n",
      "466,467\n",
      "466,468\n",
      "466,469\n",
      "466,470\n",
      "467,468\n",
      "469,470\n",
      "471,472\n",
      "474,475\n",
      "476,477\n",
      "476,478\n",
      "477,478\n",
      "477,479\n",
      "478,479\n",
      "481,482\n",
      "482,483\n",
      "482,484\n",
      "482,485\n",
      "483,484\n",
      "483,485\n",
      "484,485\n",
      "487,488\n",
      "488,489\n",
      "489,490\n",
      "489,491\n",
      "489,492\n",
      "490,491\n",
      "492,493\n",
      "494,495\n",
      "494,496\n",
      "495,496\n",
      "495,497\n",
      "498,499\n",
      "500,501\n",
      "501,502\n",
      "503,504\n",
      "504,505\n",
      "504,506\n",
      "505,506\n",
      "507,508\n",
      "507,509\n",
      "509,510\n",
      "510,511\n",
      "510,512\n",
      "511,512\n",
      "513,514\n",
      "515,516\n",
      "516,517\n",
      "516,518\n",
      "517,518\n",
      "519,520\n",
      "519,521\n",
      "521,522\n",
      "522,523\n",
      "522,524\n",
      "523,524\n",
      "525,526\n",
      "527,528\n",
      "528,529\n",
      "528,530\n",
      "529,530\n",
      "531,532\n",
      "531,533\n",
      "533,534\n",
      "534,535\n",
      "534,536\n",
      "535,536\n",
      "536,537\n",
      "538,539\n",
      "538,540\n",
      "540,541\n",
      "540,542\n",
      "541,542\n",
      "542,543\n",
      "542,544\n",
      "543,544\n",
      "543,545\n",
      "544,545\n",
      "544,546\n",
      "545,546\n",
      "545,547\n",
      "546,547\n",
      "549,550\n",
      "551,552\n",
      "555,556\n",
      "555,557\n",
      "557,558\n",
      "557,559\n",
      "557,560\n",
      "557,561\n",
      "557,562\n",
      "557,563\n",
      "558,559\n",
      "558,560\n",
      "559,560\n",
      "559,561\n",
      "560,561\n",
      "563,564\n",
      "563,565\n",
      "563,566\n",
      "563,567\n",
      "563,568\n",
      "563,569\n",
      "563,570\n",
      "563,571\n",
      "564,565\n",
      "565,566\n",
      "565,567\n",
      "566,567\n",
      "566,568\n",
      "567,568\n",
      "571,572\n",
      "572,573\n",
      "572,574\n",
      "573,574\n",
      "573,575\n",
      "574,575\n",
      "578,579\n",
      "579,580\n",
      "580,581\n",
      "580,582\n",
      "581,582\n",
      "584,585\n",
      "584,586\n",
      "585,586\n",
      "585,587\n",
      "586,587\n",
      "586,588\n",
      "587,588\n",
      "590,591\n",
      "590,592\n",
      "591,592\n",
      "594,595\n",
      "594,596\n",
      "595,596\n",
      "596,597\n",
      "596,598\n",
      "597,598\n",
      "597,599\n",
      "598,599\n",
      "602,603\n",
      "602,604\n",
      "602,605\n",
      "603,604\n",
      "603,605\n",
      "604,605\n",
      "607,608\n",
      "608,609\n",
      "609,610\n",
      "609,611\n",
      "609,612\n",
      "610,611\n",
      "612,613\n",
      "614,615\n",
      "614,616\n",
      "615,616\n",
      "615,617\n",
      "618,619\n",
      "620,621\n",
      "621,622\n",
      "623,624\n",
      "624,625\n",
      "624,626\n",
      "625,626\n",
      "627,628\n",
      "627,629\n",
      "628,629\n",
      "630,631\n",
      "632,633\n",
      "633,634\n",
      "633,635\n",
      "634,635\n",
      "636,637\n",
      "636,638\n",
      "637,638\n",
      "639,640\n",
      "641,642\n",
      "642,643\n",
      "642,644\n",
      "643,644\n",
      "645,646\n",
      "645,647\n",
      "646,647\n",
      "647,648\n",
      "649,650\n",
      "649,651\n",
      "651,652\n",
      "651,653\n",
      "652,653\n",
      "653,654\n",
      "653,655\n",
      "654,655\n",
      "654,656\n",
      "655,656\n",
      "655,657\n",
      "656,657\n",
      "656,658\n",
      "657,658\n",
      "660,661\n",
      "662,663\n",
      "666,667\n",
      "666,668\n",
      "666,669\n",
      "667,668\n",
      "667,669\n",
      "668,669\n",
      "668,670\n",
      "669,670\n",
      "672,673\n",
      "672,674\n",
      "673,674\n",
      "676,677\n",
      "677,678\n",
      "678,679\n",
      "678,680\n",
      "679,680\n",
      "679,681\n",
      "680,681\n",
      "684,685\n",
      "684,686\n",
      "684,687\n",
      "685,686\n",
      "686,687\n",
      "686,688\n",
      "686,689\n",
      "686,690\n",
      "687,688\n",
      "689,690\n",
      "689,691\n",
      "690,691\n",
      "694,695\n",
      "696,697\n",
      "697,698\n",
      "697,699\n",
      "697,700\n",
      "697,701\n",
      "698,699\n",
      "700,701\n",
      "700,702\n",
      "701,702\n",
      "705,706\n",
      "707,708\n",
      "708,709\n",
      "708,710\n",
      "709,710\n",
      "709,711\n",
      "710,711\n",
      "714,715\n",
      "714,716\n",
      "715,716\n",
      "715,717\n",
      "716,717\n",
      "718,719\n",
      "718,720\n",
      "719,720\n",
      "722,723\n",
      "722,724\n",
      "722,725\n",
      "722,726\n",
      "722,727\n",
      "723,724\n",
      "723,725\n",
      "724,725\n",
      "724,726\n",
      "725,726\n",
      "728,729\n",
      "729,730\n",
      "731,732\n",
      "732,733\n",
      "732,734\n",
      "733,734\n",
      "735,736\n",
      "735,737\n",
      "737,738\n",
      "738,739\n",
      "738,740\n",
      "738,741\n",
      "739,740\n",
      "741,742\n",
      "743,744\n",
      "745,746\n",
      "745,747\n",
      "746,747\n",
      "747,748\n",
      "747,749\n",
      "747,750\n",
      "747,751\n",
      "748,749\n",
      "750,751\n",
      "752,753\n",
      "752,754\n",
      "753,754\n",
      "756,757\n",
      "758,759\n",
      "759,760\n",
      "761,762\n",
      "762,763\n",
      "762,764\n",
      "763,764\n",
      "765,766\n",
      "767,768\n",
      "768,769\n",
      "768,770\n",
      "768,771\n",
      "768,772\n",
      "769,770\n",
      "771,772\n",
      "771,773\n",
      "772,773\n",
      "775,776\n",
      "775,777\n",
      "776,777\n",
      "779,780\n",
      "781,782\n",
      "782,783\n",
      "782,784\n",
      "783,784\n",
      "785,786\n",
      "785,787\n",
      "787,788\n",
      "788,789\n",
      "788,790\n",
      "788,791\n",
      "788,792\n",
      "789,790\n",
      "791,792\n",
      "791,793\n",
      "792,793\n",
      "795,796\n",
      "795,797\n",
      "796,797\n",
      "796,798\n",
      "797,798\n",
      "800,801\n",
      "800,802\n",
      "801,802\n",
      "804,805\n",
      "804,806\n",
      "805,806\n",
      "807,808\n",
      "807,809\n",
      "808,809\n",
      "811,812\n",
      "811,813\n",
      "812,813\n",
      "812,814\n",
      "813,814\n",
      "815,816\n",
      "817,818\n",
      "817,819\n",
      "818,819\n",
      "819,820\n",
      "819,821\n",
      "819,822\n",
      "819,823\n",
      "820,821\n",
      "822,823\n",
      "824,825\n",
      "827,828\n",
      "829,830\n",
      "830,831\n",
      "830,832\n",
      "831,832\n",
      "831,833\n",
      "832,833\n",
      "835,836\n",
      "837,838\n",
      "837,839\n",
      "838,839\n",
      "838,840\n",
      "839,840\n",
      "839,841\n",
      "840,841\n",
      "843,844\n",
      "845,846\n",
      "845,847\n",
      "845,848\n",
      "845,849\n",
      "845,850\n",
      "846,847\n",
      "847,848\n",
      "847,849\n",
      "849,850\n",
      "849,851\n",
      "851,852\n",
      "852,853\n",
      "852,854\n",
      "853,854\n",
      "853,855\n",
      "854,855\n",
      "858,859\n",
      "858,860\n",
      "858,861\n",
      "859,860\n",
      "859,861\n",
      "860,861\n",
      "860,862\n",
      "861,862\n",
      "864,865\n",
      "864,866\n",
      "865,866\n",
      "867,868\n",
      "869,870\n",
      "870,871\n",
      "871,872\n",
      "871,873\n",
      "871,874\n",
      "871,875\n",
      "871,876\n",
      "871,877\n",
      "872,873\n",
      "874,875\n",
      "874,876\n",
      "875,876\n",
      "875,877\n",
      "876,877\n",
      "880,881\n",
      "880,882\n",
      "881,882\n",
      "881,883\n",
      "882,883\n",
      "886,887\n",
      "886,888\n",
      "887,888\n",
      "890,891\n",
      "892,893\n",
      "894,895\n",
      "894,896\n",
      "895,896\n",
      "895,897\n",
      "896,897\n",
      "899,900\n",
      "899,901\n",
      "900,901\n",
      "901,902\n",
      "901,903\n",
      "901,904\n",
      "901,905\n",
      "902,903\n",
      "904,905\n",
      "906,907\n",
      "909,910\n",
      "911,912\n",
      "912,913\n",
      "912,914\n",
      "912,915\n",
      "912,916\n",
      "913,914\n",
      "915,916\n",
      "917,918\n",
      "917,919\n",
      "918,919\n",
      "918,920\n",
      "919,920\n",
      "923,924\n",
      "925,926\n",
      "926,927\n",
      "927,928\n",
      "927,929\n",
      "928,929\n",
      "931,932\n",
      "931,933\n",
      "931,934\n",
      "932,933\n",
      "932,934\n",
      "933,934\n",
      "933,935\n",
      "934,935\n",
      "937,938\n",
      "939,940\n",
      "940,941\n",
      "941,942\n",
      "941,943\n",
      "942,943\n",
      "942,944\n",
      "943,944\n",
      "947,948\n",
      "947,949\n",
      "947,950\n",
      "947,951\n",
      "948,949\n",
      "949,950\n",
      "949,951\n",
      "950,951\n",
      "952,953\n",
      "952,954\n",
      "952,955\n",
      "955,956\n",
      "956,957\n",
      "956,958\n",
      "957,958\n",
      "960,961\n",
      "961,962\n",
      "961,963\n",
      "962,963\n",
      "962,964\n",
      "963,964\n",
      "966,967\n",
      "966,968\n",
      "967,968\n",
      "970,971\n",
      "971,972\n",
      "971,973\n",
      "972,973\n",
      "972,974\n",
      "973,974\n",
      "976,977\n",
      "978,979\n",
      "979,980\n",
      "979,981\n",
      "980,981\n",
      "980,982\n",
      "981,982\n",
      "-----nextToken-----\n",
      "2,4,7,9,10,13,15,20,22,23,27,28,32,34,37,38,42,44,50,51,52,53,54,58,60,65,66,69,72,73,77,79,85,86,87,91,93,96,104,105,108,109,111,112,113,117,119,124,125,127,132,133,139,140,141,148,149,150,153,154,157,158,161,162,165,166,170,171,175,176,181,183,189,190,193,194,197,198,202,204,209,210,212,216,218,224,225,228,230,232,237,238,243,245,247,248,250,255,256,260,261,264,265,270,272,274,275,277,282,283,288,290,296,297,300,302,304,309,310,315,317,323,324,327,329,331,336,337,343,344,347,349,351,357,358,359,363,364,370,371,374,376,380,381,384,385,393,394,398,399,403,404,410,411,412,416,417,422,424,426,427,429,434,435,441,442,445,448,449,452,453,456,457,462,463,468,470,472,473,475,479,480,485,486,491,493,496,497,499,502,506,508,512,514,518,520,524,526,530,532,537,539,547,548,550,552,553,554,556,561,562,568,569,570,575,576,577,582,583,588,589,592,593,599,600,601,605,606,611,613,616,617,619,622,626,629,631,635,638,640,644,648,650,658,659,661,663,664,665,670,671,674,675,681,682,683,688,691,692,693,695,699,702,703,704,706,711,712,713,717,720,721,726,727,730,734,736,740,742,744,749,751,754,755,757,760,764,766,770,773,774,777,778,780,784,786,790,793,794,798,799,802,803,806,809,810,814,816,821,823,825,826,828,833,834,836,841,842,844,848,850,855,856,857,862,863,866,868,873,877,878,879,883,884,885,888,889,891,893,897,898,903,905,907,908,910,914,916,920,921,922,924,929,930,935,936,938,944,945,946,951,953,954,958,959,964,965,968,969,974,975,977,982,983,984\n",
      "-----computeFrom-----\n",
      "36,37\n",
      "36,38\n",
      "47,48\n",
      "47,49\n",
      "62,63\n",
      "62,64\n",
      "81,82\n",
      "81,83\n",
      "83,84\n",
      "83,85\n",
      "95,96\n",
      "95,97\n",
      "97,98\n",
      "97,99\n",
      "99,100\n",
      "99,101\n",
      "100,101\n",
      "100,102\n",
      "185,186\n",
      "185,187\n",
      "214,215\n",
      "214,216\n",
      "221,222\n",
      "221,223\n",
      "252,253\n",
      "252,254\n",
      "257,258\n",
      "257,259\n",
      "286,287\n",
      "286,288\n",
      "293,294\n",
      "293,295\n",
      "313,314\n",
      "313,315\n",
      "320,321\n",
      "320,322\n",
      "340,341\n",
      "340,342\n",
      "353,354\n",
      "353,355\n",
      "354,355\n",
      "354,356\n",
      "367,368\n",
      "367,369\n",
      "377,378\n",
      "377,379\n",
      "387,388\n",
      "387,389\n",
      "388,389\n",
      "388,390\n",
      "389,390\n",
      "389,391\n",
      "406,407\n",
      "406,408\n",
      "407,408\n",
      "407,409\n",
      "438,439\n",
      "438,440\n",
      "483,484\n",
      "483,485\n",
      "538,539\n",
      "538,540\n",
      "540,541\n",
      "540,542\n",
      "542,543\n",
      "542,544\n",
      "543,544\n",
      "543,545\n",
      "565,566\n",
      "565,567\n",
      "572,573\n",
      "572,574\n",
      "585,586\n",
      "585,587\n",
      "590,591\n",
      "590,592\n",
      "596,597\n",
      "596,598\n",
      "603,604\n",
      "603,605\n",
      "624,625\n",
      "624,626\n",
      "633,634\n",
      "633,635\n",
      "642,643\n",
      "642,644\n",
      "649,650\n",
      "649,651\n",
      "651,652\n",
      "651,653\n",
      "653,654\n",
      "653,655\n",
      "654,655\n",
      "654,656\n",
      "667,668\n",
      "667,669\n",
      "668,669\n",
      "668,670\n",
      "672,673\n",
      "672,674\n",
      "678,679\n",
      "678,680\n",
      "708,709\n",
      "708,710\n",
      "724,725\n",
      "724,726\n",
      "762,763\n",
      "762,764\n",
      "795,796\n",
      "795,797\n",
      "804,805\n",
      "804,806\n",
      "812,813\n",
      "812,814\n",
      "830,831\n",
      "830,832\n",
      "838,839\n",
      "838,840\n",
      "859,860\n",
      "859,861\n",
      "860,861\n",
      "860,862\n",
      "864,865\n",
      "864,866\n",
      "874,875\n",
      "874,876\n",
      "880,881\n",
      "880,882\n",
      "886,887\n",
      "886,888\n",
      "895,896\n",
      "895,897\n",
      "917,918\n",
      "917,919\n",
      "932,933\n",
      "932,934\n",
      "941,942\n",
      "941,943\n",
      "961,962\n",
      "961,963\n",
      "971,972\n",
      "971,973\n",
      "979,980\n",
      "979,981\n",
      "-----guardedBy-----\n",
      "216,232\n",
      "264,272\n",
      "290,304\n",
      "317,331\n",
      "364,371\n",
      "363,376\n",
      "485,499\n",
      "588,613\n",
      "605,619\n",
      "844,888\n",
      "842,983\n",
      "841,982\n",
      "866,891\n",
      "935,944\n",
      "-----guardedByNegation-----\n",
      "866,897\n",
      "935,982\n",
      "-----lastLexicalUse-----\n",
      "866,897\n",
      "935,982\n",
      "-----jump-----\n",
      "866,897\n",
      "935,982\n",
      "-----attribute-----\n",
      "FunctionDefinition;SimpleDeclSpecifier;FunctionDeclarator;Name;ParameterDeclaration;NamedTypeSpecifier;Name;Declarator;Pointer;Name;ParameterDeclaration;NamedTypeSpecifier;Name;Declarator;Name;CompoundStatement;DeclarationStatement;SimpleDeclaration;NamedTypeSpecifier;Name;Declarator;Pointer;Name;EqualsInitializer;FieldReference;IdExpression;Name;Name;DeclarationStatement;SimpleDeclaration;NamedTypeSpecifier;Name;Declarator;Name;EqualsInitializer;BinaryExpression;LiteralExpression;LiteralExpression;DeclarationStatement;SimpleDeclaration;NamedTypeSpecifier;Name;Declarator;Name;EqualsInitializer;ConditionalExpression;BinaryExpression;FieldReference;IdExpression;Name;Name;LiteralExpression;LiteralExpression;LiteralExpression;DeclarationStatement;SimpleDeclaration;NamedTypeSpecifier;Name;Declarator;Name;EqualsInitializer;BinaryExpression;FieldReference;IdExpression;Name;Name;ArraySubscriptExpression;IdExpression;Name;FieldReference;IdExpression;Name;Name;DeclarationStatement;SimpleDeclaration;NamedTypeSpecifier;Name;Declarator;Name;EqualsInitializer;BinaryExpression;UnaryExpression;BinaryExpression;IdExpression;Name;LiteralExpression;LiteralExpression;DeclarationStatement;SimpleDeclaration;NamedTypeSpecifier;Name;Declarator;Name;EqualsInitializer;BinaryExpression;LiteralExpression;BinaryExpression;UnaryExpression;BinaryExpression;BinaryExpression;CastExpression;TypeId;NamedTypeSpecifier;Name;Declarator;FieldReference;IdExpression;Name;Name;IdExpression;Name;LiteralExpression;LiteralExpression;DeclarationStatement;SimpleDeclaration;NamedTypeSpecifier;Name;Declarator;Name;EqualsInitializer;CastExpression;TypeId;NamedTypeSpecifier;Name;Declarator;IdExpression;Name;IfStatement;UnaryExpression;FieldReference;IdExpression;Name;Name;CompoundStatement;IfStatement;FieldReference;FieldReference;IdExpression;Name;Name;Name;CompoundStatement;ExpressionStatement;FunctionCallExpression;FieldReference;FieldReference;IdExpression;Name;Name;Name;FieldReference;IdExpression;Name;Name;FieldReference;IdExpression;Name;Name;FieldReference;IdExpression;Name;Name;FieldReference;IdExpression;Name;Name;UnaryExpression;FieldReference;IdExpression;Name;Name;UnaryExpression;FieldReference;IdExpression;Name;Name;CompoundStatement;DeclarationStatement;SimpleDeclaration;NamedTypeSpecifier;Name;Declarator;Name;EqualsInitializer;BinaryExpression;CastExpression;TypeId;NamedTypeSpecifier;Name;Declarator;FieldReference;IdExpression;Name;Name;FieldReference;IdExpression;Name;Name;DeclarationStatement;SimpleDeclaration;NamedTypeSpecifier;Name;Declarator;Name;EqualsInitializer;CastExpression;TypeId;NamedTypeSpecifier;Name;Declarator;IdExpression;Name;IfStatement;BinaryExpression;IdExpression;Name;IdExpression;Name;CompoundStatement;ExpressionStatement;BinaryExpression;FieldReference;IdExpression;Name;Name;FunctionCallExpression;IdExpression;Name;IdExpression;Name;IdExpression;Name;IfStatement;UnaryExpression;FieldReference;IdExpression;Name;Name;CompoundStatement;ExpressionStatement;FunctionCallExpression;IdExpression;Name;IdExpression;Name;IdExpression;Name;LiteralExpression;ReturnStatement;LiteralExpression;IfStatement;BinaryExpression;FieldReference;IdExpression;Name;Name;BinaryExpression;FieldReference;IdExpression;Name;Name;FieldReference;IdExpression;Name;Name;CompoundStatement;ExpressionStatement;FunctionCallExpression;IdExpression;Name;IdExpression;Name;IdExpression;Name;LiteralExpression;ReturnStatement;LiteralExpression;IfStatement;UnaryExpression;FieldReference;IdExpression;Name;Name;CompoundStatement;IfStatement;BinaryExpression;IdExpression;Name;IdExpression;Name;CompoundStatement;ExpressionStatement;BinaryExpression;FieldReference;IdExpression;Name;Name;FunctionCallExpression;IdExpression;Name;IdExpression;Name;IdExpression;Name;IfStatement;UnaryExpression;FieldReference;IdExpression;Name;Name;CompoundStatement;IfStatement;BinaryExpression;IdExpression;Name;IdExpression;Name;CompoundStatement;ExpressionStatement;BinaryExpression;FieldReference;IdExpression;Name;Name;FunctionCallExpression;IdExpression;Name;IdExpression;Name;IdExpression;Name;IfStatement;UnaryExpression;FieldReference;IdExpression;Name;Name;CompoundStatement;ExpressionStatement;BinaryExpression;FieldReference;IdExpression;Name;Name;FunctionCallExpression;IdExpression;Name;IdExpression;Name;IdExpression;Name;IfStatement;BinaryExpression;BinaryExpression;FieldReference;IdExpression;Name;Name;LiteralExpression;UnaryExpression;FieldReference;IdExpression;Name;Name;CompoundStatement;ExpressionStatement;BinaryExpression;FieldReference;IdExpression;Name;Name;FunctionCallExpression;IdExpression;Name;IdExpression;Name;BinaryExpression;FieldReference;IdExpression;Name;Name;FieldReference;IdExpression;Name;Name;IfStatement;BinaryExpression;BinaryExpression;BinaryExpression;UnaryExpression;FieldReference;IdExpression;Name;Name;UnaryExpression;FieldReference;IdExpression;Name;Name;UnaryExpression;FieldReference;IdExpression;Name;Name;UnaryExpression;BinaryExpression;BinaryExpression;FieldReference;IdExpression;Name;Name;LiteralExpression;UnaryExpression;FieldReference;IdExpression;Name;Name;CompoundStatement;ExpressionStatement;FunctionCallExpression;IdExpression;Name;IdExpression;Name;IdExpression;Name;LiteralExpression;ReturnStatement;LiteralExpression;IfStatement;UnaryExpression;FieldReference;IdExpression;Name;Name;CompoundStatement;ExpressionStatement;BinaryExpression;FieldReference;IdExpression;Name;Name;FunctionCallExpression;IdExpression;Name;FieldReference;IdExpression;Name;Name;FieldReference;IdExpression;Name;Name;FieldReference;IdExpression;Name;Name;IfStatement;UnaryExpression;FieldReference;IdExpression;Name;Name;CompoundStatement;ExpressionStatement;FunctionCallExpression;IdExpression;Name;IdExpression;Name;IdExpression;Name;LiteralExpression;ReturnStatement;LiteralExpression;IfStatement;FieldReference;IdExpression;Name;Name;CompoundStatement;IfStatement;BinaryExpression;IdExpression;Name;LiteralExpression;CompoundStatement;ReturnStatement;FunctionCallExpression;IdExpression;Name;IdExpression;Name;CastExpression;TypeId;SimpleDeclSpecifier;Declarator;IdExpression;Name;CompoundStatement;ReturnStatement;LiteralExpression;DeclarationStatement;SimpleDeclaration;NamedTypeSpecifier;Name;Declarator;Name;EqualsInitializer;FunctionCallExpression;IdExpression;Name;IdExpression;Name;DeclarationStatement;SimpleDeclaration;NamedTypeSpecifier;Name;Declarator;Name;EqualsInitializer;FunctionCallExpression;IdExpression;Name;IdExpression;Name;DeclarationStatement;SimpleDeclaration;NamedTypeSpecifier;Name;Declarator;Name;EqualsInitializer;FunctionCallExpression;UnaryExpression;IdExpression;Name;BinaryExpression;LiteralExpression;BinaryExpression;UnaryExpression;BinaryExpression;BinaryExpression;CastExpression;TypeId;NamedTypeSpecifier;Name;Declarator;IdExpression;Name;IdExpression;Name;LiteralExpression;LiteralExpression;WhileStatement;LiteralExpression;CompoundStatement;WhileStatement;FieldReference;IdExpression;Name;Name;CompoundStatement;ExpressionStatement;BinaryExpression;FieldReference;IdExpression;Name;Name;LiteralExpression;ExpressionStatement;BinaryExpression;FieldReference;IdExpression;Name;Name;LiteralExpression;ExpressionStatement;UnaryExpression;FieldReference;IdExpression;Name;Name;IfStatement;BinaryExpression;FieldReference;IdExpression;Name;Name;BinaryExpression;IdExpression;Name;LiteralExpression;CompoundStatement;ExpressionStatement;BinaryExpression;FieldReference;IdExpression;Name;Name;LiteralExpression;IfStatement;BinaryExpression;IdExpression;Name;LiteralExpression;CompoundStatement;ReturnStatement;FunctionCallExpression;IdExpression;Name;IdExpression;Name;CastExpression;TypeId;SimpleDeclSpecifier;Declarator;IdExpression;Name;CompoundStatement;ReturnStatement;LiteralExpression;ExpressionStatement;BinaryExpression;IdExpression;Name;FunctionCallExpression;IdExpression;Name;IdExpression;Name;ExpressionStatement;BinaryExpression;IdExpression;Name;FunctionCallExpression;IdExpression;Name;IdExpression;Name;ExpressionStatement;BinaryExpression;IdExpression;Name;FunctionCallExpression;UnaryExpression;IdExpression;Name;BinaryExpression;LiteralExpression;BinaryExpression;UnaryExpression;BinaryExpression;BinaryExpression;CastExpression;TypeId;NamedTypeSpecifier;Name;Declarator;IdExpression;Name;IdExpression;Name;LiteralExpression;LiteralExpression;IfStatement;BinaryExpression;BinaryExpression;IdExpression;Name;LiteralExpression;BinaryExpression;IdExpression;Name;LiteralExpression;CompoundStatement;ExpressionStatement;BinaryExpression;FieldReference;IdExpression;Name;Name;LiteralExpression;CompoundStatement;ExpressionStatement;FunctionCallExpression;IdExpression;Name;FieldReference;IdExpression;Name;Name;LiteralExpression;IdExpression;Name;ExpressionStatement;FunctionCallExpression;IdExpression;Name;FieldReference;IdExpression;Name;Name;LiteralExpression;IdExpression;Name;ExpressionStatement;BinaryExpression;FieldReference;IdExpression;Name;Name;LiteralExpression;IfStatement;FunctionCallExpression;IdExpression;Name;FieldReference;IdExpression;Name;Name;CompoundStatement;IfStatement;BinaryExpression;IdExpression;Name;LiteralExpression;CompoundStatement;ReturnStatement;LiteralExpression;DeclarationStatement;SimpleDeclaration;NamedTypeSpecifier;Name;Declarator;Name;EqualsInitializer;FunctionCallExpression;IdExpression;Name;IdExpression;Name;IdExpression;Name;IfStatement;UnaryExpression;FunctionCallExpression;IdExpression;Name;IdExpression;Name;FieldReference;IdExpression;Name;Name;IdExpression;Name;CompoundStatement;ReturnStatement;LiteralExpression;ExpressionStatement;BinaryExpression;IdExpression;Name;IdExpression;Name;ExpressionStatement;FunctionCallExpression;IdExpression;Name;FieldReference;IdExpression;Name;Name;FieldReference;IdExpression;Name;Name;IdExpression;Name;DeclarationStatement;SimpleDeclaration;NamedTypeSpecifier;Name;Declarator;Name;EqualsInitializer;FunctionCallExpression;IdExpression;Name;FieldReference;IdExpression;Name;Name;BinaryExpression;FieldReference;IdExpression;Name;Name;FieldReference;IdExpression;Name;Name;BinaryExpression;IdExpression;Name;FieldReference;IdExpression;Name;Name;IfStatement;BinaryExpression;IdExpression;Name;IdExpression;Name;CompoundStatement;ExpressionStatement;FunctionCallExpression;IdExpression;Name;IdExpression;Name;IdExpression;Name;LiteralExpression;ReturnStatement;LiteralExpression;ExpressionStatement;BinaryExpression;FieldReference;IdExpression;Name;Name;IdExpression;Name;IfStatement;BinaryExpression;FieldReference;IdExpression;Name;Name;IdExpression;Name;CompoundStatement;DeclarationStatement;SimpleDeclaration;SimpleDeclSpecifier;Declarator;Name;EqualsInitializer;ArraySubscriptExpression;FieldReference;IdExpression;Name;Name;LiteralExpression;IfStatement;BinaryExpression;BinaryExpression;IdExpression;Name;LiteralExpression;BinaryExpression;IdExpression;Name;IdExpression;Name;CompoundStatement;ExpressionStatement;FunctionCallExpression;IdExpression;Name;BinaryExpression;FieldReference;IdExpression;Name;Name;LiteralExpression;BinaryExpression;FieldReference;IdExpression;Name;Name;LiteralExpression;BinaryExpression;IdExpression;Name;LiteralExpression;IdExpression;Name;IdExpression;Name;IfStatement;BinaryExpression;IdExpression;Name;LiteralExpression;CompoundStatement;ExpressionStatement;FunctionCallExpression;IdExpression;Name;IdExpression;Name;IdExpression;Name;LiteralExpression;ReturnStatement;LiteralExpression;ExpressionStatement;FunctionCallExpression;IdExpression;Name;IdExpression;Name;BinaryExpression;FieldReference;IdExpression;Name;Name;LiteralExpression;IdExpression;Name;ExpressionStatement;UnaryExpression;FieldReference;IdExpression;Name;Name;IfStatement;BinaryExpression;FieldReference;IdExpression;Name;Name;IdExpression;Name;CompoundStatement;ExpressionStatement;BinaryExpression;FieldReference;IdExpression;Name;Name;LiteralExpression;CompoundStatement;DeclarationStatement;SimpleDeclaration;NamedTypeSpecifier;Name;Declarator;Pointer;Name;EqualsInitializer;FieldReference;IdExpression;Name;Name;ExpressionStatement;BinaryExpression;FieldReference;IdExpression;Name;Name;FieldReference;IdExpression;Name;Name;ExpressionStatement;BinaryExpression;FieldReference;IdExpression;Name;Name;IdExpression;Name;ExpressionStatement;BinaryExpression;FieldReference;IdExpression;Name;Name;LiteralExpression;\n",
      "-----ast_node-----\n",
      "static bool ok_png_read_data(ok_png_decoder *decoder, uint32_t bytes_remaining) {    ok_png *png = decoder->png;    size_t inflate_buffer_size = 64 * 1024;    size_t num_passes = decoder->interlace_method == 0 ? 1 : 7;    uint8_t bits_per_pixel = decoder->bit_depth * OK_PNG_SAMPLES_PER_PIXEL[decoder->color_type];    uint8_t bytes_per_pixel = (bits_per_pixel + 7) / 8;    uint64_t max_bytes_per_scanline = 1 + ((uint64_t)png->width * bits_per_pixel + 7) / 8;    size_t platform_max_bytes_per_scanline = (size_t)max_bytes_per_scanline;    // Create buffers    if (!png->data) {        if (decoder->allocator.image_alloc) {            decoder->allocator.image_alloc(decoder->allocator_user_data,                                           png->width, png->height, png->bpp,                                           &png->data, &png->stride);        } else {            uint64_t size = (uint64_t)png->stride * png->height;            size_t platform_size = (size_t)size;            if (platform_size == size) {                png->data = ok_alloc(decoder, platform_size);            }        }        if (!png->data) {            ok_png_error(png, OK_PNG_ERROR_ALLOCATION, \"Couldn't allocate memory for image\");            return false;        }        if (png->stride < png->width * png->bpp) {            ok_png_error(png, OK_PNG_ERROR_API, \"Invalid stride\");            return false;        }    }    if (!decoder->prev_scanline) {        if (max_bytes_per_scanline == platform_max_bytes_per_scanline) {            decoder->prev_scanline = ok_alloc(decoder, platform_max_bytes_per_scanline);        }    }    if (!decoder->curr_scanline) {        if (max_bytes_per_scanline == platform_max_bytes_per_scanline) {            decoder->curr_scanline = ok_alloc(decoder, platform_max_bytes_per_scanline);        }    }    if (!decoder->inflate_buffer) {        decoder->inflate_buffer = ok_alloc(decoder, inflate_buffer_size);    }    if (decoder->interlace_method == 1 && !decoder->temp_data_row) {        decoder->temp_data_row = ok_alloc(decoder, png->width * png->bpp);    }    if (!decoder->curr_scanline || !decoder->prev_scanline || !decoder->inflate_buffer ||        (decoder->interlace_method == 1 && !decoder->temp_data_row)) {        ok_png_error(png, OK_PNG_ERROR_ALLOCATION, \"Couldn't allocate buffers\");        return false;    }    // Setup inflater    if (!decoder->inflater) {        decoder->inflater = ok_inflater_init(decoder->is_ios_format,                                             decoder->allocator, decoder->allocator_user_data);        if (!decoder->inflater) {            ok_png_error(png, OK_PNG_ERROR_ALLOCATION, \"Couldn't init inflater\");            return false;        }    }    // Sanity check - this happened with one file in the PNG suite    if (decoder->decoding_completed) {        if (bytes_remaining > 0) {            return ok_seek(decoder, (long)bytes_remaining);        } else {            return true;        }    }    // Read data    uint32_t curr_width = ok_png_get_width_for_pass(decoder);    uint32_t curr_height = ok_png_get_height_for_pass(decoder);    size_t curr_bytes_per_scanline = (size_t)(1 + ((uint64_t)curr_width * bits_per_pixel + 7) / 8);    while (true) {        // Setup pass        while (decoder->ready_for_next_interlace_pass) {            decoder->ready_for_next_interlace_pass = false;            decoder->scanline = 0;            decoder->interlace_pass++;            if (decoder->interlace_pass == num_passes + 1) {                // Done decoding - skip any remaining chunk data                decoder->decoding_completed = true;                if (bytes_remaining > 0) {                    return ok_seek(decoder, (long)bytes_remaining);                } else {                    return true;                }            }            curr_width = ok_png_get_width_for_pass(decoder);            curr_height = ok_png_get_height_for_pass(decoder);            curr_bytes_per_scanline = (size_t)(1 + ((uint64_t)curr_width * bits_per_pixel + 7) / 8);            if (curr_width == 0 || curr_height == 0) {                // No data for this pass - happens if width or height <= 4                decoder->ready_for_next_interlace_pass = true;            } else {                memset(decoder->curr_scanline, 0, curr_bytes_per_scanline);                memset(decoder->prev_scanline, 0, curr_bytes_per_scanline);                decoder->inflater_bytes_read = 0;            }        }        // Read compressed data        if (ok_inflater_needs_input(decoder->inflater)) {            if (bytes_remaining == 0) {                // Need more data, but there is no remaining data in this chunk.                // There may be another IDAT chunk.                return true;            }            const size_t len = min(inflate_buffer_size, bytes_remaining);            if (!ok_read(decoder, decoder->inflate_buffer, len)) {                return false;            }            bytes_remaining -= len;            ok_inflater_set_input(decoder->inflater, decoder->inflate_buffer, len);        }        // Decompress data        size_t len = ok_inflater_inflate(decoder->inflater,                                         decoder->curr_scanline + decoder->inflater_bytes_read,                                         curr_bytes_per_scanline - decoder->inflater_bytes_read);        if (len == OK_SIZE_MAX) {            ok_png_error(png, OK_PNG_ERROR_INFLATER, \"Inflater error\");            return false;        }        decoder->inflater_bytes_read += len;        if (decoder->inflater_bytes_read == curr_bytes_per_scanline) {            // Apply filter            const int filter = decoder->curr_scanline[0];            if (filter > 0 && filter < OK_PNG_NUM_FILTERS) {                ok_png_decode_filter(decoder->curr_scanline + 1, decoder->prev_scanline + 1,                                     curr_bytes_per_scanline - 1, filter, bytes_per_pixel);            } else if (filter != 0) {                ok_png_error(png, OK_PNG_ERROR_INVALID, \"Invalid filter type\");                return false;            }            // Transform            ok_png_transform_scanline(decoder, decoder->curr_scanline + 1, curr_width);            // Setup for next scanline or pass            decoder->scanline++;            if (decoder->scanline == curr_height) {                decoder->ready_for_next_interlace_pass = true;            } else {                uint8_t *temp = decoder->curr_scanline;                decoder->curr_scanline = decoder->prev_scanline;                decoder->prev_scanline = temp;                decoder->inflater_bytes_read = 0;            }        }    }}\n",
      "static bool\n",
      "ok_png_read_data(ok_png_decoder *decoder, uint32_t bytes_remaining)\n",
      "ok_png_read_data\n",
      "ok_png_decoder *decoder\n",
      "ok_png_decoder\n",
      "ok_png_decoder\n",
      "*decoder\n",
      "*\n",
      "decoder\n",
      "uint32_t bytes_remaining\n",
      "uint32_t\n",
      "uint32_t\n",
      "bytes_remaining\n",
      "bytes_remaining\n",
      "{    ok_png *png = decoder->png;    size_t inflate_buffer_size = 64 * 1024;    size_t num_passes = decoder->interlace_method == 0 ? 1 : 7;    uint8_t bits_per_pixel = decoder->bit_depth * OK_PNG_SAMPLES_PER_PIXEL[decoder->color_type];    uint8_t bytes_per_pixel = (bits_per_pixel + 7) / 8;    uint64_t max_bytes_per_scanline = 1 + ((uint64_t)png->width * bits_per_pixel + 7) / 8;    size_t platform_max_bytes_per_scanline = (size_t)max_bytes_per_scanline;    // Create buffers    if (!png->data) {        if (decoder->allocator.image_alloc) {            decoder->allocator.image_alloc(decoder->allocator_user_data,                                           png->width, png->height, png->bpp,                                           &png->data, &png->stride);        } else {            uint64_t size = (uint64_t)png->stride * png->height;            size_t platform_size = (size_t)size;            if (platform_size == size) {                png->data = ok_alloc(decoder, platform_size);            }        }        if (!png->data) {            ok_png_error(png, OK_PNG_ERROR_ALLOCATION, \"Couldn't allocate memory for image\");            return false;        }        if (png->stride < png->width * png->bpp) {            ok_png_error(png, OK_PNG_ERROR_API, \"Invalid stride\");            return false;        }    }    if (!decoder->prev_scanline) {        if (max_bytes_per_scanline == platform_max_bytes_per_scanline) {            decoder->prev_scanline = ok_alloc(decoder, platform_max_bytes_per_scanline);        }    }    if (!decoder->curr_scanline) {        if (max_bytes_per_scanline == platform_max_bytes_per_scanline) {            decoder->curr_scanline = ok_alloc(decoder, platform_max_bytes_per_scanline);        }    }    if (!decoder->inflate_buffer) {        decoder->inflate_buffer = ok_alloc(decoder, inflate_buffer_size);    }    if (decoder->interlace_method == 1 && !decoder->temp_data_row) {        decoder->temp_data_row = ok_alloc(decoder, png->width * png->bpp);    }    if (!decoder->curr_scanline || !decoder->prev_scanline || !decoder->inflate_buffer ||        (decoder->interlace_method == 1 && !decoder->temp_data_row)) {        ok_png_error(png, OK_PNG_ERROR_ALLOCATION, \"Couldn't allocate buffers\");        return false;    }    // Setup inflater    if (!decoder->inflater) {        decoder->inflater = ok_inflater_init(decoder->is_ios_format,                                             decoder->allocator, decoder->allocator_user_data);        if (!decoder->inflater) {            ok_png_error(png, OK_PNG_ERROR_ALLOCATION, \"Couldn't init inflater\");            return false;        }    }    // Sanity check - this happened with one file in the PNG suite    if (decoder->decoding_completed) {        if (bytes_remaining > 0) {            return ok_seek(decoder, (long)bytes_remaining);        } else {            return true;        }    }    // Read data    uint32_t curr_width = ok_png_get_width_for_pass(decoder);    uint32_t curr_height = ok_png_get_height_for_pass(decoder);    size_t curr_bytes_per_scanline = (size_t)(1 + ((uint64_t)curr_width * bits_per_pixel + 7) / 8);    while (true) {        // Setup pass        while (decoder->ready_for_next_interlace_pass) {            decoder->ready_for_next_interlace_pass = false;            decoder->scanline = 0;            decoder->interlace_pass++;            if (decoder->interlace_pass == num_passes + 1) {                // Done decoding - skip any remaining chunk data                decoder->decoding_completed = true;                if (bytes_remaining > 0) {                    return ok_seek(decoder, (long)bytes_remaining);                } else {                    return true;                }            }            curr_width = ok_png_get_width_for_pass(decoder);            curr_height = ok_png_get_height_for_pass(decoder);            curr_bytes_per_scanline = (size_t)(1 + ((uint64_t)curr_width * bits_per_pixel + 7) / 8);            if (curr_width == 0 || curr_height == 0) {                // No data for this pass - happens if width or height <= 4                decoder->ready_for_next_interlace_pass = true;            } else {                memset(decoder->curr_scanline, 0, curr_bytes_per_scanline);                memset(decoder->prev_scanline, 0, curr_bytes_per_scanline);                decoder->inflater_bytes_read = 0;            }        }        // Read compressed data        if (ok_inflater_needs_input(decoder->inflater)) {            if (bytes_remaining == 0) {                // Need more data, but there is no remaining data in this chunk.                // There may be another IDAT chunk.                return true;            }            const size_t len = min(inflate_buffer_size, bytes_remaining);            if (!ok_read(decoder, decoder->inflate_buffer, len)) {                return false;            }            bytes_remaining -= len;            ok_inflater_set_input(decoder->inflater, decoder->inflate_buffer, len);        }        // Decompress data        size_t len = ok_inflater_inflate(decoder->inflater,                                         decoder->curr_scanline + decoder->inflater_bytes_read,                                         curr_bytes_per_scanline - decoder->inflater_bytes_read);        if (len == OK_SIZE_MAX) {            ok_png_error(png, OK_PNG_ERROR_INFLATER, \"Inflater error\");            return false;        }        decoder->inflater_bytes_read += len;        if (decoder->inflater_bytes_read == curr_bytes_per_scanline) {            // Apply filter            const int filter = decoder->curr_scanline[0];            if (filter > 0 && filter < OK_PNG_NUM_FILTERS) {                ok_png_decode_filter(decoder->curr_scanline + 1, decoder->prev_scanline + 1,                                     curr_bytes_per_scanline - 1, filter, bytes_per_pixel);            } else if (filter != 0) {                ok_png_error(png, OK_PNG_ERROR_INVALID, \"Invalid filter type\");                return false;            }            // Transform            ok_png_transform_scanline(decoder, decoder->curr_scanline + 1, curr_width);            // Setup for next scanline or pass            decoder->scanline++;            if (decoder->scanline == curr_height) {                decoder->ready_for_next_interlace_pass = true;            } else {                uint8_t *temp = decoder->curr_scanline;                decoder->curr_scanline = decoder->prev_scanline;                decoder->prev_scanline = temp;                decoder->inflater_bytes_read = 0;            }        }    }}\n",
      "ok_png *png = decoder->png;\n",
      "ok_png *png = decoder->png;\n",
      "ok_png\n",
      "ok_png\n",
      "*png = decoder->png\n",
      "*\n",
      "png\n",
      "= decoder->png\n",
      "decoder->png\n",
      "decoder\n",
      "decoder\n",
      "png\n",
      "size_t inflate_buffer_size = 64 * 1024;\n",
      "size_t inflate_buffer_size = 64 * 1024;\n",
      "size_t\n",
      "size_t\n",
      "inflate_buffer_size = 64 * 1024\n",
      "inflate_buffer_size\n",
      "= 64 * 1024\n",
      "64 * 1024\n",
      "64\n",
      "1024\n",
      "size_t num_passes = decoder->interlace_method == 0 ? 1 : 7;\n",
      "size_t num_passes = decoder->interlace_method == 0 ? 1 : 7;\n",
      "size_t\n",
      "size_t\n",
      "num_passes = decoder->interlace_method == 0 ? 1 : 7\n",
      "num_passes\n",
      "= decoder->interlace_method == 0 ? 1 : 7\n",
      "decoder->interlace_method == 0 ? 1 : 7\n",
      "decoder->interlace_method == 0\n",
      "decoder->interlace_method\n",
      "decoder\n",
      "decoder\n",
      "interlace_method\n",
      "0\n",
      "1\n",
      "7\n",
      "uint8_t bits_per_pixel = decoder->bit_depth * OK_PNG_SAMPLES_PER_PIXEL[decoder->color_type];\n",
      "uint8_t bits_per_pixel = decoder->bit_depth * OK_PNG_SAMPLES_PER_PIXEL[decoder->color_type];\n",
      "uint8_t\n",
      "uint8_t\n",
      "bits_per_pixel = decoder->bit_depth * OK_PNG_SAMPLES_PER_PIXEL[decoder->color_type]\n",
      "bits_per_pixel\n",
      "= decoder->bit_depth * OK_PNG_SAMPLES_PER_PIXEL[decoder->color_type]\n",
      "decoder->bit_depth * OK_PNG_SAMPLES_PER_PIXEL[decoder->color_type]\n",
      "decoder->bit_depth\n",
      "decoder\n",
      "decoder\n",
      "bit_depth\n",
      "OK_PNG_SAMPLES_PER_PIXEL[decoder->color_type]\n",
      "OK_PNG_SAMPLES_PER_PIXEL\n",
      "OK_PNG_SAMPLES_PER_PIXEL\n",
      "decoder->color_type\n",
      "decoder\n",
      "decoder\n",
      "color_type\n",
      "uint8_t bytes_per_pixel = (bits_per_pixel + 7) / 8;\n",
      "uint8_t bytes_per_pixel = (bits_per_pixel + 7) / 8;\n",
      "uint8_t\n",
      "uint8_t\n",
      "bytes_per_pixel = (bits_per_pixel + 7) / 8\n",
      "bytes_per_pixel\n",
      "= (bits_per_pixel + 7) / 8\n",
      "(bits_per_pixel + 7) / 8\n",
      "(bits_per_pixel + 7)\n",
      "bits_per_pixel + 7\n",
      "bits_per_pixel\n",
      "bits_per_pixel\n",
      "7\n",
      "8\n",
      "uint64_t max_bytes_per_scanline = 1 + ((uint64_t)png->width * bits_per_pixel + 7) / 8;\n",
      "uint64_t max_bytes_per_scanline = 1 + ((uint64_t)png->width * bits_per_pixel + 7) / 8;\n",
      "uint64_t\n",
      "uint64_t\n",
      "max_bytes_per_scanline = 1 + ((uint64_t)png->width * bits_per_pixel + 7) / 8\n",
      "max_bytes_per_scanline\n",
      "= 1 + ((uint64_t)png->width * bits_per_pixel + 7) / 8\n",
      "1 + ((uint64_t)png->width * bits_per_pixel + 7) / 8\n",
      "1\n",
      "((uint64_t)png->width * bits_per_pixel + 7) / 8\n",
      "((uint64_t)png->width * bits_per_pixel + 7)\n",
      "(uint64_t)png->width * bits_per_pixel + 7\n",
      "(uint64_t)png->width * bits_per_pixel\n",
      "(uint64_t)png->width\n",
      "uint64_t\n",
      "uint64_t\n",
      "uint64_t\n",
      "\n",
      "png->width\n",
      "png\n",
      "png\n",
      "width\n",
      "bits_per_pixel\n",
      "bits_per_pixel\n",
      "7\n",
      "8\n",
      "size_t platform_max_bytes_per_scanline = (size_t)max_bytes_per_scanline;\n",
      "size_t platform_max_bytes_per_scanline = (size_t)max_bytes_per_scanline;\n",
      "size_t\n",
      "size_t\n",
      "platform_max_bytes_per_scanline = (size_t)max_bytes_per_scanline\n",
      "platform_max_bytes_per_scanline\n",
      "= (size_t)max_bytes_per_scanline\n",
      "(size_t)max_bytes_per_scanline\n",
      "size_t\n",
      "size_t\n",
      "size_t\n",
      "\n",
      "max_bytes_per_scanline\n",
      "max_bytes_per_scanline\n",
      "if (!png->data) {        if (decoder->allocator.image_alloc) {            decoder->allocator.image_alloc(decoder->allocator_user_data,                                           png->width, png->height, png->bpp,                                           &png->data, &png->stride);        } else {            uint64_t size = (uint64_t)png->stride * png->height;            size_t platform_size = (size_t)size;            if (platform_size == size) {                png->data = ok_alloc(decoder, platform_size);            }        }        if (!png->data) {            ok_png_error(png, OK_PNG_ERROR_ALLOCATION, \"Couldn't allocate memory for image\");            return false;        }        if (png->stride < png->width * png->bpp) {            ok_png_error(png, OK_PNG_ERROR_API, \"Invalid stride\");            return false;        }    }\n",
      "!png->data\n",
      "png->data\n",
      "png\n",
      "png\n",
      "data\n",
      "{        if (decoder->allocator.image_alloc) {            decoder->allocator.image_alloc(decoder->allocator_user_data,                                           png->width, png->height, png->bpp,                                           &png->data, &png->stride);        } else {            uint64_t size = (uint64_t)png->stride * png->height;            size_t platform_size = (size_t)size;            if (platform_size == size) {                png->data = ok_alloc(decoder, platform_size);            }        }        if (!png->data) {            ok_png_error(png, OK_PNG_ERROR_ALLOCATION, \"Couldn't allocate memory for image\");            return false;        }        if (png->stride < png->width * png->bpp) {            ok_png_error(png, OK_PNG_ERROR_API, \"Invalid stride\");            return false;        }    }\n",
      "if (decoder->allocator.image_alloc) {            decoder->allocator.image_alloc(decoder->allocator_user_data,                                           png->width, png->height, png->bpp,                                           &png->data, &png->stride);        } else {            uint64_t size = (uint64_t)png->stride * png->height;            size_t platform_size = (size_t)size;            if (platform_size == size) {                png->data = ok_alloc(decoder, platform_size);            }        }\n",
      "decoder->allocator.image_alloc\n",
      "decoder->allocator\n",
      "decoder\n",
      "decoder\n",
      "allocator\n",
      "image_alloc\n",
      "{            decoder->allocator.image_alloc(decoder->allocator_user_data,                                           png->width, png->height, png->bpp,                                           &png->data, &png->stride);        }\n",
      "decoder->allocator.image_alloc(decoder->allocator_user_data,                                           png->width, png->height, png->bpp,                                           &png->data, &png->stride);\n",
      "decoder->allocator.image_alloc(decoder->allocator_user_data,                                           png->width, png->height, png->bpp,                                           &png->data, &png->stride)\n",
      "decoder->allocator.image_alloc\n",
      "decoder->allocator\n",
      "decoder\n",
      "decoder\n",
      "allocator\n",
      "image_alloc\n",
      "decoder->allocator_user_data\n",
      "decoder\n",
      "decoder\n",
      "allocator_user_data\n",
      "png->width\n",
      "png\n",
      "png\n",
      "width\n",
      "png->height\n",
      "png\n",
      "png\n",
      "height\n",
      "png->bpp\n",
      "png\n",
      "png\n",
      "bpp\n",
      "&png->data\n",
      "png->data\n",
      "png\n",
      "png\n",
      "data\n",
      "&png->stride\n",
      "png->stride\n",
      "png\n",
      "png\n",
      "stride\n",
      "{            uint64_t size = (uint64_t)png->stride * png->height;            size_t platform_size = (size_t)size;            if (platform_size == size) {                png->data = ok_alloc(decoder, platform_size);            }        }\n",
      "uint64_t size = (uint64_t)png->stride * png->height;\n",
      "uint64_t size = (uint64_t)png->stride * png->height;\n",
      "uint64_t\n",
      "uint64_t\n",
      "size = (uint64_t)png->stride * png->height\n",
      "size\n",
      "= (uint64_t)png->stride * png->height\n",
      "(uint64_t)png->stride * png->height\n",
      "(uint64_t)png->stride\n",
      "uint64_t\n",
      "uint64_t\n",
      "uint64_t\n",
      "\n",
      "png->stride\n",
      "png\n",
      "png\n",
      "stride\n",
      "png->height\n",
      "png\n",
      "png\n",
      "height\n",
      "size_t platform_size = (size_t)size;\n",
      "size_t platform_size = (size_t)size;\n",
      "size_t\n",
      "size_t\n",
      "platform_size = (size_t)size\n",
      "platform_size\n",
      "= (size_t)size\n",
      "(size_t)size\n",
      "size_t\n",
      "size_t\n",
      "size_t\n",
      "\n",
      "size\n",
      "size\n",
      "if (platform_size == size) {                png->data = ok_alloc(decoder, platform_size);            }\n",
      "platform_size == size\n",
      "platform_size\n",
      "platform_size\n",
      "size\n",
      "size\n",
      "{                png->data = ok_alloc(decoder, platform_size);            }\n",
      "png->data = ok_alloc(decoder, platform_size);\n",
      "png->data = ok_alloc(decoder, platform_size)\n",
      "png->data\n",
      "png\n",
      "png\n",
      "data\n",
      "ok_alloc(decoder, platform_size)\n",
      "ok_alloc\n",
      "ok_alloc\n",
      "decoder\n",
      "decoder\n",
      "platform_size\n",
      "platform_size\n",
      "if (!png->data) {            ok_png_error(png, OK_PNG_ERROR_ALLOCATION, \"Couldn't allocate memory for image\");            return false;        }\n",
      "!png->data\n",
      "png->data\n",
      "png\n",
      "png\n",
      "data\n",
      "{            ok_png_error(png, OK_PNG_ERROR_ALLOCATION, \"Couldn't allocate memory for image\");            return false;        }\n",
      "ok_png_error(png, OK_PNG_ERROR_ALLOCATION, \"Couldn't allocate memory for image\");\n",
      "ok_png_error(png, OK_PNG_ERROR_ALLOCATION, \"Couldn't allocate memory for image\")\n",
      "ok_png_error\n",
      "ok_png_error\n",
      "png\n",
      "png\n",
      "OK_PNG_ERROR_ALLOCATION\n",
      "OK_PNG_ERROR_ALLOCATION\n",
      "\"Couldn't allocate memory for image\"\n",
      "return false;\n",
      "false\n",
      "if (png->stride < png->width * png->bpp) {            ok_png_error(png, OK_PNG_ERROR_API, \"Invalid stride\");            return false;        }\n",
      "png->stride < png->width * png->bpp\n",
      "png->stride\n",
      "png\n",
      "png\n",
      "stride\n",
      "png->width * png->bpp\n",
      "png->width\n",
      "png\n",
      "png\n",
      "width\n",
      "png->bpp\n",
      "png\n",
      "png\n",
      "bpp\n",
      "{            ok_png_error(png, OK_PNG_ERROR_API, \"Invalid stride\");            return false;        }\n",
      "ok_png_error(png, OK_PNG_ERROR_API, \"Invalid stride\");\n",
      "ok_png_error(png, OK_PNG_ERROR_API, \"Invalid stride\")\n",
      "ok_png_error\n",
      "ok_png_error\n",
      "png\n",
      "png\n",
      "OK_PNG_ERROR_API\n",
      "OK_PNG_ERROR_API\n",
      "\"Invalid stride\"\n",
      "return false;\n",
      "false\n",
      "if (!decoder->prev_scanline) {        if (max_bytes_per_scanline == platform_max_bytes_per_scanline) {            decoder->prev_scanline = ok_alloc(decoder, platform_max_bytes_per_scanline);        }    }\n",
      "!decoder->prev_scanline\n",
      "decoder->prev_scanline\n",
      "decoder\n",
      "decoder\n",
      "prev_scanline\n",
      "{        if (max_bytes_per_scanline == platform_max_bytes_per_scanline) {            decoder->prev_scanline = ok_alloc(decoder, platform_max_bytes_per_scanline);        }    }\n",
      "if (max_bytes_per_scanline == platform_max_bytes_per_scanline) {            decoder->prev_scanline = ok_alloc(decoder, platform_max_bytes_per_scanline);        }\n",
      "max_bytes_per_scanline == platform_max_bytes_per_scanline\n",
      "max_bytes_per_scanline\n",
      "max_bytes_per_scanline\n",
      "platform_max_bytes_per_scanline\n",
      "platform_max_bytes_per_scanline\n",
      "{            decoder->prev_scanline = ok_alloc(decoder, platform_max_bytes_per_scanline);        }\n",
      "decoder->prev_scanline = ok_alloc(decoder, platform_max_bytes_per_scanline);\n",
      "decoder->prev_scanline = ok_alloc(decoder, platform_max_bytes_per_scanline)\n",
      "decoder->prev_scanline\n",
      "decoder\n",
      "decoder\n",
      "prev_scanline\n",
      "ok_alloc(decoder, platform_max_bytes_per_scanline)\n",
      "ok_alloc\n",
      "ok_alloc\n",
      "decoder\n",
      "decoder\n",
      "platform_max_bytes_per_scanline\n",
      "platform_max_bytes_per_scanline\n",
      "if (!decoder->curr_scanline) {        if (max_bytes_per_scanline == platform_max_bytes_per_scanline) {            decoder->curr_scanline = ok_alloc(decoder, platform_max_bytes_per_scanline);        }    }\n",
      "!decoder->curr_scanline\n",
      "decoder->curr_scanline\n",
      "decoder\n",
      "decoder\n",
      "curr_scanline\n",
      "{        if (max_bytes_per_scanline == platform_max_bytes_per_scanline) {            decoder->curr_scanline = ok_alloc(decoder, platform_max_bytes_per_scanline);        }    }\n",
      "if (max_bytes_per_scanline == platform_max_bytes_per_scanline) {            decoder->curr_scanline = ok_alloc(decoder, platform_max_bytes_per_scanline);        }\n",
      "max_bytes_per_scanline == platform_max_bytes_per_scanline\n",
      "max_bytes_per_scanline\n",
      "max_bytes_per_scanline\n",
      "platform_max_bytes_per_scanline\n",
      "platform_max_bytes_per_scanline\n",
      "{            decoder->curr_scanline = ok_alloc(decoder, platform_max_bytes_per_scanline);        }\n",
      "decoder->curr_scanline = ok_alloc(decoder, platform_max_bytes_per_scanline);\n",
      "decoder->curr_scanline = ok_alloc(decoder, platform_max_bytes_per_scanline)\n",
      "decoder->curr_scanline\n",
      "decoder\n",
      "decoder\n",
      "curr_scanline\n",
      "ok_alloc(decoder, platform_max_bytes_per_scanline)\n",
      "ok_alloc\n",
      "ok_alloc\n",
      "decoder\n",
      "decoder\n",
      "platform_max_bytes_per_scanline\n",
      "platform_max_bytes_per_scanline\n",
      "if (!decoder->inflate_buffer) {        decoder->inflate_buffer = ok_alloc(decoder, inflate_buffer_size);    }\n",
      "!decoder->inflate_buffer\n",
      "decoder->inflate_buffer\n",
      "decoder\n",
      "decoder\n",
      "inflate_buffer\n",
      "{        decoder->inflate_buffer = ok_alloc(decoder, inflate_buffer_size);    }\n",
      "decoder->inflate_buffer = ok_alloc(decoder, inflate_buffer_size);\n",
      "decoder->inflate_buffer = ok_alloc(decoder, inflate_buffer_size)\n",
      "decoder->inflate_buffer\n",
      "decoder\n",
      "decoder\n",
      "inflate_buffer\n",
      "ok_alloc(decoder, inflate_buffer_size)\n",
      "ok_alloc\n",
      "ok_alloc\n",
      "decoder\n",
      "decoder\n",
      "inflate_buffer_size\n",
      "inflate_buffer_size\n",
      "if (decoder->interlace_method == 1 && !decoder->temp_data_row) {        decoder->temp_data_row = ok_alloc(decoder, png->width * png->bpp);    }\n",
      "decoder->interlace_method == 1 && !decoder->temp_data_row\n",
      "decoder->interlace_method == 1\n",
      "decoder->interlace_method\n",
      "decoder\n",
      "decoder\n",
      "interlace_method\n",
      "1\n",
      "!decoder->temp_data_row\n",
      "decoder->temp_data_row\n",
      "decoder\n",
      "decoder\n",
      "temp_data_row\n",
      "{        decoder->temp_data_row = ok_alloc(decoder, png->width * png->bpp);    }\n",
      "decoder->temp_data_row = ok_alloc(decoder, png->width * png->bpp);\n",
      "decoder->temp_data_row = ok_alloc(decoder, png->width * png->bpp)\n",
      "decoder->temp_data_row\n",
      "decoder\n",
      "decoder\n",
      "temp_data_row\n",
      "ok_alloc(decoder, png->width * png->bpp)\n",
      "ok_alloc\n",
      "ok_alloc\n",
      "decoder\n",
      "decoder\n",
      "png->width * png->bpp\n",
      "png->width\n",
      "png\n",
      "png\n",
      "width\n",
      "png->bpp\n",
      "png\n",
      "png\n",
      "bpp\n",
      "if (!decoder->curr_scanline || !decoder->prev_scanline || !decoder->inflate_buffer ||        (decoder->interlace_method == 1 && !decoder->temp_data_row)) {        ok_png_error(png, OK_PNG_ERROR_ALLOCATION, \"Couldn't allocate buffers\");        return false;    }\n",
      "!decoder->curr_scanline || !decoder->prev_scanline || !decoder->inflate_buffer ||        (decoder->interlace_method == 1 && !decoder->temp_data_row)\n",
      "!decoder->curr_scanline || !decoder->prev_scanline || !decoder->inflate_buffer\n",
      "!decoder->curr_scanline || !decoder->prev_scanline\n",
      "!decoder->curr_scanline\n",
      "decoder->curr_scanline\n",
      "decoder\n",
      "decoder\n",
      "curr_scanline\n",
      "!decoder->prev_scanline\n",
      "decoder->prev_scanline\n",
      "decoder\n",
      "decoder\n",
      "prev_scanline\n",
      "!decoder->inflate_buffer\n",
      "decoder->inflate_buffer\n",
      "decoder\n",
      "decoder\n",
      "inflate_buffer\n",
      "(decoder->interlace_method == 1 && !decoder->temp_data_row)\n",
      "decoder->interlace_method == 1 && !decoder->temp_data_row\n",
      "decoder->interlace_method == 1\n",
      "decoder->interlace_method\n",
      "decoder\n",
      "decoder\n",
      "interlace_method\n",
      "1\n",
      "!decoder->temp_data_row\n",
      "decoder->temp_data_row\n",
      "decoder\n",
      "decoder\n",
      "temp_data_row\n",
      "{        ok_png_error(png, OK_PNG_ERROR_ALLOCATION, \"Couldn't allocate buffers\");        return false;    }\n",
      "ok_png_error(png, OK_PNG_ERROR_ALLOCATION, \"Couldn't allocate buffers\");\n",
      "ok_png_error(png, OK_PNG_ERROR_ALLOCATION, \"Couldn't allocate buffers\")\n",
      "ok_png_error\n",
      "ok_png_error\n",
      "png\n",
      "png\n",
      "OK_PNG_ERROR_ALLOCATION\n",
      "OK_PNG_ERROR_ALLOCATION\n",
      "\"Couldn't allocate buffers\"\n",
      "return false;\n",
      "false\n",
      "if (!decoder->inflater) {        decoder->inflater = ok_inflater_init(decoder->is_ios_format,                                             decoder->allocator, decoder->allocator_user_data);        if (!decoder->inflater) {            ok_png_error(png, OK_PNG_ERROR_ALLOCATION, \"Couldn't init inflater\");            return false;        }    }\n",
      "!decoder->inflater\n",
      "decoder->inflater\n",
      "decoder\n",
      "decoder\n",
      "inflater\n",
      "{        decoder->inflater = ok_inflater_init(decoder->is_ios_format,                                             decoder->allocator, decoder->allocator_user_data);        if (!decoder->inflater) {            ok_png_error(png, OK_PNG_ERROR_ALLOCATION, \"Couldn't init inflater\");            return false;        }    }\n",
      "decoder->inflater = ok_inflater_init(decoder->is_ios_format,                                             decoder->allocator, decoder->allocator_user_data);\n",
      "decoder->inflater = ok_inflater_init(decoder->is_ios_format,                                             decoder->allocator, decoder->allocator_user_data)\n",
      "decoder->inflater\n",
      "decoder\n",
      "decoder\n",
      "inflater\n",
      "ok_inflater_init(decoder->is_ios_format,                                             decoder->allocator, decoder->allocator_user_data)\n",
      "ok_inflater_init\n",
      "ok_inflater_init\n",
      "decoder->is_ios_format\n",
      "decoder\n",
      "decoder\n",
      "is_ios_format\n",
      "decoder->allocator\n",
      "decoder\n",
      "decoder\n",
      "allocator\n",
      "decoder->allocator_user_data\n",
      "decoder\n",
      "decoder\n",
      "allocator_user_data\n",
      "if (!decoder->inflater) {            ok_png_error(png, OK_PNG_ERROR_ALLOCATION, \"Couldn't init inflater\");            return false;        }\n",
      "!decoder->inflater\n",
      "decoder->inflater\n",
      "decoder\n",
      "decoder\n",
      "inflater\n",
      "{            ok_png_error(png, OK_PNG_ERROR_ALLOCATION, \"Couldn't init inflater\");            return false;        }\n",
      "ok_png_error(png, OK_PNG_ERROR_ALLOCATION, \"Couldn't init inflater\");\n",
      "ok_png_error(png, OK_PNG_ERROR_ALLOCATION, \"Couldn't init inflater\")\n",
      "ok_png_error\n",
      "ok_png_error\n",
      "png\n",
      "png\n",
      "OK_PNG_ERROR_ALLOCATION\n",
      "OK_PNG_ERROR_ALLOCATION\n",
      "\"Couldn't init inflater\"\n",
      "return false;\n",
      "false\n",
      "if (decoder->decoding_completed) {        if (bytes_remaining > 0) {            return ok_seek(decoder, (long)bytes_remaining);        } else {            return true;        }    }\n",
      "decoder->decoding_completed\n",
      "decoder\n",
      "decoder\n",
      "decoding_completed\n",
      "{        if (bytes_remaining > 0) {            return ok_seek(decoder, (long)bytes_remaining);        } else {            return true;        }    }\n",
      "if (bytes_remaining > 0) {            return ok_seek(decoder, (long)bytes_remaining);        } else {            return true;        }\n",
      "bytes_remaining > 0\n",
      "bytes_remaining\n",
      "bytes_remaining\n",
      "0\n",
      "{            return ok_seek(decoder, (long)bytes_remaining);        }\n",
      "return ok_seek(decoder, (long)bytes_remaining);\n",
      "ok_seek(decoder, (long)bytes_remaining)\n",
      "ok_seek\n",
      "ok_seek\n",
      "decoder\n",
      "decoder\n",
      "(long)bytes_remaining\n",
      "long\n",
      "long\n",
      "\n",
      "bytes_remaining\n",
      "bytes_remaining\n",
      "{            return true;        }\n",
      "return true;\n",
      "true\n",
      "uint32_t curr_width = ok_png_get_width_for_pass(decoder);\n",
      "uint32_t curr_width = ok_png_get_width_for_pass(decoder);\n",
      "uint32_t\n",
      "uint32_t\n",
      "curr_width = ok_png_get_width_for_pass(decoder)\n",
      "curr_width\n",
      "= ok_png_get_width_for_pass(decoder)\n",
      "ok_png_get_width_for_pass(decoder)\n",
      "ok_png_get_width_for_pass\n",
      "ok_png_get_width_for_pass\n",
      "decoder\n",
      "decoder\n",
      "uint32_t curr_height = ok_png_get_height_for_pass(decoder);\n",
      "uint32_t curr_height = ok_png_get_height_for_pass(decoder);\n",
      "uint32_t\n",
      "uint32_t\n",
      "curr_height = ok_png_get_height_for_pass(decoder)\n",
      "curr_height\n",
      "= ok_png_get_height_for_pass(decoder)\n",
      "ok_png_get_height_for_pass(decoder)\n",
      "ok_png_get_height_for_pass\n",
      "ok_png_get_height_for_pass\n",
      "decoder\n",
      "decoder\n",
      "size_t curr_bytes_per_scanline = (size_t)(1 + ((uint64_t)curr_width * bits_per_pixel + 7) / 8);\n",
      "size_t curr_bytes_per_scanline = (size_t)(1 + ((uint64_t)curr_width * bits_per_pixel + 7) / 8);\n",
      "size_t\n",
      "size_t\n",
      "curr_bytes_per_scanline = (size_t)(1 + ((uint64_t)curr_width * bits_per_pixel + 7) / 8)\n",
      "curr_bytes_per_scanline\n",
      "= (size_t)(1 + ((uint64_t)curr_width * bits_per_pixel + 7) / 8)\n",
      "(size_t)(1 + ((uint64_t)curr_width * bits_per_pixel + 7) / 8)\n",
      "(size_t)\n",
      "size_t\n",
      "size_t\n",
      "1 + ((uint64_t)curr_width * bits_per_pixel + 7) / 8\n",
      "1\n",
      "((uint64_t)curr_width * bits_per_pixel + 7) / 8\n",
      "((uint64_t)curr_width * bits_per_pixel + 7)\n",
      "(uint64_t)curr_width * bits_per_pixel + 7\n",
      "(uint64_t)curr_width * bits_per_pixel\n",
      "(uint64_t)curr_width\n",
      "uint64_t\n",
      "uint64_t\n",
      "uint64_t\n",
      "\n",
      "curr_width\n",
      "curr_width\n",
      "bits_per_pixel\n",
      "bits_per_pixel\n",
      "7\n",
      "8\n",
      "while (true) {        // Setup pass        while (decoder->ready_for_next_interlace_pass) {            decoder->ready_for_next_interlace_pass = false;            decoder->scanline = 0;            decoder->interlace_pass++;            if (decoder->interlace_pass == num_passes + 1) {                // Done decoding - skip any remaining chunk data                decoder->decoding_completed = true;                if (bytes_remaining > 0) {                    return ok_seek(decoder, (long)bytes_remaining);                } else {                    return true;                }            }            curr_width = ok_png_get_width_for_pass(decoder);            curr_height = ok_png_get_height_for_pass(decoder);            curr_bytes_per_scanline = (size_t)(1 + ((uint64_t)curr_width * bits_per_pixel + 7) / 8);            if (curr_width == 0 || curr_height == 0) {                // No data for this pass - happens if width or height <= 4                decoder->ready_for_next_interlace_pass = true;            } else {                memset(decoder->curr_scanline, 0, curr_bytes_per_scanline);                memset(decoder->prev_scanline, 0, curr_bytes_per_scanline);                decoder->inflater_bytes_read = 0;            }        }        // Read compressed data        if (ok_inflater_needs_input(decoder->inflater)) {            if (bytes_remaining == 0) {                // Need more data, but there is no remaining data in this chunk.                // There may be another IDAT chunk.                return true;            }            const size_t len = min(inflate_buffer_size, bytes_remaining);            if (!ok_read(decoder, decoder->inflate_buffer, len)) {                return false;            }            bytes_remaining -= len;            ok_inflater_set_input(decoder->inflater, decoder->inflate_buffer, len);        }        // Decompress data        size_t len = ok_inflater_inflate(decoder->inflater,                                         decoder->curr_scanline + decoder->inflater_bytes_read,                                         curr_bytes_per_scanline - decoder->inflater_bytes_read);        if (len == OK_SIZE_MAX) {            ok_png_error(png, OK_PNG_ERROR_INFLATER, \"Inflater error\");            return false;        }        decoder->inflater_bytes_read += len;        if (decoder->inflater_bytes_read == curr_bytes_per_scanline) {            // Apply filter            const int filter = decoder->curr_scanline[0];            if (filter > 0 && filter < OK_PNG_NUM_FILTERS) {                ok_png_decode_filter(decoder->curr_scanline + 1, decoder->prev_scanline + 1,                                     curr_bytes_per_scanline - 1, filter, bytes_per_pixel);            } else if (filter != 0) {                ok_png_error(png, OK_PNG_ERROR_INVALID, \"Invalid filter type\");                return false;            }            // Transform            ok_png_transform_scanline(decoder, decoder->curr_scanline + 1, curr_width);            // Setup for next scanline or pass            decoder->scanline++;            if (decoder->scanline == curr_height) {                decoder->ready_for_next_interlace_pass = true;            } else {                uint8_t *temp = decoder->curr_scanline;                decoder->curr_scanline = decoder->prev_scanline;                decoder->prev_scanline = temp;                decoder->inflater_bytes_read = 0;            }        }    }\n",
      "true\n",
      "{        // Setup pass        while (decoder->ready_for_next_interlace_pass) {            decoder->ready_for_next_interlace_pass = false;            decoder->scanline = 0;            decoder->interlace_pass++;            if (decoder->interlace_pass == num_passes + 1) {                // Done decoding - skip any remaining chunk data                decoder->decoding_completed = true;                if (bytes_remaining > 0) {                    return ok_seek(decoder, (long)bytes_remaining);                } else {                    return true;                }            }            curr_width = ok_png_get_width_for_pass(decoder);            curr_height = ok_png_get_height_for_pass(decoder);            curr_bytes_per_scanline = (size_t)(1 + ((uint64_t)curr_width * bits_per_pixel + 7) / 8);            if (curr_width == 0 || curr_height == 0) {                // No data for this pass - happens if width or height <= 4                decoder->ready_for_next_interlace_pass = true;            } else {                memset(decoder->curr_scanline, 0, curr_bytes_per_scanline);                memset(decoder->prev_scanline, 0, curr_bytes_per_scanline);                decoder->inflater_bytes_read = 0;            }        }        // Read compressed data        if (ok_inflater_needs_input(decoder->inflater)) {            if (bytes_remaining == 0) {                // Need more data, but there is no remaining data in this chunk.                // There may be another IDAT chunk.                return true;            }            const size_t len = min(inflate_buffer_size, bytes_remaining);            if (!ok_read(decoder, decoder->inflate_buffer, len)) {                return false;            }            bytes_remaining -= len;            ok_inflater_set_input(decoder->inflater, decoder->inflate_buffer, len);        }        // Decompress data        size_t len = ok_inflater_inflate(decoder->inflater,                                         decoder->curr_scanline + decoder->inflater_bytes_read,                                         curr_bytes_per_scanline - decoder->inflater_bytes_read);        if (len == OK_SIZE_MAX) {            ok_png_error(png, OK_PNG_ERROR_INFLATER, \"Inflater error\");            return false;        }        decoder->inflater_bytes_read += len;        if (decoder->inflater_bytes_read == curr_bytes_per_scanline) {            // Apply filter            const int filter = decoder->curr_scanline[0];            if (filter > 0 && filter < OK_PNG_NUM_FILTERS) {                ok_png_decode_filter(decoder->curr_scanline + 1, decoder->prev_scanline + 1,                                     curr_bytes_per_scanline - 1, filter, bytes_per_pixel);            } else if (filter != 0) {                ok_png_error(png, OK_PNG_ERROR_INVALID, \"Invalid filter type\");                return false;            }            // Transform            ok_png_transform_scanline(decoder, decoder->curr_scanline + 1, curr_width);            // Setup for next scanline or pass            decoder->scanline++;            if (decoder->scanline == curr_height) {                decoder->ready_for_next_interlace_pass = true;            } else {                uint8_t *temp = decoder->curr_scanline;                decoder->curr_scanline = decoder->prev_scanline;                decoder->prev_scanline = temp;                decoder->inflater_bytes_read = 0;            }        }    }\n",
      "while (decoder->ready_for_next_interlace_pass) {            decoder->ready_for_next_interlace_pass = false;            decoder->scanline = 0;            decoder->interlace_pass++;            if (decoder->interlace_pass == num_passes + 1) {                // Done decoding - skip any remaining chunk data                decoder->decoding_completed = true;                if (bytes_remaining > 0) {                    return ok_seek(decoder, (long)bytes_remaining);                } else {                    return true;                }            }            curr_width = ok_png_get_width_for_pass(decoder);            curr_height = ok_png_get_height_for_pass(decoder);            curr_bytes_per_scanline = (size_t)(1 + ((uint64_t)curr_width * bits_per_pixel + 7) / 8);            if (curr_width == 0 || curr_height == 0) {                // No data for this pass - happens if width or height <= 4                decoder->ready_for_next_interlace_pass = true;            } else {                memset(decoder->curr_scanline, 0, curr_bytes_per_scanline);                memset(decoder->prev_scanline, 0, curr_bytes_per_scanline);                decoder->inflater_bytes_read = 0;            }        }\n",
      "decoder->ready_for_next_interlace_pass\n",
      "decoder\n",
      "decoder\n",
      "ready_for_next_interlace_pass\n",
      "{            decoder->ready_for_next_interlace_pass = false;            decoder->scanline = 0;            decoder->interlace_pass++;            if (decoder->interlace_pass == num_passes + 1) {                // Done decoding - skip any remaining chunk data                decoder->decoding_completed = true;                if (bytes_remaining > 0) {                    return ok_seek(decoder, (long)bytes_remaining);                } else {                    return true;                }            }            curr_width = ok_png_get_width_for_pass(decoder);            curr_height = ok_png_get_height_for_pass(decoder);            curr_bytes_per_scanline = (size_t)(1 + ((uint64_t)curr_width * bits_per_pixel + 7) / 8);            if (curr_width == 0 || curr_height == 0) {                // No data for this pass - happens if width or height <= 4                decoder->ready_for_next_interlace_pass = true;            } else {                memset(decoder->curr_scanline, 0, curr_bytes_per_scanline);                memset(decoder->prev_scanline, 0, curr_bytes_per_scanline);                decoder->inflater_bytes_read = 0;            }        }\n",
      "decoder->ready_for_next_interlace_pass = false;\n",
      "decoder->ready_for_next_interlace_pass = false\n",
      "decoder->ready_for_next_interlace_pass\n",
      "decoder\n",
      "decoder\n",
      "ready_for_next_interlace_pass\n",
      "false\n",
      "decoder->scanline = 0;\n",
      "decoder->scanline = 0\n",
      "decoder->scanline\n",
      "decoder\n",
      "decoder\n",
      "scanline\n",
      "0\n",
      "decoder->interlace_pass++;\n",
      "decoder->interlace_pass++\n",
      "decoder->interlace_pass\n",
      "decoder\n",
      "decoder\n",
      "interlace_pass\n",
      "if (decoder->interlace_pass == num_passes + 1) {                // Done decoding - skip any remaining chunk data                decoder->decoding_completed = true;                if (bytes_remaining > 0) {                    return ok_seek(decoder, (long)bytes_remaining);                } else {                    return true;                }            }\n",
      "decoder->interlace_pass == num_passes + 1\n",
      "decoder->interlace_pass\n",
      "decoder\n",
      "decoder\n",
      "interlace_pass\n",
      "num_passes + 1\n",
      "num_passes\n",
      "num_passes\n",
      "1\n",
      "{                // Done decoding - skip any remaining chunk data                decoder->decoding_completed = true;                if (bytes_remaining > 0) {                    return ok_seek(decoder, (long)bytes_remaining);                } else {                    return true;                }            }\n",
      "decoder->decoding_completed = true;\n",
      "decoder->decoding_completed = true\n",
      "decoder->decoding_completed\n",
      "decoder\n",
      "decoder\n",
      "decoding_completed\n",
      "true\n",
      "if (bytes_remaining > 0) {                    return ok_seek(decoder, (long)bytes_remaining);                } else {                    return true;                }\n",
      "bytes_remaining > 0\n",
      "bytes_remaining\n",
      "bytes_remaining\n",
      "0\n",
      "{                    return ok_seek(decoder, (long)bytes_remaining);                }\n",
      "return ok_seek(decoder, (long)bytes_remaining);\n",
      "ok_seek(decoder, (long)bytes_remaining)\n",
      "ok_seek\n",
      "ok_seek\n",
      "decoder\n",
      "decoder\n",
      "(long)bytes_remaining\n",
      "long\n",
      "long\n",
      "\n",
      "bytes_remaining\n",
      "bytes_remaining\n",
      "{                    return true;                }\n",
      "return true;\n",
      "true\n",
      "curr_width = ok_png_get_width_for_pass(decoder);\n",
      "curr_width = ok_png_get_width_for_pass(decoder)\n",
      "curr_width\n",
      "curr_width\n",
      "ok_png_get_width_for_pass(decoder)\n",
      "ok_png_get_width_for_pass\n",
      "ok_png_get_width_for_pass\n",
      "decoder\n",
      "decoder\n",
      "curr_height = ok_png_get_height_for_pass(decoder);\n",
      "curr_height = ok_png_get_height_for_pass(decoder)\n",
      "curr_height\n",
      "curr_height\n",
      "ok_png_get_height_for_pass(decoder)\n",
      "ok_png_get_height_for_pass\n",
      "ok_png_get_height_for_pass\n",
      "decoder\n",
      "decoder\n",
      "curr_bytes_per_scanline = (size_t)(1 + ((uint64_t)curr_width * bits_per_pixel + 7) / 8);\n",
      "curr_bytes_per_scanline = (size_t)(1 + ((uint64_t)curr_width * bits_per_pixel + 7) / 8)\n",
      "curr_bytes_per_scanline\n",
      "curr_bytes_per_scanline\n",
      "(size_t)(1 + ((uint64_t)curr_width * bits_per_pixel + 7) / 8)\n",
      "(size_t)\n",
      "size_t\n",
      "size_t\n",
      "1 + ((uint64_t)curr_width * bits_per_pixel + 7) / 8\n",
      "1\n",
      "((uint64_t)curr_width * bits_per_pixel + 7) / 8\n",
      "((uint64_t)curr_width * bits_per_pixel + 7)\n",
      "(uint64_t)curr_width * bits_per_pixel + 7\n",
      "(uint64_t)curr_width * bits_per_pixel\n",
      "(uint64_t)curr_width\n",
      "uint64_t\n",
      "uint64_t\n",
      "uint64_t\n",
      "\n",
      "curr_width\n",
      "curr_width\n",
      "bits_per_pixel\n",
      "bits_per_pixel\n",
      "7\n",
      "8\n",
      "if (curr_width == 0 || curr_height == 0) {                // No data for this pass - happens if width or height <= 4                decoder->ready_for_next_interlace_pass = true;            } else {                memset(decoder->curr_scanline, 0, curr_bytes_per_scanline);                memset(decoder->prev_scanline, 0, curr_bytes_per_scanline);                decoder->inflater_bytes_read = 0;            }\n",
      "curr_width == 0 || curr_height == 0\n",
      "curr_width == 0\n",
      "curr_width\n",
      "curr_width\n",
      "0\n",
      "curr_height == 0\n",
      "curr_height\n",
      "curr_height\n",
      "0\n",
      "{                // No data for this pass - happens if width or height <= 4                decoder->ready_for_next_interlace_pass = true;            }\n",
      "decoder->ready_for_next_interlace_pass = true;\n",
      "decoder->ready_for_next_interlace_pass = true\n",
      "decoder->ready_for_next_interlace_pass\n",
      "decoder\n",
      "decoder\n",
      "ready_for_next_interlace_pass\n",
      "true\n",
      "{                memset(decoder->curr_scanline, 0, curr_bytes_per_scanline);                memset(decoder->prev_scanline, 0, curr_bytes_per_scanline);                decoder->inflater_bytes_read = 0;            }\n",
      "memset(decoder->curr_scanline, 0, curr_bytes_per_scanline);\n",
      "memset(decoder->curr_scanline, 0, curr_bytes_per_scanline)\n",
      "memset\n",
      "memset\n",
      "decoder->curr_scanline\n",
      "decoder\n",
      "decoder\n",
      "curr_scanline\n",
      "0\n",
      "curr_bytes_per_scanline\n",
      "curr_bytes_per_scanline\n",
      "memset(decoder->prev_scanline, 0, curr_bytes_per_scanline);\n",
      "memset(decoder->prev_scanline, 0, curr_bytes_per_scanline)\n",
      "memset\n",
      "memset\n",
      "decoder->prev_scanline\n",
      "decoder\n",
      "decoder\n",
      "prev_scanline\n",
      "0\n",
      "curr_bytes_per_scanline\n",
      "curr_bytes_per_scanline\n",
      "decoder->inflater_bytes_read = 0;\n",
      "decoder->inflater_bytes_read = 0\n",
      "decoder->inflater_bytes_read\n",
      "decoder\n",
      "decoder\n",
      "inflater_bytes_read\n",
      "0\n",
      "if (ok_inflater_needs_input(decoder->inflater)) {            if (bytes_remaining == 0) {                // Need more data, but there is no remaining data in this chunk.                // There may be another IDAT chunk.                return true;            }            const size_t len = min(inflate_buffer_size, bytes_remaining);            if (!ok_read(decoder, decoder->inflate_buffer, len)) {                return false;            }            bytes_remaining -= len;            ok_inflater_set_input(decoder->inflater, decoder->inflate_buffer, len);        }\n",
      "ok_inflater_needs_input(decoder->inflater)\n",
      "ok_inflater_needs_input\n",
      "ok_inflater_needs_input\n",
      "decoder->inflater\n",
      "decoder\n",
      "decoder\n",
      "inflater\n",
      "{            if (bytes_remaining == 0) {                // Need more data, but there is no remaining data in this chunk.                // There may be another IDAT chunk.                return true;            }            const size_t len = min(inflate_buffer_size, bytes_remaining);            if (!ok_read(decoder, decoder->inflate_buffer, len)) {                return false;            }            bytes_remaining -= len;            ok_inflater_set_input(decoder->inflater, decoder->inflate_buffer, len);        }\n",
      "if (bytes_remaining == 0) {                // Need more data, but there is no remaining data in this chunk.                // There may be another IDAT chunk.                return true;            }\n",
      "bytes_remaining == 0\n",
      "bytes_remaining\n",
      "bytes_remaining\n",
      "0\n",
      "{                // Need more data, but there is no remaining data in this chunk.                // There may be another IDAT chunk.                return true;            }\n",
      "return true;\n",
      "true\n",
      "const size_t len = min(inflate_buffer_size, bytes_remaining);\n",
      "const size_t len = min(inflate_buffer_size, bytes_remaining);\n",
      "const size_t\n",
      "size_t\n",
      "len = min(inflate_buffer_size, bytes_remaining)\n",
      "len\n",
      "= min(inflate_buffer_size, bytes_remaining)\n",
      "min(inflate_buffer_size, bytes_remaining)\n",
      "min\n",
      "min\n",
      "inflate_buffer_size\n",
      "inflate_buffer_size\n",
      "bytes_remaining\n",
      "bytes_remaining\n",
      "if (!ok_read(decoder, decoder->inflate_buffer, len)) {                return false;            }\n",
      "!ok_read(decoder, decoder->inflate_buffer, len)\n",
      "ok_read(decoder, decoder->inflate_buffer, len)\n",
      "ok_read\n",
      "ok_read\n",
      "decoder\n",
      "decoder\n",
      "decoder->inflate_buffer\n",
      "decoder\n",
      "decoder\n",
      "inflate_buffer\n",
      "len\n",
      "len\n",
      "{                return false;            }\n",
      "return false;\n",
      "false\n",
      "bytes_remaining -= len;\n",
      "bytes_remaining -= len\n",
      "bytes_remaining\n",
      "bytes_remaining\n",
      "len\n",
      "len\n",
      "ok_inflater_set_input(decoder->inflater, decoder->inflate_buffer, len);\n",
      "ok_inflater_set_input(decoder->inflater, decoder->inflate_buffer, len)\n",
      "ok_inflater_set_input\n",
      "ok_inflater_set_input\n",
      "decoder->inflater\n",
      "decoder\n",
      "decoder\n",
      "inflater\n",
      "decoder->inflate_buffer\n",
      "decoder\n",
      "decoder\n",
      "inflate_buffer\n",
      "len\n",
      "len\n",
      "size_t len = ok_inflater_inflate(decoder->inflater,                                         decoder->curr_scanline + decoder->inflater_bytes_read,                                         curr_bytes_per_scanline - decoder->inflater_bytes_read);\n",
      "size_t len = ok_inflater_inflate(decoder->inflater,                                         decoder->curr_scanline + decoder->inflater_bytes_read,                                         curr_bytes_per_scanline - decoder->inflater_bytes_read);\n",
      "size_t\n",
      "size_t\n",
      "len = ok_inflater_inflate(decoder->inflater,                                         decoder->curr_scanline + decoder->inflater_bytes_read,                                         curr_bytes_per_scanline - decoder->inflater_bytes_read)\n",
      "len\n",
      "= ok_inflater_inflate(decoder->inflater,                                         decoder->curr_scanline + decoder->inflater_bytes_read,                                         curr_bytes_per_scanline - decoder->inflater_bytes_read)\n",
      "ok_inflater_inflate(decoder->inflater,                                         decoder->curr_scanline + decoder->inflater_bytes_read,                                         curr_bytes_per_scanline - decoder->inflater_bytes_read)\n",
      "ok_inflater_inflate\n",
      "ok_inflater_inflate\n",
      "decoder->inflater\n",
      "decoder\n",
      "decoder\n",
      "inflater\n",
      "decoder->curr_scanline + decoder->inflater_bytes_read\n",
      "decoder->curr_scanline\n",
      "decoder\n",
      "decoder\n",
      "curr_scanline\n",
      "decoder->inflater_bytes_read\n",
      "decoder\n",
      "decoder\n",
      "inflater_bytes_read\n",
      "curr_bytes_per_scanline - decoder->inflater_bytes_read\n",
      "curr_bytes_per_scanline\n",
      "curr_bytes_per_scanline\n",
      "decoder->inflater_bytes_read\n",
      "decoder\n",
      "decoder\n",
      "inflater_bytes_read\n",
      "if (len == OK_SIZE_MAX) {            ok_png_error(png, OK_PNG_ERROR_INFLATER, \"Inflater error\");            return false;        }\n",
      "len == OK_SIZE_MAX\n",
      "len\n",
      "len\n",
      "OK_SIZE_MAX\n",
      "OK_SIZE_MAX\n",
      "{            ok_png_error(png, OK_PNG_ERROR_INFLATER, \"Inflater error\");            return false;        }\n",
      "ok_png_error(png, OK_PNG_ERROR_INFLATER, \"Inflater error\");\n",
      "ok_png_error(png, OK_PNG_ERROR_INFLATER, \"Inflater error\")\n",
      "ok_png_error\n",
      "ok_png_error\n",
      "png\n",
      "png\n",
      "OK_PNG_ERROR_INFLATER\n",
      "OK_PNG_ERROR_INFLATER\n",
      "\"Inflater error\"\n",
      "return false;\n",
      "false\n",
      "decoder->inflater_bytes_read += len;\n",
      "decoder->inflater_bytes_read += len\n",
      "decoder->inflater_bytes_read\n",
      "decoder\n",
      "decoder\n",
      "inflater_bytes_read\n",
      "len\n",
      "len\n",
      "if (decoder->inflater_bytes_read == curr_bytes_per_scanline) {            // Apply filter            const int filter = decoder->curr_scanline[0];            if (filter > 0 && filter < OK_PNG_NUM_FILTERS) {                ok_png_decode_filter(decoder->curr_scanline + 1, decoder->prev_scanline + 1,                                     curr_bytes_per_scanline - 1, filter, bytes_per_pixel);            } else if (filter != 0) {                ok_png_error(png, OK_PNG_ERROR_INVALID, \"Invalid filter type\");                return false;            }            // Transform            ok_png_transform_scanline(decoder, decoder->curr_scanline + 1, curr_width);            // Setup for next scanline or pass            decoder->scanline++;            if (decoder->scanline == curr_height) {                decoder->ready_for_next_interlace_pass = true;            } else {                uint8_t *temp = decoder->curr_scanline;                decoder->curr_scanline = decoder->prev_scanline;                decoder->prev_scanline = temp;                decoder->inflater_bytes_read = 0;            }        }\n",
      "decoder->inflater_bytes_read == curr_bytes_per_scanline\n",
      "decoder->inflater_bytes_read\n",
      "decoder\n",
      "decoder\n",
      "inflater_bytes_read\n",
      "curr_bytes_per_scanline\n",
      "curr_bytes_per_scanline\n",
      "{            // Apply filter            const int filter = decoder->curr_scanline[0];            if (filter > 0 && filter < OK_PNG_NUM_FILTERS) {                ok_png_decode_filter(decoder->curr_scanline + 1, decoder->prev_scanline + 1,                                     curr_bytes_per_scanline - 1, filter, bytes_per_pixel);            } else if (filter != 0) {                ok_png_error(png, OK_PNG_ERROR_INVALID, \"Invalid filter type\");                return false;            }            // Transform            ok_png_transform_scanline(decoder, decoder->curr_scanline + 1, curr_width);            // Setup for next scanline or pass            decoder->scanline++;            if (decoder->scanline == curr_height) {                decoder->ready_for_next_interlace_pass = true;            } else {                uint8_t *temp = decoder->curr_scanline;                decoder->curr_scanline = decoder->prev_scanline;                decoder->prev_scanline = temp;                decoder->inflater_bytes_read = 0;            }        }\n",
      "const int filter = decoder->curr_scanline[0];\n",
      "const int filter = decoder->curr_scanline[0];\n",
      "const int\n",
      "filter = decoder->curr_scanline[0]\n",
      "filter\n",
      "= decoder->curr_scanline[0]\n",
      "decoder->curr_scanline[0]\n",
      "decoder->curr_scanline\n",
      "decoder\n",
      "decoder\n",
      "curr_scanline\n",
      "0\n",
      "if (filter > 0 && filter < OK_PNG_NUM_FILTERS) {                ok_png_decode_filter(decoder->curr_scanline + 1, decoder->prev_scanline + 1,                                     curr_bytes_per_scanline - 1, filter, bytes_per_pixel);            } else if (filter != 0) {                ok_png_error(png, OK_PNG_ERROR_INVALID, \"Invalid filter type\");                return false;            }\n",
      "filter > 0 && filter < OK_PNG_NUM_FILTERS\n",
      "filter > 0\n",
      "filter\n",
      "filter\n",
      "0\n",
      "filter < OK_PNG_NUM_FILTERS\n",
      "filter\n",
      "filter\n",
      "OK_PNG_NUM_FILTERS\n",
      "OK_PNG_NUM_FILTERS\n",
      "{                ok_png_decode_filter(decoder->curr_scanline + 1, decoder->prev_scanline + 1,                                     curr_bytes_per_scanline - 1, filter, bytes_per_pixel);            }\n",
      "ok_png_decode_filter(decoder->curr_scanline + 1, decoder->prev_scanline + 1,                                     curr_bytes_per_scanline - 1, filter, bytes_per_pixel);\n",
      "ok_png_decode_filter(decoder->curr_scanline + 1, decoder->prev_scanline + 1,                                     curr_bytes_per_scanline - 1, filter, bytes_per_pixel)\n",
      "ok_png_decode_filter\n",
      "ok_png_decode_filter\n",
      "decoder->curr_scanline + 1\n",
      "decoder->curr_scanline\n",
      "decoder\n",
      "decoder\n",
      "curr_scanline\n",
      "1\n",
      "decoder->prev_scanline + 1\n",
      "decoder->prev_scanline\n",
      "decoder\n",
      "decoder\n",
      "prev_scanline\n",
      "1\n",
      "curr_bytes_per_scanline - 1\n",
      "curr_bytes_per_scanline\n",
      "curr_bytes_per_scanline\n",
      "1\n",
      "filter\n",
      "filter\n",
      "bytes_per_pixel\n",
      "bytes_per_pixel\n",
      "if (filter != 0) {                ok_png_error(png, OK_PNG_ERROR_INVALID, \"Invalid filter type\");                return false;            }\n",
      "filter != 0\n",
      "filter\n",
      "filter\n",
      "0\n",
      "{                ok_png_error(png, OK_PNG_ERROR_INVALID, \"Invalid filter type\");                return false;            }\n",
      "ok_png_error(png, OK_PNG_ERROR_INVALID, \"Invalid filter type\");\n",
      "ok_png_error(png, OK_PNG_ERROR_INVALID, \"Invalid filter type\")\n",
      "ok_png_error\n",
      "ok_png_error\n",
      "png\n",
      "png\n",
      "OK_PNG_ERROR_INVALID\n",
      "OK_PNG_ERROR_INVALID\n",
      "\"Invalid filter type\"\n",
      "return false;\n",
      "false\n",
      "ok_png_transform_scanline(decoder, decoder->curr_scanline + 1, curr_width);\n",
      "ok_png_transform_scanline(decoder, decoder->curr_scanline + 1, curr_width)\n",
      "ok_png_transform_scanline\n",
      "ok_png_transform_scanline\n",
      "decoder\n",
      "decoder\n",
      "decoder->curr_scanline + 1\n",
      "decoder->curr_scanline\n",
      "decoder\n",
      "decoder\n",
      "curr_scanline\n",
      "1\n",
      "curr_width\n",
      "curr_width\n",
      "decoder->scanline++;\n",
      "decoder->scanline++\n",
      "decoder->scanline\n",
      "decoder\n",
      "decoder\n",
      "scanline\n",
      "if (decoder->scanline == curr_height) {                decoder->ready_for_next_interlace_pass = true;            } else {                uint8_t *temp = decoder->curr_scanline;                decoder->curr_scanline = decoder->prev_scanline;                decoder->prev_scanline = temp;                decoder->inflater_bytes_read = 0;            }\n",
      "decoder->scanline == curr_height\n",
      "decoder->scanline\n",
      "decoder\n",
      "decoder\n",
      "scanline\n",
      "curr_height\n",
      "curr_height\n",
      "{                decoder->ready_for_next_interlace_pass = true;            }\n",
      "decoder->ready_for_next_interlace_pass = true;\n",
      "decoder->ready_for_next_interlace_pass = true\n",
      "decoder->ready_for_next_interlace_pass\n",
      "decoder\n",
      "decoder\n",
      "ready_for_next_interlace_pass\n",
      "true\n",
      "{                uint8_t *temp = decoder->curr_scanline;                decoder->curr_scanline = decoder->prev_scanline;                decoder->prev_scanline = temp;                decoder->inflater_bytes_read = 0;            }\n",
      "uint8_t *temp = decoder->curr_scanline;\n",
      "uint8_t *temp = decoder->curr_scanline;\n",
      "uint8_t\n",
      "uint8_t\n",
      "*temp = decoder->curr_scanline\n",
      "*\n",
      "temp\n",
      "= decoder->curr_scanline\n",
      "decoder->curr_scanline\n",
      "decoder\n",
      "decoder\n",
      "curr_scanline\n",
      "decoder->curr_scanline = decoder->prev_scanline;\n",
      "decoder->curr_scanline = decoder->prev_scanline\n",
      "decoder->curr_scanline\n",
      "decoder\n",
      "decoder\n",
      "curr_scanline\n",
      "decoder->prev_scanline\n",
      "decoder\n",
      "decoder\n",
      "prev_scanline\n",
      "decoder->prev_scanline = temp;\n",
      "decoder->prev_scanline = temp\n",
      "decoder->prev_scanline\n",
      "decoder\n",
      "decoder\n",
      "prev_scanline\n",
      "temp\n",
      "temp\n",
      "decoder->inflater_bytes_read = 0;\n",
      "decoder->inflater_bytes_read = 0\n",
      "decoder->inflater_bytes_read\n",
      "decoder\n",
      "decoder\n",
      "inflater_bytes_read\n",
      "0\n",
      "-----joern-----\n",
      "(12,48,0)\n",
      "(46,23,0)\n",
      "(6,50,0)\n",
      "(2,50,0)\n",
      "(34,33,0)\n",
      "(30,42,0)\n",
      "(32,45,0)\n",
      "(24,23,0)\n",
      "(45,33,0)\n",
      "(47,30,0)\n",
      "(6,13,0)\n",
      "(35,1,0)\n",
      "(29,47,0)\n",
      "(22,7,0)\n",
      "(33,50,0)\n",
      "(4,2,0)\n",
      "(2,20,0)\n",
      "(44,42,0)\n",
      "(26,33,0)\n",
      "(30,47,0)\n",
      "(32,24,0)\n",
      "(2,49,0)\n",
      "(42,44,0)\n",
      "(52,6,0)\n",
      "(45,23,0)\n",
      "(1,48,0)\n",
      "(42,30,0)\n",
      "(36,23,0)\n",
      "(45,11,0)\n",
      "(10,42,0)\n",
      "(17,50,0)\n",
      "(13,37,0)\n",
      "(24,33,0)\n",
      "(43,37,0)\n",
      "(47,50,0)\n",
      "(36,14,0)\n",
      "(31,7,0)\n",
      "(20,51,0)\n",
      "(48,1,0)\n",
      "(5,23,0)\n",
      "(15,6,0)\n",
      "(37,13,0)\n",
      "(49,8,0)\n",
      "(18,37,0)\n",
      "(17,35,0)\n",
      "(35,17,0)\n",
      "(14,7,0)\n",
      "(40,20,0)\n",
      "(14,48,0)\n",
      "(20,23,0)\n",
      "(3,11,0)\n",
      "(27,45,0)\n",
      "(47,20,0)\n",
      "(28,2,0)\n",
      "(24,41,0)\n",
      "(16,47,0)\n",
      "(7,50,0)\n",
      "(39,17,0)\n",
      "(7,14,0)\n",
      "(49,2,0)\n",
      "(36,51,0)\n",
      "(21,51,0)\n",
      "(37,50,0)\n",
      "(13,44,0)\n",
      "(25,14,0)\n",
      "(20,33,0)\n",
      "(53,49,0)\n",
      "(7,20,0)\n",
      "(23,50,0)\n",
      "(9,51,0)\n",
      "(44,13,0)\n",
      "(0,24,0)\n",
      "(36,33,0)\n",
      "(1,35,0)\n",
      "(48,51,0)\n",
      "(38,17,0)\n",
      "(14,36,0)\n",
      "(13,6,0)\n",
      "(23,36,0)\n",
      "(33,20,0)\n",
      "(19,30,0)\n",
      "(49,8,1)\n",
      "(23,5,1)\n",
      "(22,31,1)\n",
      "(17,38,1)\n",
      "(46,48,1)\n",
      "(27,49,1)\n",
      "(40,33,1)\n",
      "(1,35,1)\n",
      "(37,50,1)\n",
      "(14,48,1)\n",
      "(36,23,1)\n",
      "(47,16,1)\n",
      "(32,24,1)\n",
      "(49,2,1)\n",
      "(45,23,1)\n",
      "(52,37,1)\n",
      "(20,23,1)\n",
      "(2,50,1)\n",
      "(53,2,1)\n",
      "(44,13,1)\n",
      "(30,19,1)\n",
      "(2,20,1)\n",
      "(48,1,1)\n",
      "(5,46,1)\n",
      "(34,36,1)\n",
      "(16,29,1)\n",
      "(13,6,1)\n",
      "(15,52,1)\n",
      "(45,33,1)\n",
      "(37,18,1)\n",
      "(20,40,1)\n",
      "(7,22,1)\n",
      "(19,47,1)\n",
      "(18,43,1)\n",
      "(49,53,1)\n",
      "(6,50,1)\n",
      "(42,10,1)\n",
      "(42,30,1)\n",
      "(36,33,1)\n",
      "(20,33,1)\n",
      "(38,39,1)\n",
      "(7,20,1)\n",
      "(25,23,1)\n",
      "(28,4,1)\n",
      "(24,23,1)\n",
      "(4,20,1)\n",
      "(47,50,1)\n",
      "(32,45,1)\n",
      "(7,50,1)\n",
      "(14,7,1)\n",
      "(33,50,1)\n",
      "(6,15,1)\n",
      "(24,0,1)\n",
      "(17,50,1)\n",
      "(30,47,1)\n",
      "(36,14,1)\n",
      "(39,12,1)\n",
      "(43,49,1)\n",
      "(2,28,1)\n",
      "(33,26,1)\n",
      "(23,50,1)\n",
      "(13,37,1)\n",
      "(24,33,1)\n",
      "(26,34,1)\n",
      "(12,44,1)\n",
      "(44,42,1)\n",
      "(35,17,1)\n",
      "(47,20,1)\n",
      "(10,30,1)\n",
      "(45,27,1)\n",
      "(31,25,1)\n",
      "(29,13,1)\n",
      "(0,44,1)\n",
      "(30,13,2)\n",
      "(37,50,2)\n",
      "(7,44,2)\n",
      "(20,33,2)\n",
      "(35,17,2)\n",
      "(22,44,2)\n",
      "(5,44,2)\n",
      "(36,44,2)\n",
      "(16,13,2)\n",
      "(23,50,2)\n",
      "(7,50,2)\n",
      "(12,44,2)\n",
      "(20,23,2)\n",
      "(45,49,2)\n",
      "(34,44,2)\n",
      "(36,33,2)\n",
      "(19,13,2)\n",
      "(25,44,2)\n",
      "(32,45,2)\n",
      "(14,48,2)\n",
      "(48,44,2)\n",
      "(24,23,2)\n",
      "(36,14,2)\n",
      "(39,44,2)\n",
      "(17,44,2)\n",
      "(44,49,2)\n",
      "(1,35,2)\n",
      "(20,44,2)\n",
      "(49,8,2)\n",
      "(47,50,2)\n",
      "(26,44,2)\n",
      "(10,13,2)\n",
      "(42,30,2)\n",
      "(46,44,2)\n",
      "(47,13,2)\n",
      "(30,47,2)\n",
      "(53,44,2)\n",
      "(28,44,2)\n",
      "(49,44,2)\n",
      "(43,49,2)\n",
      "(13,49,2)\n",
      "(6,50,2)\n",
      "(15,49,2)\n",
      "(38,44,2)\n",
      "(42,13,2)\n",
      "(1,44,2)\n",
      "(45,33,2)\n",
      "(29,13,2)\n",
      "(0,44,2)\n",
      "(13,6,2)\n",
      "(4,44,2)\n",
      "(14,7,2)\n",
      "(47,20,2)\n",
      "(18,49,2)\n",
      "(44,42,2)\n",
      "(2,20,2)\n",
      "(45,23,2)\n",
      "(32,24,2)\n",
      "(52,49,2)\n",
      "(35,44,2)\n",
      "(44,13,2)\n",
      "(7,20,2)\n",
      "(23,44,2)\n",
      "(49,2,2)\n",
      "(17,50,2)\n",
      "(27,49,2)\n",
      "(13,37,2)\n",
      "(6,49,2)\n",
      "(2,44,2)\n",
      "(37,49,2)\n",
      "(40,44,2)\n",
      "(2,50,2)\n",
      "(33,44,2)\n",
      "(14,44,2)\n",
      "(33,50,2)\n",
      "(36,23,2)\n",
      "(31,44,2)\n",
      "(24,44,2)\n",
      "(24,33,2)\n",
      "(48,1,2)\n",
      "-----------------------------------\n",
      "(0,false)\n",
      "(1,*inflater->input++)\n",
      "(2,inflater->input_buffer_bits)\n",
      "(3,while (inflater->input_buffer_bits < num_bits)\n",
      "(4,inflater)\n",
      "(5,input_buffer)\n",
      "(6,inflater->input_end)\n",
      "(7,inflater->input_buffer_bits)\n",
      "(8,unsigned int num_bits)\n",
      "(9,if (inflater->input == inflater->input_end || inflater->input_buffer_bits + 8 > 32)\n",
      "(10,32)\n",
      "(11,)\n",
      "(12,input)\n",
      "(13,inflater->input == inflater->input_end)\n",
      "(14,input << inflater->input_buffer_bits)\n",
      "(15,input_end)\n",
      "(16,input_buffer_bits)\n",
      "(17,inflater->input)\n",
      "(18,input)\n",
      "(19,8)\n",
      "(20,inflater->input_buffer_bits += 8)\n",
      "(21,input)\n",
      "(22,input_buffer_bits)\n",
      "(23,inflater->input_buffer)\n",
      "(24,return false;)\n",
      "(25,input)\n",
      "(26,input_buffer_bits)\n",
      "(27,true)\n",
      "(28,input_buffer_bits)\n",
      "(29,inflater)\n",
      "(30,inflater->input_buffer_bits + 8)\n",
      "(31,inflater)\n",
      "(32,RET)\n",
      "(33,inflater->input_buffer_bits)\n",
      "(34,inflater)\n",
      "(35,inflater->input++)\n",
      "(36,inflater->input_buffer |= input << inflater->input_buffer_bits)\n",
      "(37,inflater->input)\n",
      "(38,input)\n",
      "(39,inflater)\n",
      "(40,8)\n",
      "(41,)\n",
      "(42,inflater->input_buffer_bits + 8 > 32)\n",
      "(43,inflater)\n",
      "(44,inflater->input == inflater->input_end || inflater->input_buffer_bits + 8 > 32)\n",
      "(45,return true;)\n",
      "(46,inflater)\n",
      "(47,inflater->input_buffer_bits)\n",
      "(48,input = *inflater->input++)\n",
      "(49,inflater->input_buffer_bits < num_bits)\n",
      "(50,ok_inflater *inflater)\n",
      "(51,)\n",
      "(52,inflater)\n",
      "(53,num_bits)\n",
      "=====================================\n",
      "\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Training phase:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Training the representation model...\n",
      "\n",
      "\n",
      "Saving the trained model...\n",
      "The model has been successfully saved!\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Covert programs source code to vectors via trained model\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "code:\n",
      "_zip_cdir_new(int nentry, struct zip_error *error)\n",
      "if ((cd=(struct zip_cdir *)malloc(sizeof(*cd))) == NULL) {_zip_error_set(error, ZIP_ER_MEMORY, 0);return NULL;}\n",
      "\n",
      "embedding:\n",
      "tensor([[[ 0.1581, -0.4600, -0.0727,  ..., -0.1875,  0.1904, -0.1420],\n",
      "         [-0.7708, -0.2276, -0.3352,  ...,  0.2482, -0.1096, -0.1805],\n",
      "         [ 0.1649,  0.1616,  0.2836,  ..., -0.1906,  0.1244,  0.4996],\n",
      "         ...,\n",
      "         [-0.0204, -0.6084, -0.1065,  ...,  0.4505,  0.4727, -0.4035],\n",
      "         [ 0.8623, -0.3156, -0.0681,  ..., -0.3251, -0.0094,  0.1844],\n",
      "         [ 0.1580, -0.4600, -0.0727,  ..., -0.1875,  0.1903, -0.1420]]],\n",
      "       grad_fn=<NativeLayerNormBackward>)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "from demo import demo_run \n",
    "current = os.getcwd()  # Get the current working directory\n",
    "\n",
    "''' Extract static information for programs (Sec. 3.2.1)'''\n",
    "print(\"Showing the static information:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "# Use the path_static function from the demo_run module to obtain the program path (path) \n",
    "# and the script path (ScriptPath) for extracting static code information\n",
    "path, ScriptPath = demo_run.path_static(current)\n",
    "# Execute the script to extract static information, \n",
    "# passing the program path (path) and the script path (ScriptPath) as arguments\n",
    "!bash $ScriptPath $path\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "''' Training the pretained representation model (Sec. 3.3.2)'''\n",
    "print(\"Training phase:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "# Obtain the dataset path and the path to the script for training reoresentation model\n",
    "dataset, scriptPath = demo_run.path_pretrain(current)\n",
    "# Execute the script for pretraining\n",
    "!python $scriptPath --dataset $dataset\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "''' Using trained model to represent programs''' \n",
    "print(\"Covert programs source code to vectors via trained model\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "# Obtain the trained reoresentation model to embedding\n",
    "scriptPath = demo_run.path_pretrain_show(current)\n",
    "# Execute the script with a trained model to represent programs\n",
    "#program you can choose with test_a.c,test_b.c or test_c.c\n",
    "!python $scriptPath --program test_a.c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-01-02T15:07:52.328679400Z",
     "start_time": "2024-01-02T15:07:52.321678Z"
    }
   },
   "source": [
    "\n",
    "### *Dynamic representation model*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Showing the dynamic information:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Compiling the entire project...\n",
      "Using KLEE to collect the dynamic information...\n",
      "Showing the dynamic code information of 4sqlite3.c-sqlite3VXPrintf.c.txt :\n",
      "----------------dynamic----------------\n",
      "=======testcase========\n",
      "model_version:0x01000000\n",
      "stdin-stat:0x000800000000000001000000ffffffff0100000000000000a4810000e8030000e8030000ffffffff0000000000000000ffffffffffffffff0010000000000000ffffffffffffffff2ff9366400000000ffffffffffffffff9ff8366400000000ffffffffffffffff9ff8366400000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\n",
      "stdin:0x4700000000000000000000000000000000000000\n",
      "=========trace=========\n",
      "void sqlite3VXPrintf(   StrAccum *pAccum,                  /* Accumulate results here */   int useExtended,                   /* Allow extended _-conversions */   const char *fmt,                   /* Format string */   va_list ap                         /* arguments */ ){\n",
      "int c;\n",
      "char *bufpt;\n",
      "int precision;\n",
      "int length;\n",
      "int idx;\n",
      "int width;\n",
      "etByte flag_leftjustify;\n",
      "etByte flag_plussign;\n",
      "etByte flag_blanksign;\n",
      "etByte flag_alternateform;\n",
      "etByte flag_altform2;\n",
      "etByte flag_zeropad;\n",
      "etByte flag_long;\n",
      "etByte flag_longlong;\n",
      "etByte done;\n",
      "etByte xtype = 0;\n",
      "char prefix;\n",
      "LONGDOUBLE_TYPE realvalue;\n",
      "const et_info *infop;\n",
      "char *zOut;\n",
      "int nOut;\n",
      "char *zExtra;\n",
      "int  exp, e2;\n",
      "int nsd;\n",
      "double rounder;\n",
      "etByte flag_dp;\n",
      "etByte flag_rtz;\n",
      "char buf[etBUFSIZE];\n",
      "bufpt = 0;\n",
      "flag_leftjustify = flag_plussign = flag_blanksign =       flag_alternateform = flag_altform2 = flag_zeropad = 0;\n",
      "done = 0;\n",
      "switch(c)\n",
      "done = 1;\n",
      "width = 0;\n",
      "precision = -1;\n",
      "flag_long = flag_longlong = 0;\n",
      "infop = &fmtinfo[0];\n",
      "xtype = etINVALID;\n",
      "for(idx=0;idx<ArraySize(fmtinfo);idx++)\n",
      "for(idx=0;idx<ArraySize(fmtinfo);idx++)\n",
      "if(c==fmtinfo[idx].fmttype)\n",
      "infop = &fmtinfo[idx];\n",
      "if(useExtended || (infop->flags & FLAG_INTERN)==0)\n",
      "xtype = infop->type;\n",
      "zExtra = 0;\n",
      "switch(xtype)\n",
      "bufpt = va_arg(ap,char*);\n",
      "length = sqlite3Strlen30(bufpt);\n",
      "if(!flag_leftjustify)\n",
      "register int nspace;\n",
      "nspace = width-length;\n",
      "if(length>0)\n",
      "sqlite3StrAccumAppend(pAccum, bufpt, length);\n",
      "sqlite3_free(zExtra);\n",
      "if(c!='_')\n",
      "int amt;\n",
      "bufpt = (char *)fmt;\n",
      "amt = 1;\n",
      "while((c=(*++fmt))!='_' && c!=0)\n",
      "amt++;\n",
      "while((c=(*++fmt))!='_' && c!=0)\n",
      "amt++;\n",
      "while((c=(*++fmt))!='_' && c!=0)\n",
      "amt++;\n",
      "while((c=(*++fmt))!='_' && c!=0)\n",
      "amt++;\n",
      "while((c=(*++fmt))!='_' && c!=0)\n",
      "amt++;\n",
      "while((c=(*++fmt))!='_' && c!=0)\n",
      "amt++;\n",
      "while((c=(*++fmt))!='_' && c!=0)\n",
      "amt++;\n",
      "while((c=(*++fmt))!='_' && c!=0)\n",
      "amt++;\n",
      "while((c=(*++fmt))!='_' && c!=0)\n",
      "amt++;\n",
      "sqlite3StrAccumAppend(pAccum, bufpt, amt);\n",
      "if(c==0)\n",
      "=======================\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Training phase:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Training the representation model...\n",
      "\n",
      "\n",
      "Saving the trained model...\n",
      "The model has been successfully saved!\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Covert programs source code to vectors via trained model\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "code:\n",
      "static jas_cmprof_t *jas_cmprof_create() {\n",
      "memset(prof, 0, sizeof(jas_cmprof_t));prof->iccprof = 0;for(i = 0;i < JAS_CMPROF_NUMPXFORMSEQS;++i)\n",
      "\n",
      "embedding:\n",
      "tensor([[[-0.4045, -0.3771,  0.1593,  ..., -0.1054, -0.5880,  1.2386],\n",
      "         [-0.7662,  0.3165,  0.0759,  ..., -0.1202, -0.6907,  0.6732],\n",
      "         [ 0.2650,  0.9174,  0.2216,  ..., -0.1886, -0.1772, -0.5871],\n",
      "         ...,\n",
      "         [ 0.2417, -0.4727,  1.2239,  ...,  0.1100, -0.7655,  0.7306],\n",
      "         [ 0.1611, -0.2626,  0.7901,  ..., -0.6500, -0.4085,  1.4150],\n",
      "         [-0.1635, -0.1899,  0.9200,  ..., -0.3743,  0.4969,  0.8255]]],\n",
      "       grad_fn=<NativeLayerNormBackward>)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "from demo import demo_run \n",
    "current = os.getcwd()  # Get the current working directory\n",
    "''' Extract dynamic information for programs (Sec. 3.2.2)'''\n",
    "print(\"Showing the dynamic information:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "# Use the path_static function from the demo_run module to obtain the project path (path) \n",
    "# and the script path (ScriptPath) for extracting dynamic code information\n",
    "path, ScriptPath = demo_run.path_dynamic(current)\n",
    "# Execute the script to extract dynamic information, \n",
    "# passing the program path (path) and the script path (ScriptPath) as arguments\n",
    "!bash $ScriptPath $path \n",
    "print(\"\\n---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "''' Training the dynamic pretained representation model (Sec. 3.3.2)'''\n",
    "print(\"Training phase:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "# Obtain the dataset path and the path to the script for training reoresentation model\n",
    "dataset, scriptPath = demo_run.path_pretrain_dynamic(current)\n",
    "# Execute the script for pretraining dynamic representation model\n",
    "!python $scriptPath  --dataset $dataset\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "''' Using trained model to represent programs dynamic information''' \n",
    "print(\"Covert programs source code to vectors via trained model\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "# Execute the script with a trained model to represent programs dynamic information\n",
    "scriptPath = demo_run.path_pretrain_dynamic_show(current)\n",
    "#program you can choose with test_a.c,test_b.c or test_c.c\n",
    "!python $scriptPath --program test_a.c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "## Step 2. Training Vulnerability Detection Model\n",
    "\n",
    " Concoction’s detection component takes the joint embedding as input to predict the presence of vulnerabilities.  Our current implementation only identifies whether a function may contain a vulnerability or bug and does not specify the type of vulnerability. Here we use CVE benchmarks to show the process.\n",
    "\n",
    "**approximate runtime ~ 10 minutes (please wait before moving to the next cell)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 3. Deployment\n",
    "\n",
    "This demo shows how to deploy our trained model on a real world project. Here we apply Concoction to the project Jasper.\n",
    "\n",
    "#### *Path Selection for Symbolic Execution*:\n",
    "After training the end-to-end model, we develop a path selection component to automatically select a subset of important paths whose dynamic traces are likely to improve prediction accuracy during deployment.\n",
    "\n",
    "*approximate runtime ~ 10 minutes*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training detection model:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Training the detection Model...\n",
      "Loading training and validation data set...\n",
      "Training the detection model...\n",
      "Training finished and saving the best trained model, The best validation performance is :\n",
      "f1 = 0.8873, precision = 0.9242, recall = 0.8531, accuracy = 0.8893\n",
      "\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Testing detection model:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Show the Trained Model (Load trained model and test on test case)\n",
      "Loading test dataset and the trained model...\n",
      "The test performance is :\n",
      "f1 = 0.8715, precision = 0.8914,recall = 0.8525,accuracy = 0.8686\n",
      "\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "from demo import demo_run \n",
    "current = os.getcwd()  # Get the current working directory\n",
    "''' Training vulnerability detection model (Sec. 3.3.3)'''\n",
    "print(\"Training detection model:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "# Use the path_train function from the demo_run module to obtain the project path (path) \n",
    "# and the script path (ScriptPath) for training the detection model\n",
    "train_dataset, ScriptPath = demo_run.path_train(current)\n",
    "# Execute the script to train the detection model\n",
    "!python $ScriptPath  --dataset $train_dataset --epochs 200 --batch_size 64\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "\n",
    "''' Testing vulnerability detection model'''\n",
    "print(\"Testing detection model:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "# Use the path_test function from the demo_run module to obtain the test project path (path) \n",
    "# and the script path (ScriptPath) for testing the detection model\n",
    "test_dataset, model_to_load,ScriptPath = demo_run.path_test(current)\n",
    "# Execute the script to test the detection model\n",
    "!python $ScriptPath  --dataset $test_dataset --model_to_load $model_to_load\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-08T13:43:09.709400100Z",
     "start_time": "2023-05-08T13:43:09.695397900Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting execution paths:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Collecting paths via static analysis...\n",
      "\n",
      "file (jas_cm.c-jas_cmprof_createfromiccprof.c.txt)  42 paths detected.\n",
      "\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Path selection:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Active learning for path selection...\n",
      "\n",
      "Apply active learning to jas_cm.c-jas_cmprof_createfromiccprof.c.txt...\n",
      "5 paths selected.\n",
      "\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Vulnerability detection:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Detecting vulnerability for files in project jasper...\n",
      "The following files are predicted to vulnerability:\n",
      "['jas_cm.c-jas_cmshapmatlut_set.c', 'jas_cm.c-jas_cmshapmatlut_init.c', 'jas_malloc.c-jas_malloc.c']\n",
      "\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "from Evaluation.demo1.concoction import Concoction\n",
    "from demo import demo_run \n",
    "current = os.getcwd()\n",
    "concoction=Concoction()\n",
    "\n",
    "''' Path collection (Sec. 3.4) '''\n",
    "print(\"Collecting execution paths:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "concoction.extractPathRepre()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "\n",
    "''' Active learning for path selection'''\n",
    "print(\"Path selection:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "concoction.pathSelect()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "\n",
    "''' Vulnerability detection'''\n",
    "print(\"Vulnerability detection:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "concoction.symbolicOnPath()\n",
    "test_dataset, model_to_load,ScriptPath = demo_run.detect(current)\n",
    "!python $ScriptPath  --dataset $test_dataset --model_to_load $model_to_load\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Demo 2: Experimental Evaluation (Section 5)\n",
    "\n",
    "Here, we present the evaluation results from our submitted manuscript. The entire training process, which takes over a day to complete, is available through our Docker image. Detailed instructions can be found on our project's GitHub. \n",
    "\n",
    "\n",
    "### Detect Vulnerabilities in Large-scale Testing (Section 5.1)\n",
    "\n",
    "This part(https://github.com/HuantWang/CONCOCTION/tree/main/vul_info) gives a quantified summary of Concoction for detecting function-level code vulnerabilities across the 20 projects listed in Table 3 in our papaer. This demo corresponds to Table 3 of the submitted manuscript."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparison on Open Datasets (Section  5.2)\n",
    "\n",
    "We now evaluate our vulnerability detection model on the SARD and CVE datasets in Table 1 in the paper.\n",
    "\n",
    "This demo corresponds to Figure 7 and 8 of the submitted manuscript.\n",
    "\n",
    "*approximate runtime = 10 minutes for one benchmark*\n",
    "\n",
    "#### --dataset:\n",
    "This parameter defines 8 candidate vulnerability dataset type. Possible values are:\n",
    "\n",
    "Standard vulnerability dataset (Sard dataset) : \"CWE-416\", \"CWE-789\",\"CWE-122\",\"CWE-124\",\"CWE-126\",\"CWE-190\",\"CWE-191\",\"CWE-78\"\n",
    "\n",
    "Open source vulnerability dataset : \"Github\"\n",
    "\n",
    "#### --method:\n",
    "This parameter defines 12 candidate vulnerability detection methods. Possible values are:\n",
    "\n",
    "\"concoction\" ,\"funded\"[1], \"vuldeepecker\"[2], \"reveal\"[3], \"devign\"[4], \"ReGVD\"[5], \"LineVul\"[6], \"Linevd\"[7], \"codebert\"[8], \"GraphCodebert\"[9], \"ContraFlow\"[10],\"Liger\" [11] \n",
    "\n",
    "### *Sard Dataset*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-08T13:43:09.740861300Z",
     "start_time": "2023-05-08T13:43:09.725404Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluating the \"CONCOCTION\" approach on SARD open source vulnerability:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is: Accuracy: 0.9592 Precision: 0.9310 Recall: 1.0000 F1 Score: 0.9643\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Evaluating the \"funded\" approach on SARD open source vulnerability:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is : Accuracy: 0.722  Precision: 0.667  Recall: 0.889  F1 Score: 0.762\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Evaluating the \"devign\" approach on SARD open source vulnerability:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is : Accuracy: 0.9742  Precision: 1  Recall: 0.9474  F1 Score: 0.973\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Evaluating the \"reveal\" approach on SARD open source vulnerability:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "The detection result is : Accuracy: 0.9722  Precision: 1  Recall: 0.9459  F1 Score: 0.9722\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Evaluating the \"vuldeepecker\" approach on SARD open source vulnerability:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is: Accuracy: 1.0000 Precision: 1.0000 Recall: 1.0000 F1 Score: 1.0000\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Evaluating the \"ContraFlow\" approach on SARD open source vulnerability:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is: Accuracy: 1.0000 Precision: 1.0000 Recall: 1.0000 F1 Score: 1.0000\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Evaluating the \"Liger\" approach on SARD open source vulnerability:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is: Accuracy: 1.0000 Precision: 1.0000 Recall: 1.0000 F1 Score: 1.0000\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Evaluating the \"codebert\" approach on SARD open source vulnerability:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "The detection result is : Accuracy: 0.9116  Precision: 0.9833  Recall: 0.831  F1 Score: 0.9008\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Evaluating the \"GraphCodebert\" approach on SARD open source vulnerability:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "The detection result is : Accuracy: 0.7851  Precision: 0.6832  Recall: 0.607  F1 Score: 0.6\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Evaluating the \"ReGVD\" approach on SARD open source vulnerability:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is : Accuracy: 0.8571  Precision: 0.7941  Recall: 1  F1 Score: 0.8852\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Evaluating the \"LineVul\" approach on SARD open source vulnerability:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is: Accuracy: 1.0000 Precision: 1.0000 Recall: 1.0000 F1 Score: 1.0000\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Evaluating the \"Linevd\" approach on SARD open source vulnerability:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is: Accuracy: 1.0000 Precision: 1.0000 Recall: 1.0000 F1 Score: 1.0000\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Finish\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "from Evaluation.demo2.demo2 import *\n",
    "\n",
    "''' Detection on SARD dataset '''\n",
    "\n",
    "print(\"Evaluating the \\\"CONCOCTION\\\" approach on SARD open source vulnerability:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "EvaluationSard(dataset=\"CWE-416\",method=\"concoction\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"Evaluating the \\\"funded\\\" approach on SARD open source vulnerability:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "EvaluationSard(dataset=\"CWE-416\",method=\"funded\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"Evaluating the \\\"devign\\\" approach on SARD open source vulnerability:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "EvaluationSard(dataset=\"CWE-416\",method=\"devign\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"Evaluating the \\\"reveal\\\" approach on SARD open source vulnerability:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "EvaluationSard(dataset=\"CWE-416\",method=\"reveal\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"Evaluating the \\\"vuldeepecker\\\" approach on SARD open source vulnerability:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "EvaluationSard(dataset=\"CWE-416\",method=\"vuldeepecker\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"Evaluating the \\\"ContraFlow\\\" approach on SARD open source vulnerability:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "EvaluationSard(dataset=\"CWE-416\",method=\"ContraFlow\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"Evaluating the \\\"Liger\\\" approach on SARD open source vulnerability:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "EvaluationSard(dataset=\"CWE-416\",method=\"Liger\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"Evaluating the \\\"codebert\\\" approach on SARD open source vulnerability:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "EvaluationSard(dataset=\"CWE-416\",method=\"codebert\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"Evaluating the \\\"GraphCodebert\\\" approach on SARD open source vulnerability:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "EvaluationSard(dataset=\"CWE-416\",method=\"graphcodebert\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"Evaluating the \\\"ReGVD\\\" approach on SARD open source vulnerability:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "EvaluationSard(dataset=\"CWE-416\",method=\"regvd\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"Evaluating the \\\"LineVul\\\" approach on SARD open source vulnerability:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "EvaluationSard(dataset=\"CWE-416\",method=\"LineVul\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"Evaluating the \\\"Linevd\\\" approach on SARD open source vulnerability:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "EvaluationSard(dataset=\"CWE-416\",method=\"Linevd\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "print(\"Finish\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### *Github Dataset*:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-08T13:43:09.758882900Z",
     "start_time": "2023-05-08T13:43:09.741861500Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluating the \"concoction\" approach on GitHub open source vulnerability:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is: Accuracy: 0.8686 Precision: 0.8914 Recall: 0.8525 F1 Score: 0.8715\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Evaluating the \"funded\" approach on GitHub open source vulnerability:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is : Accuracy: 0.727  Precision: 0.679  Recall: 0.864  F1 Score: 0.76\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Evaluating the \"devign\" approach on GitHub open source vulnerability:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is : Accuracy: 0.63  Precision: 0.67  Recall: 0.58  F1 Score: 0.62\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Evaluating the \"reveal\" approach on GitHub open source vulnerability:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "The detection result is : Accuracy: 0.6711  Precision: 0.6951  Recall: 0.6569  F1 Score: 0.6755\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Evaluating the \"vuldeepecker\" approach on GitHub open source vulnerability:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is: Accuracy: 0.6086 Precision: 0.6337 Recall: 0.5956 F1 Score: 0.6141\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Evaluating the \"ContraFlow\" approach on GitHub open source vulnerability:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is: Accuracy: 0.73  Precision: 0.72  Recall: 0.8  F1 Score: 0.76\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Evaluating the \"Liger\" approach on GitHub open source vulnerability:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is: Accuracy: 0.771  Precision: 0.731  Recall: 0.813  F1 Score: 0.762\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Evaluating the \"codebert\" approach on GitHub open source vulnerability:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "The detection result is : Accuracy: 0.6921  Precision: 0.6626  Recall: 0.8075  F1 Score: 0.7279\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Evaluating the \"GraphCodebert\" approach on GitHub open source vulnerability:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "The detection result is : Accuracy: 0.6667  Precision: 0.8  Recall: 0.6667  F1 Score: 0.7273\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Evaluating the \"ReGVD\" approach on GitHub open source vulnerability:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is : Accuracy: 0.7371  Precision: 0.8095  Recall: 0.6503  F1 Score: 0.7212\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Evaluating the \"Linevd\" approach on GitHub open source vulnerability:\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is: Accuracy: 0.69  Precision: 0.68  Recall: 0.76  F1 Score: 0.72\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Finish\n"
     ]
    }
   ],
   "source": [
    "from Evaluation.demo2.demo2 import *\n",
    "''' Detection on Github dataset '''\n",
    "print(\"Evaluating the \\\"concoction\\\" approach on GitHub open source vulnerability:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "EvaluationGithub(dataset=\"Github\",method=\"concoction\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"Evaluating the \\\"funded\\\" approach on GitHub open source vulnerability:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "EvaluationGithub(dataset=\"Github\",method=\"funded\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"Evaluating the \\\"devign\\\" approach on GitHub open source vulnerability:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "EvaluationGithub(dataset=\"Github\",method=\"devign\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"Evaluating the \\\"reveal\\\" approach on GitHub open source vulnerability:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "EvaluationGithub(dataset=\"Github\",method=\"reveal\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"Evaluating the \\\"vuldeepecker\\\" approach on GitHub open source vulnerability:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "EvaluationGithub(dataset=\"Github\",method=\"vuldeepecker\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"Evaluating the \\\"ContraFlow\\\" approach on GitHub open source vulnerability:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "EvaluationGithub(dataset=\"Github\",method=\"ContraFlow\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"Evaluating the \\\"Liger\\\" approach on GitHub open source vulnerability:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "EvaluationGithub(dataset=\"Github\",method=\"Liger\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"Evaluating the \\\"codebert\\\" approach on GitHub open source vulnerability:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "EvaluationGithub(dataset=\"Github\",method=\"codebert\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"Evaluating the \\\"GraphCodebert\\\" approach on GitHub open source vulnerability:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "EvaluationGithub(dataset=\"Github\",method=\"graphcodebert\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"Evaluating the \\\"ReGVD\\\" approach on GitHub open source vulnerability:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "EvaluationGithub(dataset=\"Github\",method=\"regvd\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"Evaluating the \\\"Linevd\\\" approach on GitHub open source vulnerability:\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "EvaluationGithub(dataset=\"Github\",method=\"Linevd\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "print(\"Finish\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "#### Full-scale evaluation data\n",
    "\n",
    "We now plot the diagrams using full-scale evaluation data (the full-scale evaluation would take too long to run the experiment lively in provided docker). The results correspond to Figure 7 and 8 (Section 5.2) of the submitted manuscript."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluating all 12 SOTA methods on entire SARD dataset... (approximately 10 mins)\n",
      "------------------------------funded-----------------------------\n",
      "Loading the dataset...\n",
      "Loading the trained model...\n",
      "\n",
      "The minimum detection result is :  Accuracy: 0.496  Precision: 0.709  Recall: 0.663  F1 Score: 0.496\n",
      "The maximum detection result is :  Accuracy: 0.962  Precision: 1  Recall: 1  F1 Score: 0.96\n",
      "The geomean detection result is : Accuracy: 0.88  Precision: 0.87  Recall: 0.94  F1 Score: 0.89\n",
      "------------------------------devign-----------------------------\n",
      "Loading the dataset...\n",
      "Loading the trained model...\n",
      "\n",
      "The minimum detection result is :  Accuracy: 0.4984  Precision: 0.4967  Recall: 0.4967  F1 Score: 0.4984\n",
      "The maximum detection result is :  Accuracy: 0.9817  Precision: 1  Recall: 1  F1 Score: 0.98\n",
      "The geomean detection result is : Accuracy: 0.7445  Precision: 0.7471  Recall: 0.7818  F1 Score: 0.7579\n",
      "---------------------------graphcodebert--------------------------\n",
      "Loading the dataset...\n",
      "Loading the trained model...\n",
      "The minimum detection result is :  Accuracy: 0.4851  Precision: 0.4883  Recall: 0.5  F1 Score: 0.4851\n",
      "The maximum detection result is :  Accuracy: 0.97  Precision: 0.94  Recall: 1  F1 Score: 0.97\n",
      "The geomean detection result is : Accuracy: 0.83  Precision: 0.81  Recall: 1  F1 Score: 0.88\n",
      "------------------------------regvd-------------------------------\n",
      "Loading the dataset...\n",
      "Loading the trained model...\n",
      "\n",
      "The minimum detection result is :  Accuracy: 0.5  Precision: 0.7725  Recall: 0.6667  F1 Score: 0.5\n",
      "The maximum detection result is :  Accuracy: 0.9592  Precision: 1  Recall: 1  F1 Score: 0.9575\n",
      "The geomean detection result is : Accuracy: 0.8373  Precision: 0.8671  Recall: 0.9039  F1 Score: 0.8754\n",
      "------------------------------reveal------------------------------\n",
      "Loading the dataset...\n",
      "Loading the trained model...\n",
      "The minimum detection result is :  Accuracy: 0.5161  Precision: 0.6103  Recall: 0.6979  F1 Score: 0.5161\n",
      "The maximum detection result is :  Accuracy: 1  Precision: 1  Recall: 1  F1 Score: 1\n",
      "The geomean detection result is :  Accuracy: 0.8535  Precision: 0.8638  Recall: 0.8707  F1 Score: 0.8923\n",
      "------------------------------codebert-----------------------------\n",
      "Loading the dataset...\n",
      "Loading the trained model...\n",
      "The minimum detection result is : Accuracy: 0.7941  Precision: 0.8605  Recall: 0.8108  F1 Score: 0.7941\n",
      "The maximum detection result is : Accuracy: 0.965  Precision: 0.986  Recall: 1  F1 Score: 0.964\n",
      "The geomean detection result is : Accuracy: 0.8923  Precision: 0.8984  Recall: 0.8797  F1 Score: 0.9138\n",
      "------------------------------vuldeepecker-----------------------------\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The minimum detection result is :  Accuracy: 0.6136  Precision: 0.2273  Recall: 0.3703  F1 Score: 0.6136\n",
      "The maximum detection result is :  Accuracy: 1  Precision: 1  Recall: 1  F1 Score: 1\n",
      "The geomean detection result is : Accuracy: 0.915  Precision: 0.9356  Recall: 0.7935  F1 Score: 0.8529\n",
      "------------------------------concoction-----------------------------\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The minimum detection result is :  Accuracy: 0.84  Precision: 0.77  Recall: 0.82  F1 Score: 0.84\n",
      "The maximum detection result is :  Accuracy: 0.9681  Precision: 0.9833  Recall: 1  F1 Score: 0.9684\n",
      "The geomean detection result is : Accuracy: 0.9339  Precision: 0.9338  Recall: 0.9391  F1 Score: 0.9347\n",
      "------------------------------LineVul-----------------------------\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The minimum detection result is :  Accuracy: 0.7045  Precision: 0.454  Recall: 0.606  F1 Score: 0.7045\n",
      "The maximum detection result is :  Accuracy: 0.98  Precision: 1  Recall: 0.98  F1 Score: 0.98\n",
      "The geomean detection result is : Accuracy: 0.9167  Precision: 0.9336  Recall: 0.8418  F1 Score: 0.9004\n",
      "------------------------------LineVD-----------------------------\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The minimum detection result is :  Accuracy: 0.81  Precision: 0.84  Recall: 0.6979  F1 Score: 0.83\n",
      "The maximum detection result is :  Accuracy: 1  Precision: 1  Recall: 1  F1 Score: 1\n",
      "The geomean detection result is : Accuracy: 0.9167  Precision: 0.9336  Recall: 0.8418  F1 Score: 0.9004\n",
      "------------------------------Liger-----------------------------\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The minimum detection result is :  Accuracy: 0.65  Precision: 0.33  Recall: 0.5  F1 Score: 0.65\n",
      "The maximum detection result is :  Accuracy: 1  Precision: 1  Recall: 1  F1 Score: 1\n",
      "The geomean detection result is : Accuracy: 0.8662  Precision: 0.8901  Recall: 0.8197  F1 Score: 0.834\n",
      "------------------------------ContraFlow-----------------------------\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The minimum detection result is :  Accuracy: 0.75  Precision: 0.67  Recall: 0.55  F1 Score: 0.7\n",
      "The maximum detection result is :  Accuracy: 0.9817  Precision: 1  Recall: 1  F1 Score: 0.98\n",
      "The geomean detection result is : Accuracy: 0.89  Precision: 0.91  Recall: 0.88  F1 Score: 0.89\n",
      "Output Figure 7: Evaluation on standard vulnerability databases. Min-max bars show performance across vulnerability types.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 736x280 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This figure reports the \"higher-is-better\" metrics achieved by Concoction and the baseline methods on the SARD dataset. The min-max bar indicates variances across cross-validation runs. Concoction outperforms baseline methods in all metrics and demonstrates the most reliable performance across cross-validation runs, with the narrowest min-max bar.\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "from Evaluation.demo2.chart.chart import *\n",
    "from Evaluation.demo2.demo2AllSard import *\n",
    "# Output Figure 7: Evaluation on standard vulnerability databases. Min-max bars show performance across vulnerability types.\n",
    "\n",
    "print(\"Evaluating all 12 SOTA methods on entire SARD dataset... (approximately 10 mins)\")\n",
    "# !python /homee/Evaluation/demo2/demo2AllSard.py --sard True > /homee/Evaluation/demo2/allSardResult.log\n",
    "!python /homee/Evaluation/demo2/demo2AllSard.py --sard True\n",
    "# print(\"Saving results in allSardResult.log ...\")\n",
    "\n",
    "print(\"Output Figure 7: Evaluation on standard vulnerability databases. Min-max bars show performance across vulnerability types.\")\n",
    "drawSard()\n",
    "print(\"This figure reports the \\\"higher-is-better\\\" metrics achieved by Concoction and the baseline methods on the SARD dataset. The min-max bar indicates variances across cross-validation runs. Concoction outperforms baseline methods in all metrics and demonstrates the most reliable performance across cross-validation runs, with the narrowest min-max bar.\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============================funded=================================\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is : Accuracy: 0.727  Precision: 0.679  Recall: 0.864  F1 Score: 0.76\n",
      "============================devign=================================\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is : Accuracy: 0.63  Precision: 0.67  Recall: 0.58  F1 Score: 0.62\n",
      "============================reveal=================================\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "The detection result is : Accuracy: 0.6711  Precision: 0.6951  Recall: 0.6569  F1 Score: 0.6755\n",
      "============================vuldeepecker=================================\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is: Accuracy: 0.6086 Precision: 0.6337 Recall: 0.5956 F1 Score: 0.6141\n",
      "============================concoction=================================\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is: Accuracy: 0.8686 Precision: 0.8914 Recall: 0.8525 F1 Score: 0.8715\n",
      "============================LineVul=================================\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is: Accuracy: 0.6067  Precision: 0.6067  Recall: 0.6408  F1 Score: 0.6233\n",
      "============================Linevd=================================\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is: Accuracy: 0.69  Precision: 0.68  Recall: 0.76  F1 Score: 0.72\n",
      "============================ContraFlow=================================\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is: Accuracy: 0.73  Precision: 0.72  Recall: 0.8  F1 Score: 0.76\n",
      "============================Liger=================================\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is: Accuracy: 0.771  Precision: 0.731  Recall: 0.813  F1 Score: 0.762\n",
      "============================codebert=================================\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "The detection result is : Accuracy: 0.6921  Precision: 0.6626  Recall: 0.8075  F1 Score: 0.7279\n",
      "============================graphcodebert=================================\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "The detection result is : Accuracy: 0.6667  Precision: 0.8  Recall: 0.6667  F1 Score: 0.7273\n",
      "============================regvd=================================\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is : Accuracy: 0.7371  Precision: 0.8095  Recall: 0.6503  F1 Score: 0.7212\n",
      "Finish\n",
      "Evaluating all 12 SOTA methods on entire CVE dataset... (approximately 10 mins)\n",
      "============================funded=================================\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is : Accuracy: 0.727  Precision: 0.679  Recall: 0.864  F1 Score: 0.76\n",
      "============================devign=================================\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is : Accuracy: 0.63  Precision: 0.67  Recall: 0.58  F1 Score: 0.62\n",
      "============================reveal=================================\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "The detection result is : Accuracy: 0.6711  Precision: 0.6951  Recall: 0.6569  F1 Score: 0.6755\n",
      "============================vuldeepecker=================================\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is: Accuracy: 0.6086 Precision: 0.6337 Recall: 0.5956 F1 Score: 0.6141\n",
      "============================concoction=================================\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is: Accuracy: 0.8686 Precision: 0.8914 Recall: 0.8525 F1 Score: 0.8715\n",
      "============================LineVul=================================\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is: Accuracy: 0.6067  Precision: 0.6067  Recall: 0.6408  F1 Score: 0.6233\n",
      "============================Linevd=================================\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is: Accuracy: 0.69  Precision: 0.68  Recall: 0.76  F1 Score: 0.72\n",
      "============================ContraFlow=================================\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is: Accuracy: 0.73  Precision: 0.72  Recall: 0.8  F1 Score: 0.76\n",
      "============================Liger=================================\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is: Accuracy: 0.771  Precision: 0.731  Recall: 0.813  F1 Score: 0.762\n",
      "============================codebert=================================\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "The detection result is : Accuracy: 0.6921  Precision: 0.6626  Recall: 0.8075  F1 Score: 0.7279\n",
      "============================graphcodebert=================================\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "The detection result is : Accuracy: 0.6667  Precision: 0.8  Recall: 0.6667  F1 Score: 0.7273\n",
      "============================regvd=================================\n",
      "Loading the dataset... \n",
      "Loading the trained model...\n",
      "\n",
      "The detection result is : Accuracy: 0.7371  Precision: 0.8095  Recall: 0.6503  F1 Score: 0.7212\n",
      "Finish\n",
      "\n",
      " Output Figure 8:  Evaluation on the CVE dataset Concoction gives the best performance across evaluation metrics.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 776x280 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test samples in the CVE dataset are more complex than the SARD dataset. As such, it is more challenging to achieve good performance. However, Concoction outperforms all other methods across all evaluation metrics shown as this Figure.\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "from Evaluation.demo2.chart.chart import *\n",
    "from Evaluation.demo2.demo2AllGithub import *\n",
    "# Output Figure 8:  Evaluation on the CVE dataset Concoction gives the best performance across evaluation metrics.\n",
    "\n",
    "print(\"Evaluating all 12 SOTA methods on entire CVE dataset... (approximately 10 mins)\")\n",
    "# !python /homee/Evaluation/demo2/demo2AllGithub.py > /homee/Evaluation/demo2/allGithubResult.log\n",
    "!python /homee/Evaluation/demo2/demo2AllGithub.py\n",
    "# print(\"Saving results in allGithubResult.log ...\")\n",
    "\n",
    "print(\"\\n Output Figure 8:  Evaluation on the CVE dataset Concoction gives the best performance across evaluation metrics.\")\n",
    "drawGithub()\n",
    "print(\"Test samples in the CVE dataset are more complex than the SARD dataset. As such, it is more challenging to achieve good performance. However, Concoction outperforms all other methods across all evaluation metrics shown as this Figure.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Case Study 3:  Evaluation on Opensource Projects (Section 5.3)\n",
    "\n",
    "We now compare to the baseline methods by applying them to the three open-source projects in Table 2 with a total of 35 CVEs reported by independent users.\n",
    "\n",
    "This demo corresponds to Table 5 of the submitted manuscript.\n",
    "\n",
    "*approximate runtime = 10 minutes for one benchmark*\n",
    "\n",
    "#### --model:\n",
    "This parameter defines 12 candidate vulnerability detection methods. Possible values are:\n",
    "\n",
    "\"concoction\" ,\"funded\"[1], \"vuldeepecker\"[2], \"reveal\"[3], \"devign\"[4], \"ReGVD\"[5], \"LineVul\"[6], \"Linevd\"[7], \"codebert\"[8], \"graphCodebert\"[9], \"ContraFlow\"[10],\"Liger\" [11] \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-08T13:43:09.790890100Z",
     "start_time": "2023-05-08T13:43:09.773886200Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------Evaluating the \"codebert\" approach on 35 CVEs:--------------------------------------\n",
      "Loading codebert pretrained model...\n",
      "Detecting vulnerabilities on all projects...\n",
      "3/35 vulnerabilities were detected: \"multiply_ms\"、\"renameUnmapSelectCb\" and \"sqlite3ExprCodeTarget\"\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "-------------------Evaluating the \"devign\" approach on 35 CVEs:----------------------------------------\n",
      "Loading Devign pretrained model...\n",
      "Detecting vulnerabilities on all projects...\n",
      "1/35 vulnerabilitie was detected: \"multiSelectOrderBy\"\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "-------------------Evaluating the \"regvd\" approach on 35 CVEs:-----------------------------------------\n",
      "Loading reGVD pretrained model...\n",
      "Detecting vulnerabilities on all projects...\n",
      "\n",
      "2/35 vulnerabilities were detected: \"JBIGDecode\" and \"exprListAppendList\"\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "-------------------Evaluating the \"funded\" approach on 35 CVEs:----------------------------------------\n",
      "Loading Funded pretrained model...\n",
      "Detecting vulnerabilities on all projects...\n",
      "\n",
      "2/35 vulnerabilities were detected: \"flattenSubquery\" and \"multiSelect\"\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "-------------------Evaluating the \"reveal\" approach on 35 CVEs:----------------------------------------\n",
      "Loading reveal pretrained model...\n",
      "Detecting vulnerabilities on all projects...\n",
      "2/35 vulnerabilities were detected: \"fts3ScanInteriorNode\" and \"png_formatted_warning\"\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "-------------------Evaluating the \"Linevd\" approach on 35 CVEs:----------------------------------------\n",
      "Loading LineVD pretrained model...\n",
      "Detecting vulnerabilities on all projects...\n",
      "\n",
      "3/35 vulnerabilitie was detected: ['selectExpander', 'sqlite3Select', 'cpSeparateBufToContigBuf']\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "------------------Evaluating the \"vuldeepecker\" approach on 35 CVEs:-----------------------------------\n",
      "Loading vuldeepecker pretrained model...\n",
      "Detecting vulnerabilities on all projects...\n",
      "\n",
      "1/35 vulnerabilitie was detected: ['unixGetTempname']\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "------------------Evaluating the \"ContraFlow\" approach on 35 CVEs:-------------------------------------\n",
      "Loading ContraFlow pretrained model...\n",
      "Detecting vulnerabilities on all projects...\n",
      "\n",
      "3/35 vulnerabilitie was detected: ['png_check_keyword', 'whereLoopAddBtreeIndex', 'zipfileUpdate']\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "------------------Evaluating the \"Liger\" approach on 35 CVEs:------------------------------------------\n",
      "Loading Liger pretrained model...\n",
      "Detecting vulnerabilities on all projects...\n",
      "\n",
      "16/35 vulnerabilitie was detected: ['selectExpander', 'fts3ScanInteriorNode', 'unixGetTempname', 'renameUnmapSelectCb', 'multiply_ms', 'TIFFSetDirectory', 'TIFFWriteDirectorySec', 'LZWDecode', 'TIFFPrintDirectory', 'cpTags', 'cpSeparateBufToContigBuf', 'png_check_keyword', 'png_set_text_2', 'png_set_unknown_chunks', 'png_decompress_chunk', 'png_handle_tRNS']\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "------------------Evaluating the \"Concoction\" approach on 35 CVEs:-------------------------------------\n",
      "Loading concoction pretrained model...\n",
      "Detecting vulnerabilities on all projects...\n",
      "\n",
      "31/35 vulnerabilitie was detected: ['png_push_read_zTXt', 'png_decompress_chunk', 'png_handle_cHRM', 'png_handle_tRNS', 'png_set_iCCP', 'png_set_sPLT', 'png_set_text_2', 'multiply_ms', 'TIFFSetDirectory', 'TIFFWriteDirectorySec', 'JBIGDecode', 'LZWDecode', 'LZWDecodeCompat', 'TIFFPrintDirectory', '_TIFFmemcmp', 'cpTags', 't2p_write_pdf', 'cpSeparateBufToContigBuf', 'renameUnmapSelectCb', 'sqlite3ExprCodeTarget', 'fts3ScanInteriorNode', 'unixGetTempname', 'flattenSubquery', 'multiSelect', 'multiSelectOrderBy', 'resetAccumulator', 'selectExpander', 'sqlite3Select', 'whereLoopAddBtreeIndex', 'exprListAppendList', 'zipfileUpdate']\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "------------------Evaluating the \"LineVul\" approach on 35 CVEs:----------------------------------------\n",
      "Loading LineVul pretrained model...\n",
      "Detecting vulnerabilities on all projects...\n",
      "\n",
      "3/35 vulnerabilitie was detected: ['png_set_text_2', 'png_set_unknown_chunks', 'resetAccumulator']\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "-------------------Evaluating the \"graphCodebert\" approach on 35 CVEs:---------------------------------\n",
      "Loading GraphCodeBERT pretrained model...\n",
      "Detecting vulnerabilities on all projects...\n",
      "1/35 vulnerabilitie was detected: \"TIFFSetDirectory\"\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Finished\n"
     ]
    }
   ],
   "source": [
    "from Evaluation.demo2.demo2CVE import *\n",
    "\n",
    "print(\"-------------------Evaluating the \\\"codebert\\\" approach on 35 CVEs:--------------------------------------\")\n",
    "EvaluationOP(model=\"codebert\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"-------------------Evaluating the \\\"devign\\\" approach on 35 CVEs:----------------------------------------\")\n",
    "EvaluationOP(model=\"devign\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "\n",
    "print(\"-------------------Evaluating the \\\"regvd\\\" approach on 35 CVEs:-----------------------------------------\")\n",
    "EvaluationOP(model=\"regvd\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "\n",
    "print(\"-------------------Evaluating the \\\"funded\\\" approach on 35 CVEs:----------------------------------------\")\n",
    "EvaluationOP(model=\"funded\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "\n",
    "print(\"-------------------Evaluating the \\\"reveal\\\" approach on 35 CVEs:----------------------------------------\")\n",
    "EvaluationOP(model=\"reveal\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "\n",
    "print(\"-------------------Evaluating the \\\"Linevd\\\" approach on 35 CVEs:----------------------------------------\")\n",
    "EvaluationOP(model=\"Linevd\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "\n",
    "print(\"------------------Evaluating the \\\"vuldeepecker\\\" approach on 35 CVEs:-----------------------------------\")\n",
    "EvaluationOP(model=\"vuldeepecker\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "\n",
    "print(\"------------------Evaluating the \\\"ContraFlow\\\" approach on 35 CVEs:-------------------------------------\")\n",
    "EvaluationOP(model=\"ContraFlow\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "\n",
    "print(\"------------------Evaluating the \\\"Liger\\\" approach on 35 CVEs:------------------------------------------\")\n",
    "EvaluationOP(model=\"Liger\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "\n",
    "print(\"------------------Evaluating the \\\"Concoction\\\" approach on 35 CVEs:-------------------------------------\")\n",
    "EvaluationOP(model=\"concoction\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"------------------Evaluating the \\\"LineVul\\\" approach on 35 CVEs:----------------------------------------\")\n",
    "EvaluationOP(model=\"LineVul\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"-------------------Evaluating the \\\"graphCodebert\\\" approach on 35 CVEs:---------------------------------\")\n",
    "EvaluationOP(model=\"graphCodebert\").run()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"Finished\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Full-scale evaluation data\n",
    "We now generate the table using full-scale evaluation data (it would take too long to run the experiment lively). The results correspond to Figure Table 5 (Section 5.3) of the submitted manuscript."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-08T13:43:09.804893200Z",
     "start_time": "2023-05-08T13:43:09.788889500Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output Table 5: The number of vulnerabilities identified Concoction and other methods for 3 open-source projects:\n",
      "\n",
      "Categories                           Approaches       #vuln\n",
      "-----------------------------------  -------------  -------\n",
      "                                     Infer                2\n",
      "                                     CodeQL               3\n",
      "All static analysis tools                                 5\n",
      "                                     KLEE                 2\n",
      "                                     MoKLEE               4\n",
      "Symbolic execution engines                                6\n",
      "Fuzzing tool                         AFL++                8\n",
      "                                     Vuldeepecker         1\n",
      "                                     Funded               2\n",
      "                                     Devign               1\n",
      "                                     ReVeal               2\n",
      "                                     ReGVD                2\n",
      "                                     LineVul              3\n",
      "                                     LineVD               3\n",
      "                                     CodeXGLUE            3\n",
      "                                     GraphcodeBERT        2\n",
      "                                     ContraFlow           3\n",
      "DL based on static code information                      22\n",
      "DL based on dynamic information      LIGER               16\n",
      "                                     Concoction          31\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "We compare Concoction to the baselines on three open-source projects. These projects contain 35 CVEs reported by independent users. This Table demonstrates Concoction’s advantages over other methods in identifying vulnerabilities across the three open-source projects evaluated.\n"
     ]
    }
   ],
   "source": [
    "# Output Table 5: The number of vulnerabilities identified Concoction and other methods for open-source projects in Table 3.\n",
    "print(\"Output Table 5: The number of vulnerabilities identified Concoction and other methods for 3 open-source projects:\\n\")\n",
    "\n",
    "from Evaluation.demo2.table.test import draw\n",
    "draw()\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "print(\"We compare Concoction to the baselines on three open-source projects. These projects contain 35 CVEs reported by independent users. This Table demonstrates Concoction’s advantages over other methods in identifying vulnerabilities across the three open-source projects evaluated.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ablation Study (Section 5.4)\n",
    "\n",
    "we evaluate seven variants of Concoction on the CVE dataset.\n",
    "\n",
    "This demo corresponds to Figure 9 of the submitted manuscript.\n",
    "\n",
    "*approximate runtime = 10 minutes for one benchmark*\n",
    "\n",
    "#### --mode:\n",
    "This parameter defines 7 candidate variants of Concoction. Possible values are:\n",
    "\n",
    "\"nonDynamic\",\"nonStatic\",\"nonCL\",\"nonSel\",\"concoction_MS\",\"concoction_IT\",\"concoction\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-08T13:43:09.822897400Z",
     "start_time": "2023-05-08T13:43:09.805893300Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We conduct an ablation study  on Concoction using the CVE dataset with different variants:\n",
      "\n",
      "nonDynamic (using enhanced AST, Sec 3.2.1):\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the nonDynamic model..\n",
      "Computed data embeddings\n",
      "The evaluation results is:\n",
      "Accuracy: 0.7030  Precision: 0.6870  Recall: 0.6870  F1 Score: 0.6870\n",
      "\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "nonStatic (utilizing randomly sampled symbolic traces with 30 minutes of symbolic execution for each project, Sec.3.2.2)\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the NonStatic model..\n",
      "Computed data embeddings\n",
      "The evaluation results is:\n",
      "Accuracy: 0.7530  Precision: 0.7540  Recall: 0.7920  F1 Score: 0.7725\n",
      "\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "NonCL (without the contrastive learning module, Sec.3.3)\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the nonCL model..\n",
      "Evaluating on the test dataset...\n",
      "The evaluation results is:\n",
      "Accuracy: 0.8430  Precision: 0.8410  Recall: 0.8300  F1 Score: 0.8355\n",
      "\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "NonSel (omitting the path selection module by using randomly sampled symbolic execution traces with static code information, Sec 3.4)\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the nonSel model..\n",
      "Evaluating on the test dataset...\n",
      "The evaluation results is:\n",
      "Accuracy: 0.8150  Precision: 0.7690  Recall: 0.7840  F1 Score: 0.7764\n",
      "\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Concoction-MisSam (introduce mislabeled samples of the training samples into the training dataset of Concoction)\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the concoction_MS model..\n",
      "Evaluating on the test dataset...\n",
      "The evaluation results is:\n",
      "Accuracy: 0.6521  Precision: 0.6353  Recall: 0.7879  F1 Score: 0.6942\n",
      "\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Concoction-IT (randomly remove some symbolic execution traces selected by Concoction)\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the concoction_IT model..\n",
      "Evaluating on the test dataset...\n",
      "The evaluation results is:\n",
      "Accuracy: 0.7830  Precision: 0.7660  Recall: 0.7720  F1 Score: 0.7690\n",
      "\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Conc (representing the complete Concoction implementation).\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "Loading the concoction model..\n",
      "Evaluating on the test dataset...\n",
      "The evaluation results is:\n",
      "Accuracy: 0.8660  Precision: 0.8820  Recall: 0.8410  F1 Score: 0.8610\n",
      "\n",
      "---------------------------------------------------------------------------------------------------------\n",
      "\n",
      "Finished\n"
     ]
    }
   ],
   "source": [
    "#We conduct an ablation study on Concoction using the CVE dataset.\n",
    "# The study includes the following variants:nonDynamic,nonStatic,nonCL,nonSel,concoction_MS,concoction_IT,concoction\n",
    "from Evaluation.ablation.concoction import Concoction\n",
    "conco=Concoction()\n",
    "\n",
    "print(\"We conduct an ablation study  on Concoction using the CVE dataset with different variants:\\n\")\n",
    "\n",
    "print(\"nonDynamic (using enhanced AST, Sec 3.2.1):\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "conco.run(mode=\"nonDynamic\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"nonStatic (utilizing randomly sampled symbolic traces with 30 minutes of symbolic execution for each project, Sec.3.2.2)\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "conco.run(mode=\"nonStatic\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"NonCL (without the contrastive learning module, Sec.3.3)\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "conco.run(mode=\"nonCL\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"NonSel (omitting the path selection module by using randomly sampled symbolic execution traces with static code information, Sec 3.4)\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "conco.run(mode=\"nonSel\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"Concoction-MisSam (introduce mislabeled samples of the training samples into the training dataset of Concoction)\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "conco.run(mode=\"concoction_MS\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"Concoction-IT (randomly remove some symbolic execution traces selected by Concoction)\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "conco.run(mode=\"concoction_IT\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "\n",
    "print(\"Conc (representing the complete Concoction implementation).\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\")\n",
    "conco.run(mode=\"concoction\")\n",
    "print(\"---------------------------------------------------------------------------------------------------------\\n\")\n",
    "print(\"Finished\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Full-scale evaluation data\n",
    "We now generate the figure using full-scale evaluation data (the full-scale evaluation would take too long to run the experiment lively in provided docker). The results correspond to Figure 9 (Section 5.4) of the submitted manuscript.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-08T13:43:09.835900200Z",
     "start_time": "2023-05-08T13:43:09.819896400Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output Figure 9:  Comparing implementation variants of Concoction on the CVE dataset.\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAokAAADmCAYAAAC56h+HAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAxOAAAMTgF/d4wjAAB+fklEQVR4nO2dd3gUVdvG793sbrLpDdJDQglFNBBCEQgEBKS9UgQFITSxoYICgoIilldRAcHC+6mgoYr0Iqi0RHoNhF5CCqRCAull2/n+CDNks7vJtiS7m+d3XbmUOTNnzs6ccs85z3keAWOMgSAIgiAIgiCqIGzoAhAEQRAEQRCWB4lEgiAIgiAIQgMSiQRBEARBEIQGJBIJgiAIgiAIDUgkEgRBEARBEBqQSCQIgiAIgiA0EBlyMmOM/yMIgiAIgiCsB4FAwP/pg14isaysDHl5eSguLiaBSBAEQRAEYaUIBAI4OzvDy8sLUqm05nNrc6ZdVlaGO3fuwN3dHW5ubhCLxWYtLEEQBEEQBFE/yOVyFBQUID8/H8HBwTUKxVpFYnp6OsRiMXx8fMxeUIIgCIIgCKL+ycnJgVwuR2BgoM5zaty4whhDcXEx3NzczF44giAIgiAIomFwc3Or1YywVpHIGKMlZoIgCIIgCBtCLBbXuhm5VpFIEARBEARB2CZGi0SCIAiCIAiicUIikSAIgiAIgtDAZJEok8tRXFZWp38yuVzrvcvLy/Hjjz9iwIAB8PPzg0QigaurKzp27Ih33nkHFy9eNPXnNQpCQkL0dqxZ38THx/OOP6VSKQoKCnSeu2rVKv7ckJAQrefExcXh+eefR0BAACQSCTw8PNC6dWuMHj0aP/zwQ43510Rdt4PqbYB7Z3Z2drhy5UqNzy46Otqo32QO6up5m5PU1NQGf06WCNVp7dRHnTa1T67vd8dha2NyXFwcJk2ahJYtW8LZ2RkODg4ICQnBqFGjsGnTJiiVyoYuYp1jUMSV6sjkcgx7bzbyzNAoGGOQy+UQCAQaG2W83Nyw85vFkFQ5fvbsWYwcORJ3796FWCxGly5dEB0djdLSUly8eBHLly/Hd999h+XLl+Ptt982uXzWSnx8PPr06YOJEyciNja2oYtjEuXl5diyZQtefvllrelr1qyp8fpPP/0UH3/8MQCgbdu26NKlCyQSCW7cuIFt27Zhy5YtiIyMRLdu3Qwql0wux39mzzJLO9CFl5sbdi9eotYGAEClUmHhwoXYvHlznd3bWIx53tHR0fj333+RkpKiU+gbysKFC/HJJ5/gt99+w6RJk8ySp60jk8sxdOa7fJ1mjEGhUEAgEEAk0n/YUCgUYIxBJBJpiB4vNzf8ufRbm6/T9Y1MLseQd2bUeX+0Z9lymx2TS0pKMGnSJGzZsgUA0KpVK/Tv3x8SiQRpaWnYsWMHtm7dik6dOuHs2bMNXNq6xTSRqFAgr6AAo6ZMhlgiMTqfkpIS/LNtO4L9/dGjbx+1zkQuk2HLr79BplDwFfLKlSuIjo5GSUkJJk6ciG+++QZNmjRRy/PYsWN47733cPv2baPL1Vg4ePAg5Dq+DC2F9u3b48aNG1i7dq1WkZiWloYjR46gU6dOOHfunEb6uXPnsHDhQojFYmzatAnDhw9XS8/Ozsa6devg7u5ucNm4dtBh5HDY1YEnAKVcjgvbdqi1AQ6pVIqtW7fiwoUL6NChg9nvbSx1+bzNTUBAAK5duwZHR8eGLorFwNXpgE4doVQokH75Chw93OHTqqVeM1yMMeTcSoKiqAhB7Z+A2N5eLV2lVCLj3Hmq03UA9+6c3FzrZIWIMYa8ggKbHZNVKhWee+45HDp0CGFhYVi1ahV69uypds69e/ewaNGiWicmbAGTRCKHWCKBpFonoC8lxcXYv2Mn/IKC0GtA/1orNWMM48eP55X+b7/9pvW8Hj164PDhw1oFA6FOixYtGroIteLl5YXBgwdj165dSEtLQ7NmzdTS165dC8YYYmJitL7zbdu2gTGGF154QaNzBwBfX1/Mnj3b6PIpFArcuXgJQjs7o/PQhUqphEKh0Jo2bdo0LFmyBB9//DF27txp9nsbS10/b3MiFovRpk2bhi6GRaJUKJBx5Soc3dzg1zpMb4GYdeMmyouL0axDuIZArA2q0+ZBIBBAKDT/tgOVSqX2b1sbk7/77jscOnQIPj4+OHz4sNZAIk2bNsXSpUvx/PPPN0AJ65cG3bhSUlyMPZs2wycgQC+BCAD79u3DhQsXIJVKsXTp0hrPFYlE6Nq1q9qxP/74A9HR0XB3d4dUKkWbNm0wb948rXYkCxcuhEAgQGxsLC5fvozhw4fD09MTjo6O6Nq1K/766y+d975+/TqmTp2K5s2bw8HBAd7e3ujWrRu+/PJLlJWVqZ2bn5+PefPmoU2bNnBwcIC7uzv69OmDTZs26cy/tLQU33zzDbp06QJXV1c4OTmhdevWePXVV3H58mUAwKRJk9CnTx8AwOrVq9UCe1dddqvJ/uXMmTMYNWoUfHx8IJFIEBgYiEmTJuHWrVsa53L2QpMmTcLDhw/x5ptvIiAgAPb29ggLC8OSJUtMcqs0YcIEMMawbt06jbS1a9fyQlIb9+/fBwCNr1tr59VXX0VQUBB27dqFM2fO6H3d/v37MWjQIHh5ecHe3h7NmzfH22+/jaysLI1zY2NjIRAIsHDhQty9excxMTFo2rQpHBwc8NRTT2n9mjb0eXN2gf/++y8AIDQ0VK2+pqamAqhsKz/88AMGDhyIkJAQODg4wMPDA3379sXWrVs18g0JCcEnn3wCAJg8ebJanpz5RW02iWfOnMHYsWMRGBgIe3t7+Pr6onfv3vjuu+/0+m3WCmMM6ZevQOrqarBALCssRHD4UwYLRMB26nRVSktL8eWXX6Jjx45wdnaGs7MzunXrhtWrVxucl6VhS2OyUqnE4sWL+XvVFmmuR48eGsdu3ryJiRMnIjAwEBKJBD4+Phg1apRWcVy17ykvL8f8+fMRGhoKe3t7hISEYP78+ZDJZFrvrY8GMAdmmUk0BmMEIgD8+eefAICBAwfCw8PDoHu+9dZb+PHHHyGRSNCnTx+4ubnh6NGj+PLLL7Ft2zb8+++/WivFuXPn8Oabb6JZs2YYMGAAUlJScPr0aQwdOhT79u3DM888o3b+tm3bMG7cOJSXlyMsLAzDhw9HYWEhrl27hnnz5mHs2LG8vVVWVhZ69+6NW7duwd/fH8OGDUNBQQHi4uIQHx+P48ePY9myZWr55+TkoH///rh06RLc3NzQq1cvODo6IiUlBb/++iv8/f3Rvn179OzZE9nZ2fjnn3/QokULtSnz6tPn2ti4cSNiYmKgUCjQtWtXPPPMM7h8+TJWr16NrVu3Yu/evYiKitK4Lj8/H08//TTy8/MRFRWF/Px8HDlyBLNnz0ZRUREWLlxY+8vSwtChQ+Hh4YG1a9di/vz5/PFTp07h5s2bePPNN3U6fg8KCgIAbN26FR988AGaNm1qVBl0IRKJENopAiITzC50oZDJ8CBJ+xKNRCLBhx9+iNdeew0LFiyosZPkWLx4Md577z0IhUL06tULvr6+OHPmDH744Qds2bIFcXFxWmfW0tLSEBkZCUdHR/Tt2xfZ2dk4cuQIJk6cCKVSicmTJ/PnGvq8nZ2dMXHiRPz999/IycnB888/D2dnZ7V0ADh58iTefvttBAQEICwsDN26dUNWVhaOHDmCuLg4fPbZZ/jwww/560aNGoUDBw4gMTERPXr0QMuWLfm0qv+vix9++AEzZsyASqVChw4dEBUVhby8PFy+fBkzZszA9OnTa83DWlEoFHD0cK9XgQjYTp3muHfvHvr374+LFy/yHxiMMRw/fhyTJk3C2bNn8f333+v5dCwPWxqTL1y4gIyMDAgEAowZM8bgZxEfH4+hQ4eipKQETz75JHr16oXk5GRs3boVu3btwvr16zF69GiN62QyGQYMGIBLly6hd+/eaNeuHY4cOYIvvvgCGRkZGvsJ9NUA5qBBRKKxAhEALly4AACIiIgw6J7bt2/Hjz/+iKZNmyIuLg7t2rUDULkZ4qWXXsL27dvxxhtvYNu2bRrX/vDDD/jqq68wZ84c/hjXKX322WdqFTIpKQnjx4+HXC7Hr7/+qtbJAMC///6r1pBef/113Lp1C88//zzWrVsHBwcHAMDly5fRp08fLF++HH379sVzzz3HXxMTE4NLly5h+PDhWL16NVxdXfm0jIwMZGdnAwCmTp2Kli1b4p9//kHPnj0N2riSnp6Ol19+GUqlEn/88QdeeOEFPu2rr77C+++/j7Fjx+LWrVsawcF37tyJESNGYMOGDfzvOXXqFHr06IHFixdj9uzZagJAXyQSCV544QX89NNPOH36NLp06QLg8YaVmJgYndeOGzcOX375Je7evYuWLVti5MiR6NmzJzp16oSnnnoKdnWwTFxfTJ48GYsWLcLff/+N48ePo3v37jrPPXv2LObOnQupVIq///4bvXr1AlD5BT1jxgz8+OOPGDdunNav3tjYWLz11ltYtmwZ/7y2bNmC0aNH45NPPlGr64Y+b29vb8TGxiI6Oho5OTlYvHix1o0rrVu3xtGjRzW+4G/fvo2+ffti4cKFiImJ4c0RFi9ejIULFyIxMRFTp041aOPK0aNHMWPGDEilUmzevBmDBg3i01QqFfbu3at3XtaIQCAwyAbRHAKRwxbqNMeUKVNw8eJFvPXWW/jmm2/4PjEnJwdDhw7FDz/8gCFDhmDgwIFGP6+GxJbGZO63NG/e3GDb0tLSUowdOxYlJSX45ptv1EwPfv/9d4wbNw5TpkxBjx494O/vr3btiRMn8PTTTyM5OZkvy+3bt9GpUyesWbMGCxYsQPPmzfnz9dUA5qDel5tNEYgAkJubC8DwKf/ly5cDAD766CO+MgKAg4MDVqxYAQcHB+zYsYNf1qpK165d1SojAMyYMQMeHh44fvy42qaPb7/9FmVlZZg+fbpGZQSA3r1787GwU1JSsHv3bkilUr4MHO3bt+dnRKrOJJ49exb79+9HQEAA1q9fr1Y5gEoj/E6dOun5VHSzcuVKlJaWYuTIkWoCEQDmzp2Ljh07IiMjQ+sORGdnZ/z0009qv6dr164YOHAgSkpKTLJJmTBhAoDK5WUAkMvl+OOPPxAWFqaxjFGV5s2bY/fu3QgKCkJRURFWr16NV155BREREfD29sa0adO0LktZA2KxGAsWLAAA/r+6+OGHH6BSqTBt2jR+MAUAOzs7LF68GL6+vkhISMDhw4c1rg0ODsbixYvVBsNRo0ahffv2SEtLQ1paGn+8rp53aGio1iWeFi1a4MMPP4RSqcSuXbsMzlcbX375JVQqFb744gs1gQgAQqEQQ4cONct9LBVtO5K1YaxArG7bVhVbqdOJiYnYs2cPIiIisHz5crU+0cfHBz///DMA4H//+1+Nv9GSsaUx2djfAgCbNm1CdnY2OnXqpGGbOnbsWAwbNgzFxcVYuXKlxrVCoRArV65Um0Bq0aIFxo8fD8YYjhw5wh+vLw3Al81sOemBqQLRWORyOU6cOAEAGD9+vEa6r68vBgwYAMYYjh49qpFefYAAKjux0NBQyOVyvmIBlXYxAPSasThy5AgYYxgwYIDWpQtOEB0/fpzfuLBv3z4AwAsvvFCnuzG5DlXb8wIez9pp63gjIyO1NrLWrVsDADIzM40uV/fu3dGiRQts3LgRcrkce/bsQV5eXo2ziBzPPPMMkpKSsG3bNrz++uuIiIiASCRCfn4+/ve//6FDhw64ceOG0WVrSGJiYhAWFoaDBw/ydn3aqOm9Ojg48B8E2t5r3759Ya9FAISFhQHQfK919bxVKhUOHjyITz/9FG+88QYmT56s5q5Cm72soSiVSsTFxUEgEPDtkNDEWIFYnPdA52YsDluo01x/PWzYMK2bSDgbxdOnT+v8fbaIpY7JplDbmMn1I7o+VqoKZQ5tY2Z9aQCOeltuNpdA9Pb2BvDYiFgf8vLyIJPJ4O7urnMKOTQ0FEDlVG11OFuU6ri4uAAAKioq+GN3794F8LiTqQnuxXP3ro6Hhwfc3NxQUFCAvLw8+Pj4GJS/KdRWNnM9r9mzZ6s1aKDSXnLq1Kk6yzZ+/Hh88skn+Pvvv7FmzRoIBAKdDbM6EokEI0aMwIgRIwBU2k9u3LgR8+bNw7179/DWW2/xnYo1YWdnhwULFmD8+PH46KOPtHZEQP29Vw5zP++MjAw899xzSEhI0HlOUVGR3vnpIjc3F2VlZfDx8WlwlyaWirECsSg3D1k3bkJSi79FW6jT3CzYxx9/zPtX1EZ5ebnONEvHlsZkY34LR33Vw/rSABz1IhLNOYPYoUMHHD16tMZBwhS0la0u3AgYSvVyWUqEFFOf15YtW9SWdDhqEokxMTH45JNPsHz5chw5cgRRUVFGO152d3fH66+/zm8aiouLQ2lpqVX6zBs7diy++OILHDlyBPv379e5iUcf6qodmPq8p06dioSEBAwfPhxz585F69at4erqCjs7O+zbtw/PPvusSTvoq2Mp7czSMEUgZl67Dr/WYXh4O7nW8629TnMRObp3745WrVqZfC9LxJbGZM4vZ3JyMvLz8+vkA9Fcv6e++qY6Vz/mXmLm7ID+/vtvPHz4UK9rvLy8IJFIkJ+fj/z8fK3ncF981Q1KDYX7ItBnyYu7V0pKitb0/Px8FBQUwN7eHp6enmr537x506Rymlo2cz2v1NRUMMbU/mrbYNOiRQt0794dBw8ehEwm02upuTb69u0LoHKZUVcdsXSEQiG/c1yXHVd9vdfaMOZ5l5SUYN++ffDx8cGWLVvQrVs3eHh48PZkSUlJZiuft7c3pFIp7t27ZxGhAy0JUwWif9s2cPby1Osaa6/TgYGBAIDnnnsOsbGxNf5ZK7Y0Jnfo0AEBAQFgjGHjxo0G3ae+6mF9aQCOOhWJdWGDOGDAAISHh6OsrAwzZ86s8VylUonTp09DLBbj6aefBgCtPvbu3buHffv2QSAQ6OUapib69+8PAHr5v4qKioJAIMC+fftw7949jXRuc0b37t35UFhc/ps2bdLwt6gNySOXLLXZ/1SHMwDX9ryqHq9qKF6fTJkyBV5eXvDz89PqUqA6tc0ucQJDIpHwSw7WyKhRoxAeHo6TJ09iz549Guk1vdeKigp+I5Kp79XY511TfS0oKIBKpYKfn5/WnaS6OnVj2oCdnR369OkDlUrFt0PCPALRxdvLoHtac53m+usdO3aYdG9LxpbGZDs7O8yaNQtApZ9EbeNyVY4fP87/f21jJtePmFoPDdUAplJnIrGuNqkIBAKsW7cOTk5OiI2NxeTJkzVs2oBKlyu9e/fGhg0bAID3Z/bZZ5/h6tWr/Hnl5eWYNm0aysrKMGzYMJPjxb7zzjtwcHDA8uXLtQ4uhw8f5mcmQkNDMXToUJSVleHNN99Uszu4evUqPv/8cwCVu7Y4OnfujH79+iE9PR0xMTEa9lcZGRlq0/7cV8u1a9cM+h1Tp06Fo6Mjtm3bprGDefHixTh37hz8/f31Emh1wcsvv4zc3FxkZmbyO9Nq4sMPP9QZEiojIwOvvfYagMovfkkd+DqsLwQCAe88esWKFRrpb731FoRCIVasWKG2Y06lUmHOnDnIzMxEx44dTe7IjH3eNdVXzj7w8uXLamVnjOHLL79UO1YVY9vA+++/D4FAgA8++AD//POPWppKpdIqWGyZhhCIgHXX6a5du6J///44efIkXn/9da2z0kePHrXqumRLYzJXrr59+yInJwdRUVE4duyYxjV5eXl477331FzTvfDCC/D19cW5c+ewZMkStfM3bdqE7du3w8nJqUZTKn0wVAOYSp3YJNb1Lub27dsjPj4eI0aMQGxsLNavX4+uXbsiKCgIpaWluHTpEpKTkyEUCjF27FgAwMiRIzFt2jSsWLECHTt2RN++fXnHnRkZGQgLC8P//d//mVy2Vq1aYc2aNRg/fjwmTJiAL774AuHh4SgqKsLVq1eRmpqKlJQUXtj89NNPuHbtGrZs2YITJ06gZ8+eKCgowKFDhyCTyTBjxgwMGzZM7R5r1qzBM888g61bt+LAgQOIioqCVCpFamoqEhIS8OGHH/I+q0JCQhAeHo6EhARERkbiiSeegFgsRo8ePbS6A+AIDAzEypUrMWHCBLzwwgvo1q0bQkNDceXKFVy8eBHOzs7YuHGjho9ES6WkpATLly/H4sWLERYWhnbt2sHBwQHp6ek4deoU5HI5WrZsqeG43BoZNmwYIiMjtQaej4yMxKJFizBnzhxER0ejd+/evOPhpKQk+Pj4YP369SaXwdjnzfn9GjduHAYMGMDbBH311Vfw8vLC3Llz8cEHH6BPnz6Ijo5GkyZNkJCQgNu3b2PWrFkanTMAPPvss5BKpVi2bBkuX76MwMBACAQCTJkypUb/e1FRUViyZAlmzZqFgQMHomPHjmjTpg3vTDszM9Os9o+WTEMJRA5rrtPr1q3DwIED8dNPP+GPP/5AeHg4fH19kZWVhaSkJGRmZmLGjBkYMmSIyWVsKGxpTLazs8OuXbswceJEbN26FT179kRYWBjat28PsViMO3fu4MyZM1AoFLyvXgBwdHTE77//jqFDh2L27NlYs2YN2rdvj+TkZJw8eRIikQi//fabWcweDNEApmIWkSivEjampKQE/2zbjqb+/ujWu5damql5VyUyMhI3b97EqlWrsHPnTly8eBGnTp2Cg4MDWrRogZkzZ+Lll19W21b+448/IioqCitWrMDx48dRUVGBZs2a4YMPPsCcOXPMZqQ6evRotG3bFt988w0OHTqEbdu2wd3dHS1btsQbb7wBX19f/lw/Pz+cPn0aX3/9NbZt24YdO3bA3t4e3bp1w7Rp0/Diiy9q5M9ds3z5cmzevBmHDh2CQCBAYGAgXnnlFY3ZvW3btmHOnDk4fPgwzp8/D5VKBYVCUaNIBCqNxlu2bIlFixbhyJEjOHfuHJo0aYIJEyZg/vz59ba7yhx8+OGHiIyMxD///IPExEQcOXIEBQUFcHV1RZcuXTBs2DBMmzYNTk5ORt9DWcU3lzkxJt9PP/1UZ4jC9957D+Hh4fj2229x6tQpFBcXIyAgAG+++SbmzZtnlk7M2Oc9fPhwfP/99/j555+xZ88eftfnhx9+CC8vL7z//vsICgrCt99+i5MnT0IikaBLly5YtWoVFAqFVpHo5+eH3bt349NPP8WJEydQXFwMxhh69uxZo0gEgHfffRddu3bF0qVLcfToUVy+fBleXl5o06YNPvjgA5Ofk6WjUirBGEPOrSSUFRUhsP0TENrZQanH0n1x3gNk3bgJv9ZhcHR3U7tG9WhDhyFYa51u2rQpjh8/jl9++QUbN27EhQsX+J3zrVq1wrvvvmtUdI/aYIzV6IvSlHy1YStjMgA4OTnxkXpiY2Nx9OhR/P3331AqlfD19cWIESMwZswYjRje0dHROHfuHP773//i4MGD2Lx5M9zd3TFy5Eh88MEHiIyMNMvvMVQDmIKA1fAprFQqcfPmTYSFhWm1AZLJ5Rj23mzkPZqqZYxBLpdDIBCYtAutOl5ubtj5zWJIzJgnQZgLmVyOITPf5dtBXeDl5oY9S7+lNkDUCzK5HEMf1WmFQgHGmN7OtQHwH6IikUjnzk0vNzf8SXXa7Mjkcgx5Z0bd90fLltO7s3Jq03iAiSIRqKyQMgM3RRiKRCSiykhYNHXdDqgNEPUN1Wnrhd4doQ/6aDyTl5slYjFVFqLRQ+2AsDWoTlsv9O4Ic9HwXqIJgiAIgiAIi4NEIkEQBEEQBKEBiUSCIAiCIAhCAxKJBEEQBEEQhAYkEgmCIAiCIAgNSCQSBEEQBEEQGpBIJAiCIAiCIDQgkUgQBEEQBEFoQCKRIAiCIAiC0IBEIkEQBEEQBKEBiUSCIAiCIAhCAxKJBEEQBEEQhAYmi0SZXI7isrI6/ZPJ5Wr3DAkJgUAggJ2dHa5cuaK1XPHx8RAIBIiOjjb1JxoFV0buz87ODh4eHmjZsiVGjhyJ7777Dg8ePGiQslkaCxcuhEAgQGxsbEMXxWjquh1UbwMc5eXl+PHHHzFgwAD4+flBIpHA1dUVHTt2xDvvvIOLFy/W85OwTrj2aolwfVlISAh/rGrfou+fodR3nbaGfp3D0HaXmppq9HsgiIZEZMrFMrkcz82ehbyCAv4YYwxyuRxCoRAikUnZ83i5uWHX4iWQiMVqx1UqFRYuXIjNmzeb5T51wbPPPgtfX18AQFFREdLT07Fnzx5s374d77//Pr7++mu89dZbDVxKwhRkcjkGzpiOgpISjTS5TAaRSASBUP17jKlUUCgUEEskGtcoFQoAgF2V9uPl5oY/lyxVawNnz57FyJEjcffuXYjFYnTp0gXR0dEoLS3FxYsXsXz5cnz33XdYvnw53n77bXP9XKsjPj4effr0wcSJE636Q6QqEydO1Dh24cIFJCYmokWLFujZs6dJ+cvkcgx99x3kPurblQoFVIxBLBIBegodplJBoVRCZGenUf8BwNvNDX9+u8zq+nVqd0RjwjSRqFAgr6AAz7w0FqIqg11ZSQmO7dkLL18fdIiKMunrSSGT4eCG3yFTKDQ6E6lUiq1bt+LChQvo0KGD0feoS95//32Nr96CggIsX74cn332Gd5++23k5+fjww8/bJgCWgBvvfUWxowZAz8/v4YuilHIFAo8KChA60HPqgk7ALiy7wCCIjvBydND7XjJg4dIPXsOrQf008gv43LlLEpA+ycAVA7QSfsPqrWBK1euIDo6GiUlJZg4cSK++eYbNGnSRC2fY8eO4b333sPt27fN9lttlYMHD0KuY7bWEtEmdhcuXIjExET07NnTZDEsUyiQW1AA79AQCIVCMMaQl5mFirIy+AQHQVStL9ZFSVERctMz4B0YACcXF/64SqVCbkqq1fXr1O6IxoZZbBJFEgnEVf5cPTwQPWI4Ht67j0vHj0MkFqulG/In0jLTwjFt2jQwxvDxxx+b42fUG25ubliwYAHWrFkDAFiwYAGuXr3awKVqOLy9vdGmTRu4ubk1dFFMwk4kgp1YrPYnEAi0HrcTiSrTqh8XiyG0s4PQzk7t3KowxjB+/HiUlJRg0qRJiI2N1RioAKBHjx44fPgwxo4dW1+PwGpp0aIF2rRp09DFsDiEQmFlXRSJ0CQoEA5OTrh35y5UKhVfT2v6c3F3R9PgIORlZKKspORxmpaZRQ5L7dep3RGNkTrbuCJ1ckKvYc8hNysbCfHxYIyZ/R6vvvoqgoKCsGvXLpw5c0bv6/bv349BgwbBy8sL9vb2aN68Od5++21kZWVpnBsbGwuBQICFCxfi7t27iImJQdOmTeHg4ICnnnqKF3rGMHbsWPTq1QuMMSxfvpw/3rZtWwgEAp3CsbCwEM7OznBxcUFxcTGAx7Y6kyZNwsOHD/Hmm28iICAA9vb2CAsLw5IlS7S+g6NHj2L69OkIDw+Hp6cnHBwc0LJlS0yfPh3Z2dka53O2Ndzyyty5cxESEgKpVIr27dtj3bp1/Lnx8fF45pln4ObmBjc3N4waNQrp6ekaedZkk6hQKPDzzz+jV69e8PDwgFQqRYsWLTB+/HgcO3as1mdsi+zbtw8XLlyAVCrF0qVLazxXJBKha9euasf++OMPREdHw93dHVKpFG3atMG8efNQUMVshKPqu7l8+TKGDx8OT09PODo6omvXrvjrr7903vv69euYOnUqmjdvDgcHB3h7e6Nbt2748ssvUVZWpnZufn4+5s2bhzZt2sDBwQHu7u7o06cPNm3apDP/0tJSfPPNN+jSpQtcXV3h5OSE1q1b49VXX8Xly5cBAJMmTUKfPn0AAKtXr1az0Zs0aRKfV002iWfOnMGoUaPg4+MDiUSCwMBATJo0Cbdu3dI419h2aA0IBAJ4B/jD3tER2SmpUOg58+rk6oomQYG4fzcdJYWFtZ5vqf26qe2OIKyROt3dXNdCUSKR8Mu0CxYs0OuaxYsXY8CAAdi3bx+eeuopjBw5EkKhED/88AMiIiJw/fp1rdelpaUhMjISR48eRd++fdGtWzdcuXIFEydOxG+//Wb0b3jxxRcBAIcOHeKPvf766wCAn3/+Wes169evR0lJCV566SU4OzurpeXn5+Ppp5/G1q1b0b17d/Tq1Qt37tzB7Nmz8cknn2jkNXv2bPz0008QiUSIjo7Gs88+C7lcju+//x6dO3fWKhQBQCaToV+/fli1ahUiIyPRs2dP3Lx5EzExMVizZg22bNmC/v37o7S0FAMHDoS3tze2bt2KZ555BuXl5Xo9m9LSUvTv3x+vvfYazp49iy5dumDYsGFo2rQptm7dil9++UWvfGyNP//8EwAwcOBAeHh41HK2OtzS/okTJ9CtWzc899xzKCoqwpdffomuXbsiJydH63Xnzp1D165dcfPmTQwYMABPPvkkTp8+jaFDh+LgwYMa52/btg0dO3bEqlWrIBaLMXz4cHTp0gU5OTmYN2+e2n2ysrLQpUsXfPnllygqKsKwYcPQrVs3HD9+HC+++CLeeecdjfxzcnLQrVs3zJkzBzdv3kSvXr0wZMgQuLq64tdff8WWLVsAAD179sSzzz4LoHK2cOLEifyfPnZ7GzduRPfu3bF161aEhoZi1KhR8PT0xOrVqxEREYEjR45ovc7Qdmgt1IdQtNR+3ZR2RxDWSp27wKlroTh58mSEhobi77//xvHjx2s89+zZs5g7dy6kUini4uIQFxeH33//HTdu3MCbb76J7OxsjBs3Tuu1sbGxeOGFF5CUlISNGzciPj4ef/zxBwCY1OmHh4cDAJKSknibqIkTJ8LR0RFr1qzRKqg4cfTqq69qpO3cuRPt2rVDamoqNm/ejP379+Pff/+FnZ0dFi9ezM88cixYsABZWVk4d+4ctm3bhp07dyI5ORkff/wx0tPTddpKnjhxAhKJBCkpKdiyZQv279+PPXv2AAA++OADvPbaa9i8eTNOnDiBP/74A1evXkV0dDRu3ryJjRs36vVs3nnnHcTHx6N79+5ITk7GP//8g40bN+LEiRPIyMjAK6+8olc+tsaFCxcAABEREQZdt337dvz4449o2rQpzp8/j7///ht//PEHbt++jREjRuDGjRt44403tF77ww8/4OOPP8bVq1exceNGnDp1Ct988w1UKhU+++wztXOTkpIwfvx4yOVy/Prrr7hx4wY2btyIvXv3IiUlBfHx8WqD7Ouvv45bt27h+eefx+3bt/HHH3/g77//xrlz5+Dt7Y3ly5dj165daveIiYnBpUuXMHz4cNy5cwd//vknNm3ahDNnziAtLQ3/+c9/AABTp07F+++/DwC8rR73N3Xq1BqfV3p6Ol5++WUolUr88ccfOHnyJDZs2ICLFy9i0aJFKC4uxtixYzVmRQHD26E1YRahWFRU47mW2K8b2+4IwpqpFz+JdSkUxWIx/7VZ21fnDz/8AJVKhWnTpqFXr178ca7j9vX1RUJCAg4fPqxxbXBwMBYvXgw7Ozv+2KhRo9C+fXukpaUhLS3NqPJ7e3vz/8+5xHF3d8eYMWPw8OFDfkaE48yZMzh//jw6deqETp06aeTn7OyMn376CQ4ODvyxrl27YuDAgSgpKcG5c+fUzh88eDA8PT3VjtnZ2WHhwoUICAjAjh07tJZbKBTip59+gksVY/T+/fujQ4cOyMzMxKBBgzB8+HA+zd7enp8R+vfff3U/kEdkZWXht99+443YuR3iHJ6enujRo0et+dgiubm5AKDVHqomOJOGjz76CO3ateOPOzg4YMWKFXBwcMCOHTuQmpqqcW3Xrl0xZ84ctWMzZsyAh4cHjh8/rrbp49tvv0VZWRmmT5+OyZMna+TVu3dv3v40JSUFu3fvhlQq5cvA0b59e/4jZdmyZfzxs2fPYv/+/QgICMD69evh6uqqln9AQIDWtmEoK1euRGlpKUaOHIkXXnhBLW3u3Lno2LEjMjIytO7CNbQdWhumCsXc9AwwlUrneZbYrxvb7gjCmqk3Z9p1KRRjYmIQFhaGgwcP1ihAuE5i/PjxGmkODg78QKCtM+nbty/s7e01joeFhQEAMjMzjSp71edQ1SaKm9GpvuTM/VvbLCIAREZGau3EWrdurbOcWVlZ+Pnnn/Huu+/i5ZdfxqRJkzBp0iTI5XLk5eVp9efYrFkzPs+qtGjRAgAwYMAAnWn6PKu4uDgoFAoMHDhQQyAShiOXy3HixAkA2uu/r68vBgwYAMYYjh49qpE+aNAgjWNisRihoaGQy+X8AApU2oYBULP508WRI0fAGMOAAQPQtGlTjfQJEyYAAI4fPw7FI9dA+/btAwC88MILcHR0rPUexlJTfwFU9jtVz6uKMe3Q2jBFKHoHBkChVNZ4njX36wRhK5jHkaGecELx8M5dSIiPR0R0tFmci9rZ2WHBggUYP348PvroI62dAfC4wYeGhmpN545nZGRopAUFBWm9hptJq6ioMLjcAJCXl8f/f9UluMjISERGRuLIkSO4fv062rRpg6KiImzcuBHOzs546aWXtOZnaDmXL1+OOXPmQCaT6SxjUVGRxmxjYGCg1nM5G0lt6VyaPs/q7t27AB531sRjuNnn+/fv631NXl4eZDIZ3N3d4e7urvUcc9V/Q95dbW3Sw8MDbm5uKCgoQF5eHnx8fOqtbtRXfzF79mw1kQ1ULo3XthxuCXBCMTcjE9kpqfANDdHLPY6TiwuKq8zeacPS+nVj2h1BWDv1HpavrmYUx44di3bt2uHIkSP8TIaxaBOuNblsMAXOziUsLAziap1r9dnEDRs2oLi4GOPGjdPYsGJMOU+ePIl33nkHDg4O+PXXX5GSkoLy8nIwxsAYw9NPPw0AWt9Rbfcx1/OiCAWacL7jEhIS6iT/+qz/hlC9XJZSN0x9Xlu2bMHq1avV/rTN5tY3SoVCr/7Z2BlFbQ62q2NJ/XpdtzuCsEQapOevC6EoFAqxcOFCALptWPz9/QFU2kFpg7PF4s6rDzgj6b59+2qkjR07Fu7u7lizZg0qKipqXWo2lO3btwMA/vvf/2Ly5MkICQlRW3pJSkoyy32MgfvCv3nzZoOVwVIZOnQoAODvv//Gw4cP9brGy8sLEokE+fn5yM/P13qOueo/9+60uYipTm1tMj8/HwUFBbC3t+dns+urbtRXf5Gamsp/mHF/lhAZRvXIgXZdCsXasKR+3Zh2RxDWToNND9SFUBw1ahTCw8Nx8uRJfqdtVTij5qq+/DgqKip4A/Sqxs91ye+//44jR45AIBBg+vTpGulSqRQTJ05EXl4e5s+fj4SEBERGRpptdx3X0Wlbcjl48GCDLqv06dMHIpEIf//9N+7du9dg5bBEBgwYgPDwcJSVlWHmzJk1nqtUKnH69GmIxWJ+Zlhb/b937x727dsHgUBgcki3/v37A6j0S1gbUY8iMu3bt0/re167di0AoHv37nyYTy7/TZs2ad1ZXB3JI4f8nE2jvtTUX1Q9Xl/9RX0jFolQUVaG3IzMBhWKltKvG9PuCMLaadA1JHMLRYFAwLstWLFihUb6W2+9BaFQiBUrVqj5N1OpVJgzZw4yMzPRsWPHOu/0CwsL8fnnn/NG+Z999hnatm2r9VxuyXnJkiUAzDeLCDw2ov/ll1/UbBJTU1N1ukKpL/z8/DBx4kSUlpbi+eef1xAQDx48aLTOtAUCAdatWwcnJyfExsZi8uTJGjZtAHDq1Cn07t0bGzZsAAD+Q+Szzz5Tc9ReXl6OadOmoaysDMOGDUNISIhJ5eNMGJYvX86LvKocPnyYd9wdGhqKoUOHoqysDG+++aaaDdjVq1fx+eefA6jcSc3RuXNn9OvXD+np6YiJiUFRNXcqGRkZakuC3AzStWvXDPodU6dOhaOjI7Zt26axg3nx4sU4d+4c/P39MXr0aIPytRoEAvg0C0ZFaWmDCkVL6deNbXcEYc3U68YVbZh7M8uwYcMQGRmJs2fPaqRFRkZi0aJFmDNnDqKjo9G7d2/4+vrizJkzSEpKgo+PD9avX2/Kz9Fg0aJF/NJRcXEx0tPTcf78echkMt5zf01B4Fu3bo0+ffogLi4OLi4uZg31NHnyZCxduhR79uxBq1at0LVrVxQVFSE+Pp7fnVmbj7K6ZNmyZbhx4waOHj2K0NBQREVFwcPDA2lpaTh//jxefPHFRusGp3379oiPj8eIESMQGxuL9evXo2vXrggKCkJpaSkuXbqE5ORkCIVCvs6MHDkS06ZNw4oVK9CxY0f07dsXbm5uOHr0KDIyMhAWFob/+7//M7lsrVq1wpo1azB+/HhMmDABX3zxBcLDw1FUVISrV68iNTUVKSkpvBucn376CdeuXcOWLVtw4sQJ9OzZEwUFBTh06BBkMhlmzJiBYcOGqd1jzZo1eOaZZ7B161YcOHAAUVFRkEqlSE1NRUJCAj788EN+xj0kJATh4eH8TPwTTzwBsViMHj16aHXRwxEYGIiVK1diwoQJeOGFF9CtWzeEhobiypUruHjxIpydnbFx40ZIpVKTn5mlIhKL4RsaguyUVORmZMI7wL/W/tnYzSw1YSn9ujHtrjrdunXTmf+7777LB1ggCEvALCJRUcPOWL0KIRbj6UEDcWzPXpw5eBAdHi1BGZv3p59+isGDB2tNe++99xAeHo5vv/0Wp06dQnFxMQICAvDmm29i3rx5ZrdH/OeffwBU2ta4uLjAy8sLQ4YMQXR0NGJiYvTy3N+vXz/ExcXVuGHFGDw9PXHmzBl88MEHiIuLw65duxAcHIxZs2bhww8/xMCBA812L2NwdnbGwYMH8fPPP2PdunU4duwYlEolP3vz2muvNWj5qqPUspzJGINSoYCy2owKtymg+nEAUD1yDcKlacsXqBwcb968iVWrVmHnzp24ePEiTp06BQcHB7Ro0QIzZ87Eyy+/rOYT8ccff0RUVBRWrFiB48ePo6KiAs2aNcMHH3yAOXPm6Nz5bCijR49G27Zt8c033+DQoUPYtm0b3N3d0bJlS7zxxhtqbo38/Pxw+vRpfP3119i2bRt27NgBe3t7dOvWDdOmTdM6aHLXLF++HJs3b8ahQ4cgEAgQGBiIV155RWN2b9u2bZgzZw4OHz6M8+fPQ6VSQaFQ1CgSgUq74JYtW2LRokU4cuQIzp07hyZNmmDChAmYP3++ze++V6lUEAqFaBochJy0O7h/Nx1e/n56fch7+vogLzMLWckp8GkWrCYUVTX4SNSFpfTrxrS7qpw6dUpn3tpCCBJEQyJgNawhKJVK3Lx5E2FhYWrORjlkcjmemz0LeVpivhoDYwxyuRxCoZC3PwIALzc37Fq8BBITv0atlYiICJw/fx4JCQno2LFjQxeHqIZMLsfAGdNRUFKikSaXySASiTR2crJHIkX8yF6uKpwotKvWBv5csrTRtgGifpHJ5Rj67jvIrdq3Mwa5QgGhQKBWN2tDqVBAxRjEIhFQRVx6u7nhz2+XUZ0miAaiNo0HmCgSgcrORGagQbihSESiRtuR/Pnnn/jPf/6DqKgonX7CiIanrttBY24DRMNAdZogbBt9NJ7Jy80SsZgaeh0wdepUFBQU4M8//4RAIMB///vfhi4SUQPUDghbg+o0QRANvnGF0M6qVatgZ2eHli1b4uOPP0ZUVFRDF4kgCIIgiEYEiUQLxZyxrQmCIAiCIAyl4WNtEQRBEARBEBYHiUSCIAiCIAhCAxKJBEEQBEEQhAY1ikRTIp8QBEEQBEEQlk1NWq9WkSgQCCA3U6B2giAIgiAIouGRy+W8ztNFrSLR2dkZBWaKqEIQBEEQBEE0PAUFBXB2dq5RJNbqAsfLywt37twBALi5uUFMzlUJgiAIgiCsErlcjoKCAuTn5yM4OLjGc2sMy8dRVlaGvLw8FBcXk/8+giAIgiAIK4VbJfby8oJUKq35XH1EIgdjjP+zBjw9PeHt7d3QxSAIgiAIgqg3cnNz8eDBA43jnA2ivhuTDYq4YkjGloCLiwtu377d0MUgCIIgCIKoNwIDA2FnZ2dyPuQnkSAIgiAIgtCARCJBEARBEAShAYlEgiAIgiAIQgOziMS9e/eiX79+8PT0hJOTEyIiIvD9999DpVIZnFdBQQEWLFiA9u3bw9HREe7u7ujVqxd+//13cxSVIAiCIAiC0AODdjdrY9GiRfjggw8AAM2bN4ezszMuX74MlUqF5557Dtu3b4dQqJ8WzcjIQJ8+fXDr1i3Y2dmhffv2kMvluHbtGhhjeP311/G///1P77IFBgYiPT3dqN9FEARBEARhjZhL/5g0k3jixAnMmzcPQqEQGzZswO3bt5GYmIiEhAT4+Phg165dWLp0qd75xcTE4NatW3jiiSeQlJSECxcu4MqVKzh//jz8/f3xf//3f1i7dq0pRSYIgiAIgiD0wCSR+Pnnn4MxhqlTp2Ls2LH88fDwcF4cLlq0SK/Yz4mJiYiLiwMArFy5EiEhIVrzW7hwoSlFJgiCIAiCIPTAaJFYWFiIAwcOAABefvlljfTRo0fD1dUVeXl5vPiriWPHjgGonCLt1q2bRvqIESMgFAqRnJyMc+fOGVtsgiAIgiAIQg+MFonnz5+HTCaDg4MDIiIiNNLFYjE6d+4MADh16lSt+T18+BAAEBAQoDVdIpHw0VNOnjxpbLEJgiAIgiAIPTBaJN66dQsAEBwcDJFIe+CW5s2bq51bE25ubgAqN69oQyaTITc3FwBw48YNg8tLEARBEARB6I/RIpGb+fPw8NB5DpfGnVsT3Kxjeno6Tp8+rZG+Y8cO3qWOPvkRBEEQBEEQxmO0SCwvLwdQuQysC3t7ewBAWVlZrfl17doVnTp1AgBMmjQJN2/e5NNOnTqFd999l/+3rvyWLl2KwMBA/q+wsBA5OTkoKyvDlStXAACXLl2CTCZDVlYWMjMzIZfLkZiYCAC4du0aSktLcf/+fdy5cweMMSQkJAAAbt68icLCQjx48ADJyckAwNtGJicn48GDBygsLOTLnZCQAMYY7ty5g/v376O0tBTXrl0DULlJRy6XIzMzE1lZWZDJZLh06RIA4MqVKygrK0NOTg7u3r0LpVKJ8+fPA6icQS0qKkJeXh5SUlLUynD79m3k5+ejoKAASUlJamlpaWnIzc1FSUkJrl+/zpdBoVAgIyMD2dnZqKiowOXLlwEAly9fRkVFBbKzs5GRkQGFQsE/o+vXr6OkpAS5ublIS0tTu09SUhIKCgqQn5/Px8zm0lJSUpCXl4eioiJ+Jvj8+fNQKpW4e/cuvSd6T/Se6D3Re6L3RO/JTO/JXBjtJ/Gbb77BnDlz0LVrV502gnPnzsXXX3+NoUOHYvfu3bXmeePGDURHRyM7OxtCoRAtW7aETCZDamoq3N3dERUVhd27d2PixImIjY2tNT/yk0gQBEEQRGOjwf0k6rOUrM+SdFVat26N8+fPY8aMGQgJCUFqaipKSkowbtw4JCQkwNXVFQDg6+trbLEJgiAIgiAIPdC+40QPWrVqBQC4c+cOFAqF1s0r3HQqd64++Pr6YtmyZVi2bJlG2tmzZwGAX5YmCIIwFZlcDplCYfB1EpEIErG4DkpEEARhGRgtEjt27AixWIzy8nIkJCSgS5cuaulyuRxnzpwBUGlvaCpXrlzBjRs34ODggH79+pmcH0EQhEwux5B3ZiCvoMDga73c3LBn2XISigRB2CxGi0RXV1f069cPf/31F1atWqUhEjdv3ozCwkJ4eXkhOjrapEIyxvj40OPGjdN7+ZogCKImZAoF8goK4OTmCoFAoPd1jDHkFRRAplCQSCQIwmYxKSzf/PnzIRAIsHLlSvz+++/88cTERMycORMAMGfOHLUd0MuWLUNISAjGjBmjkd/Ro0dx8OBBVN1Lk5eXh8mTJ2P37t3w8fHBokWLTCkyQRCEBgKBAEKhUO8/QwQlQRCEtWKSSOzRowc+++wzqFQqvPTSS2jRogXCw8MRERGBnJwcDBkyBLNmzVK7Jj8/H2lpacjOztbI7+zZs+jXrx/c3NwQHh6Op556Cr6+vli9ejUCAgJw4MABPuoKQRAEQRAEUXcYvdzMMX/+fISHh+Pbb7/FuXPnkJ2djSeffBKTJ0/GW2+9BTs7O73zio6OxoQJE3DixAncvn0bAoEA7dq1w8iRI/Huu+/yu5sJwlBocwJBEARBGIbRfhKtAfKTSAC0OYHQTXFZGXq9MhXO7m4QCvVfWFGpVCjOL8DhX1bCWSqtwxISBGGJWPrEg7n0j8kziQRh6dDmBIIgCMJcNKaJBxKJRKOB25ygL1yscIIgCILgaEwTDyQSCYIgCIIgDKQxTDyQSCQsHmNsP2jDCUEQBEGYBolEwqKRyeV49u23kJufD7FIBOg5te/h4oK/ln9HQtHGoQ8Ioi6x9M0JBFHXkEgkLBqZQoGCkhJInJ0hKy+HT3AQRLV0viqVCrkpqVZl90EYjkwuR/83p6GwpAQCfZd8GIOLkxP2//Aj1Q2iRhrT5oTGBn1c6g+JRMIq8A7wx4PsHNy7cxe+oSG1CkXC9pEpFCgsKUG5QgHvwAA4ubjUeo1KpUJucgp9QBC10pg2JzQmZHI5hr77DnL1EP9MpYJCqYTIzg5NPDzw57fLGt07JZFIWAUCgQDeAf7IzchEdkoqCUUCACAQCuEdGIC8jEwIgwLhpI/DfQqp1ygw12xRY9ic0JiQKRTIzc+Hd/NQvd5rSVERctMzcP/hw0Yp/EkkElYDCUVCG04uLhAGBeL+3XRAX6FI2DTcUnF2Xh6EAgHsRPoNdV5ubtjTCGeLGhtyhQIqpVKv8cPF3R0AkJ+RWcelskxIJBJWBQlFQhtOrq4ACUXiETKFAnmFhWgSGoL7d9MhdnCAl79fjcvGZMvceBAKBMhJuwO/5qF6jR9OLi4oNiDEsC2h/xw6QVgInFC0d3REdkoqFHJ5QxeJsACcXF3R5JFQLCksbOjiEBaAxN4efs1DISsvx4PsHAiEQgjt7LT/GbCkTFg3diIR7KVSg8YPvTfH2RiN81cT9YJMLkdxWZnBfzI9Gi0JRUIbJBSJ6ojEYviGhqCitBS5GZlgjDV0kQgLwMvfj8YPPaDlZqJOkMnlGDrzXd59hEKhAGMMIpGo1p2CXm5u+HPpt7Uu+dDSM6ENWnomqsMJxeyUVORmZMI7wN+gHcuE7UHjh36QSCTqBM59hH9EB9xPToGiqAhB7Z+A2N6+xutUSiUyzp3X2y5IW0OnZSOChCJRHRKKRHVIKNYOjaZEnXI/OQXlxcVo1iEcDk5OsBOJavwT2tkZ7EKClp4JbdDSM1EdWnomqkPjR82QSCTqDIVCgbKiIgSHP1XrDCJHcd4DKIwIg1W1oeek3QGo8ydAQpHQhIQiUR0Sirqh5WaizmCM6bXEzFGUm4esGzchqebTTPnInrE2uIZ+/246KoqKjCozYXtUXXr2CvBv6OJYJI0tRrG2pWeicUNLz9ohkUjUGSKRyCCBmHntOvxah+Hh7WS1NBVjyMvMQpOgwFptiAQCAbz8/ZB9s9jochNWhJ6zQJxQvHfnLhz0dKzcWJDJ5fjP7FlGxyjevXiJTQhFT1+fhi4S0cCQUNSEekuiztDXKJwTiP5t28DR3U1DJIpFIlSUleltbC4wIMICYd3IFQoo5HJI9HB06+TqCu/AAIuJnGAps3fcJrMOI4fDzoB8lXI5LmzbYdXOp6sKxbzMrIYuDmEB0GZIdWgkJbRirrintVFVILp4e0Gp7Z4CAXyCg3Dvzl3alUioYa2RE2RyOYa9N7vW2TuVUgm5QgHxo01dQOXs3c5vFptdmNmJxRBJJGbN0xjMJZ6ZnhvgOKGYlZwCoVJp8H0J26O6UGwaHNTQRWowSCQSGsjkcgydNRN5BQWQy2SVvg2rfUkxlQoKhQLiKoOKl5sb/lyyVO/Bq7pArAlyX0Fow04kgtjBwaClIUuInMDN3o2aMlmtDVXlTnIKjuzfj76DBiG4eSgAQC6TYcuvv1n17F1NVPevyqGPn9Xq/lUVSiVKior42Ls1IRKL4dMsGDnVVjEIy6I+Z9+rCsWctDuwvdamHyQSCQ24Aaxl/2dw/VA8giI7wcnTQ+2ckgcPkXr2HFoP6AegcnNJ0v6Deg9ehghEDhKKhDa8/P3wIDvHKm2IxBIJJFrsdtOSbuPogQPoO3gwmrVs0QAlaxi4viegU0cI7ezAGEPOraRa/axq868qsrNDbnoGhEKhXn4yRWIxxGSmooHFmEVU+YBQPZqkEIlEei0FV/+AoM2Q+kMtgtCJ3aOvdjuRSMNWiU8zohMwRiBykFC0Dcw58NiasXla0m3E/fUX+gwaZHUC0VxmKlw85awbN3k/q/puguMQCIXwDgwwzKE69SVqmHNTk6l1g/uAcAsNQc6tJPi1bQNnL89a81AplUg/m6D2AUGbIfWHRCJRr5giEDlIKDYsJnf21ZYUGWNQKBQQCAQQ1TKToytko60IRWsXiJyZSlU4O2Ntm8nkMhl8vL2xp9o7ZYwh68ZNlBUWGuRntTpOLi4QUuQdozHXpqbqdUObuRJ/bZX6Ut2ESaVSIedWEgLatdV7/JBXVGj43qXNkPrTOH810SCYQyBykFBsGGRyOQbOmI4HBQU6B31tNqyerq68EKi6pKhUKJB++QocPdzh06plje+wtpCN1i4UrVkgAupmKlXrRsblKwCAgPZPaFxz5Z/9yMvP13inObeSUF5cbJBA1BWpiUI0mo6pm5qq143q5kpV4eqLb5vWGiZMCoUCfgaMH/KKCqRfvqLZr9BmSL0hkUjUC+YUiBwkFOsfmUKBBwUFcG0WjMCnntRIv7LvgIYNq1KhwK1/9msIAaVCgYwrV+Ho5ga/1mFmeXfWKhStXSBWpbp5CrcrW+tMlJZ3rlAooCgqMmiJubZITSQULQOubtRkrsTXFy0foSKRSK8lZqBSIN5JvAipiwvkSs3lcho/9INEoo1hKUbGVakLgchBkRP0x6x2gEKh1g5elw1rdRhjlTOIBghEblm6NqxNKNqSQDQH5orUVB0SitaPvv4KeYHo6oqmLZoj/cw5reeRUKwdEok2hEwux4Dpb+OBEUbGnm5u2Pfd92YXisV5D5B985ZBAtHQWKoUOaF2LK1uKBQKOHq4GyQQc24l6V03rEUo3klOwdEDBxpcIMpkMpzZut0g90BMpYJCJjN7WcwVqUkbJBQNx5Lqhj5UFYh+rcOgqsX3JQnFmiGRaEPIFAoUlpSgbb9nDDKyVSoUuBX/r9l9r6lUKmTduGmykbE+UOSEmrG0uiEQCGq1QeTgNzEUFdW6saX6PSw5coJKqaz0g2gBbm5EIhHa9IoyeHPC9QMHzV4Wc0Vq0gUJRcOwpLpRG9UFor51iYSibkgk2hhCoRDufr4GGRkrZLI6GTzNZWRMkRPMgyXVjZqcIlel6i7XwPZPIDvxkkH3seTICXKFAn0tZIlZKBTCpYm3RdQNfdArUlMNkFDUH2upG8YKRA4SitqxnM9qwuYw1si4+mwRFzlBr3s+ipygMnDJmrA8zOUGhROK9o6OyEm7A1hI3RCLRHwkFUJ/zGXj7OTqiiaPhGJJYaEZS0jUN6YKRA5OKFaUliI3I9Ng0ydbhEQiUWcYY2Ts06qlRjoXOUHfjpwiJ1g/+gpEQyMn2EulkBthzlAXCC0ghrS1Ye5NcGpCsZFG1LB2zCUQOUgoqkMikWhQ9GngVSMn6P3FT8sEVoshM4hc5AR9haKXvx+EVDesEoMFop6DOycUc9Mz9DZtISwDcwtEDhKKjzGLSNy7dy/69esHT09PODk5ISIiAt9//71O56a6EAgEev2tXr3aHMUmGhhDGriTiwstDTUCDF1irho5QV+h2FgjJ1gzxswgyhUKKORyvc51cnWFd2AAFGTLbDXUlUDkqCoUG/NmSJN7y0WLFuGDDz4AADRv3hzOzs5ITEzE9OnTceDAAWzfvl3vZccePXroTHv48CGuXr0KAOjWrZupxSYaGGMaOBmb2zZG2SBS5ASbx9glZqFAgJy0O/BrHqqX+yMnFxcUkwmAVWCqQKTNkPpj0kziiRMnMG/ePAiFQmzYsAG3b99GYmIiEhIS4OPjg127dmHp0qV653f06FGdfyNGjAAAdOnSBa1btzal2EQDY0oDJ2Nz28SUTSq0NGS7mGKDaCcSwV4qRXZKqt4ziob4AiQaBnPMINJmSP0xqUV8/vnnYIxh6tSpGDt2LH88PDycF4eLFi2CXM8GqgvGGNavXw8AiImJMSkvomExRwMnoWhbmGMXMwlF28Mcm1S8/P1g7+hokFAkLBcuUpMh44e2SE20GVJ/jBaJhYWFOHDgAADg5Zdf1kgfPXo0XF1dkZeXh7i4OONLCODIkSNITU2FWCzGmDFjTMqLaDjMaUNCQtE2MJebG4CEoi1RnPfAYIGo7X1XdX9EQtH6USgUkLq4mBypiTZD6o/RIvH8+fOQyWRwcHBARESERrpYLEbnzp0BAKdOnTK+hADWrVsHABg4cCC8vb1NyotoGOrCyJiEonVjToHIQULR+uEiNRm0SaWGSE0kFG0Hc0Zqos2Q+mG0SLx16xYAIDg4WGeorObNm6udawwVFRXYvHkzANtfapbJ5SguKzPoT2YFHV5d7kIjoWi95NxKMlgg6uMxgYSidaNQKODXOszkSE1VIaFoGxgbqUnXNTR+1I7Ri+wPHz4EAHh4eOg8h0vjzjWG3bt3Iz8/H25ubvjPf/5jdD6Wjkwux3OzZyGvoEDvaxhjcHF0wj/ffcfH1VUoFEg5l2CQo16VUmlUvGR9kFdUIOPK1TpzUwBo7nqWOjmZ/R62gCXVDYVCAUVREZp1CNdbIBbnPdC7LBRiyzAsqW4YG6lJrqy579QWy1ufXc+NHUuqG/pQfYWitnKT14yaMXomsby8HAAgqSGeo/2jzr+srMzY2/BLzaNHj4aDg0ON5y5duhSBgYH8X2FhIXJyclBWVoYrV64AAC5dugSZTIasrCxkZmZCLpcjMTERAHDt2jWUlpbi/v37uHPnDhhjSEhIAADcvHkThYWFePDgAZKTKwPJnzt3DgCQnJyMBw8eoLCwEDdv3gQAJCQkgDGGO3fu4P79+ygtLcW1a9cAAImJiZDL5cjMzERWVhZkMhkuJCYir6AAvV58AQMmTkC/CTHoFzMeAyZNRN9xL+HZSRPxzPhx6D9xAvpPiMEzMePRb9xLKCgugkyhwO3bt1GQnw8wxs+2KB9t2VepVGCMgamlqR6lMX6m5dojF0PXrl4FGHt0DgMD+M1HikcRLlSsMg1V0lQqFQoLCpCfn4+U5GQwxnD34mVIXV3RtGULMKZuRMxdp1SqHpWx8phCocDVK1cgk8mQk50N9qj8fBnkj8qgVFX+RgZIpNJHX4R3UVJQCMYYUlNSAAAXzp+vvI9CWXkflbYyKPnnpJbGGLKzsvj3dOlSZezgK1euoKysDDk5Obh79y6USiXOP7rPjRs3UFRUhLy8PKQ8KgNXV27fvo38/HwUFBQgKSlJLS0tLQ25ubkoKSnB9evX+bqiUCiQkZGB7OxsVFRU4PLlywCAy5cvo6KiAtnZ2cjIyIBCoeDr8vXr11FSUoLc3FykpaXx70d3fdBdV1QqFVRKJe7evYv79+6BVak/crkCjFX+m8uDe358XVGpoHqUJ9eelCoVAp9oBzuxhPdNx79fpZKvlwpFZdrD7Bxk3bgJoZ0dcnNzUVpaihs3bvDXMcagVCqhVCr5uiISi9EkKBAVpSW4n55eWS7GoHp0vxs3bqC4qIi/Vq0+6FlXuPZu6Hu6/KgeVX1GmmVQgKkYmEoF5aPnIJPJIJfLkZaairy8PBQVFfHP4fz581A+ek+G9Hvc9frWh6ppYAxFVfo97tlWfUbcdZXvCY/ek4rvDwDg+rVrKCsrw/1798Ch0eeo1N+TvKICaRcS4eDqiiYtW/D34doTU6k03qFCoYC3vx8kUgdkJadA/uh58vdjDPdycpCRkQGlQqFWp3W9J8Wj96Sq8p64c1JSUsz2nhpifMrJzn70Xo3rO7i+lxsPVFXeBffutfW9le248h3ey8lBRUUFPz7JFZV9TuW7eNwPce8k68ZNlBYUIrB9e4jt7fn3lHz7NgoKClCQn/+4Tsoq0xwcHeEdUGmjWPRoUourD0qlsrJeM4brj57R1StXNMYgzfqqo64whocP60ZHVB2fzIXRM4mcYJPJZDrPqaioAABIpVKj7pGXl4e9e/cCACZMmFDr+TNnzsTMmTP5fwcGBsLHxwcA8MQTTwAAnnzySQCAn58ff154eDgAoG3btgAAR0dHPo2ztwwLC+OPeXpWfuV26tQJwONldQBwffQVwl0XHBzMp3H5c/fz9/fn09o9Kp9UKoW4mvDmhHj143KZDHaPvpJatGiB4rIyiMRitOgcaXAw9oe3k9G2XbvKcrZrBwgEsLMTAhBAgEobUwC8aYFQUJmGR2lKuRxCoRCubm5wlkohsreHQqGAYxNvjRlELg8uz8r7VHYaeSmpYIyh3RNPQCKRwMfXl3eizu0uE4kr/yuwe5ynWCyuzC+o0meeg0iEkNDKuLgdOnasvI/IjvfZKRJWL8Pjr82q5asQCODr5wfnR3WYqz9PVHlfHB0f3aeqiyYvr8olM66utGjRgk9zc3NTS2vWrBmf1qZNGwCP60pAQACf1r59e7X/+vr68mnc+dz1Tk5O8Pb2RnFZGSQSCUI7RRhcNx4k3YbQzg5BQUEoLiuDAI/fmfjRu+D+DTx+fnxdEQohfPQOIyIiKssiFkPs4AChUAAh7B7l9aiOqb0LOxTl5uHerST4tQ7Dw9vJ8Pb2hqNUyj9nsVhc6SS7ynVcXvZSKXxDQ5GdkoqH2Tnw9PXhZxZat25d+XuqXMvXB1GVMmipKyqVCgKBgO8XDH1P7R/VI275rGr7eFwGrnsWwE5Y2T5OHzkKxhiahYTwdZJ7Dlz9CwoK4vPSp99r3bo1RCIRmkd2Mrhu5CenwMXVFX4+PiguK+OfbdV3wbU5bW2N+91t2raFVCpFk6ZNNc7n6lHlqY+uValwJ/EiHN3c4Nc6DCqlkr+uU6dOle9VKIRQKIRAKNB4h00CA5GbkYmc1DT4hoY8ThMI0NTHB85SKYrLyviyPi6D5nvi0yAAhJXihbsuNPRxbG5D3pOXtzdkCgUqFAq0CAtDcVkZgkJCoAIgdXaG1NkZJeXlCGvbFsVlZfB/lJezVGrW8am4rAwikQgtuhg+puQnp/B9b2jz5hAIBBAKK53ZV1R5ltr6Xjs7OwgElRtMmvr4wN7enh+fxCJRZZrgcZ8jFovAGMP928koKyxEsw6PTVi499S8RQs4S6Wwk0ge1zHJ47bm7O4GgVCA+3fTIbSz42cU7ezsoAIAgQBtHj2jdk9ULmEL7YQ11FftdUUgEMDDw5Nvv+bUEdXHJ3NgtEjUZylZnyXpmvjjjz8gl8sREhKCnj17GpUH0XCYy8iYi5wg0WO5g4uckJ+RaXS5LRGZXA6Zgcs3EpGIN0OwNPRd+q3qBsXR3Q0PbycbfK+qS8/WGjmBMYbD+/bjXmYmP+Bw2FrdqA1z2DhrW3rWN+hDXSOTyzHsvdl6mR6plErIFQqIRSII7ezg5eaGnd8s5t9tY6kb5toER0vPmhgtElu1agUAuHPnDhQKhdbNK9x0KneuoXBLzePHjyd7IivEWCPj7MRLaumNPXKCMfaqAODl5oZdi5dYXYfPUd1PnlLLYNcYIidwAjEnIwPPjhyBXWvX8WnG1g13FxfsWfqt1dUNc26Cqy4UmwYH1X5RPSBTKJBXUIBRUyZrrB5V5U5yCo7s34++gwYhuHko5DIZtvz6G2QKBSRiscF1gzPT8PbwwF/LlltN3TC3lwQSiuoYLRI7duwIsViM8vJyJCQkoEuXLmrpcrkcZ86cAQB07drV4Pxv376NEydOAKgUiYRtoo+RsZ1IBLGDg0HG5rYUOYEbNJ55aazeSz4KmQwHN/zODxjWhr6OlLnICS7u7rXmyUVOyDFiNrKhqCoQh7wwWnMWsRHVjbrwklBVKOak3YElPQ2xRAKJDsGTlnQbRw8cQN/Bg9GsZQut5xhTN4ry8xG/abPV1I26cKMF0GbIqhg9krq6uqJfv34AgFWrVmmkb968GYWFhfDy8kJ0dLTB+a9duxYAheGzZQxp4BQ5ARBJJBDr+WeI/ZClYUikDVuOnFBdIDo5O+s819brhjECUflok0Bt8O5xpFLIG2hHriGkJd1G3F9/oc+gQToFYlUMqRsu7u4aHyKWSl0JRA419zh6hvCzRUyabpk/fz4EAgFWrlyJ33//nT+emJjIbyCZM2eO2g7oZcuWISQkpNbIKRSGz7YxtIGTn7PGgaGh2Gw1coIhAtHWMXYGUcUY8jKz9BaKXv5+EFp43TBUIBqDNZh2mSwQ9fSdygnF3PQMvU1bbA2TRGKPHj3w2WefQaVS4aWXXkKLFi0QHh6OiIgI5OTkYMiQIZg1a5baNfn5+UhLS0P2o6312jhx4gSSkpIoDJ+NYmwDJ6Fo2xgbq9fWIieQQHyMKUvMYpEIFWVlejtUFwgEVXaUWx71IRCtAXPMIHKbIfWB2wypsDJbZnNhsuHW/PnzsXv3bvTt2xd5eXlISkrCk08+iWXLlmHnzp1q29v1hVtqpjB8toepDZyEom1irEDksJXICSQQH2OyDaJAAJ9mwTYReYcE4mPMEamJ2wypt1B0cVFzzdWYMIt1/9ChQ3Hw4EHk5+ejpKQEFy5cwIwZM7QKxIULF4Ixhvj4eJ35rVixAowx7Nq1yxzFIywEc9mQkFC0LUwViBzWLhRJID7GXJtUbCFEIwnExygUCpQVFRk0fmiL1GQnEsFeKjVo/LClzZCG0Dh/NVHvmNvImISibWAugchhrUKRBOJjGGNIv3zFIIFYNVpHdaxZKJJAVIcxhsD2T+g9fhTl5iHrxk2tLvpoM6R+kEg0AzK5HMVlZQb/yapVTGvqvAyhrnahkVC0borzHhgsEPVpI9YmFEkgqqNQKCB1cTFIIObcSqqxblijULyTnEICsRoikcgggZh57Tr8WodpdZRO44d+WK6VrpWgyzt+dU/42qjuHV8ul6OspKRGB6q1oVKpUHQ/F3YGuDFQyuUaNhvmoq7dFFhy5ARLw5LqhkqlQtaNmwho11ZvgSivqNA5W1Qda3GIaykC0ZLqhrkiNVWnauSd3IxMeAf4W+xOXpVSWekouwY/iPVWFgurG/qgb6QmbeOHPn54GxMkEk1Em3f86p7wtVHdOz5QGeP02J69iB4x3GjnnQqFAtcPHzHIfoKpVHoPvoaScysJ5cXFJhkZ14alRk4wJ+bocC2pbigUCvgZMIMor6hA+uUrBg3q1iAUjx2KQ252doPPIFpS3TBXpCateVuJUJQrFOhrITOIllQ39EGfSE1VIaFYMyQSzQTnHV8fT/i6EIlE8PL1weGdu9Br2HNGCUWJRIJOz48wOBj7uT82G3yvWvNVKKAoKkKzDuEmGRnrgyVHTjAHcoUCWalpCA4zLsQlYFl1QyQSwdnLU69z+U0MLi6QKw0LP2fJkRPkcjnuZWbiP2NebPAlZkuqG/qgT6QmXViDUBSLRDonGOoba6obxto4k1DUDa3LmRFzGBl3iIqCt58vDu/chbKSEjOXsH4xl5GxrUZOMASxSISE+HhkpqQ2dFHMgr4mAVV3ufq0amnUvSw1cgJjDM+OHGGyQFTo2T5sBXOYsFi6jaIhopeoxNRNcGSjqB0SiWbCXEbGAoEAEdHRNiEUzWVkbM2RE8y1qUkoFCIiOhpnDhywGaFYG3q5QbHiyAlisRhOZpjZVKlUuHDkiMUJnbrAnDbOli4UzYEt/iZtmMtLAglFTWi52QyY28iYE4oJ8fEmLT03NOYyMq4aOUGfpSFLiZwgk8sx+J0ZKCwtNfja6puaAMAvpBlE4n44c+AAOvfrB//QEDOW1rLQ108eFzlBosfMCxc5IT8j09zFNQpzLXGKxWLkZecgIT4eEdHRFrd0ai7qYhNc1aXnvMwsM5TSsjDHZkhLx9xutGgzpDoNP5LaAHVhZGwrQrE29DIyFgjgExyEe3fuWqwNkTZkCgUKS0vVNjXpg7ZNTRz+oSHo3M+2haIhjpS5yAl+zUP1siFycnFBsY0t5QkEAvQYMhgn/vrbZoWiMQJR3xljTihmJadAaGOh18yxGdKSMbdA5GgMmyH1pfHKYzNSV0bGtrT0rA1DGrg1Lw1xm5r0/atNUFYVira29GxopA2KnFCJ1MkJvYY9h9ysbCTEx1tV+6gNY2cQFUql3jaoIrEYPs2CobKh5waob4ZszOOHMVRdes5Ju6O3aYutYXu9ZQNQl0bGtioUjWng1iwUzY0tCkVjQ7FR5IRKbFEomrLELLKzQ256ht4O1UViMcQWYKZibmxpMySHqQKRNkPqD4lEK8DWhKIpDZyE4mNsSSiaEquXjM0fY0tC0VQbRIFQCO/AAMMi79jYMj1ge+OHOSI1WfNmyPqGRKKVYCsN3RxLBCQUH2MLQtEUgchBQvExtiAUzbVJxcnFxapCNNYVtjJ+cJGaDBk/tEVqqroZUl+haAmbIRsCEolWhLU3dHPakJBQfIw1C0VzCEQOEoqPsXahmHMryWCBqCsqkbXF8q4rrH38AB5FamodZnqkJoEAPs2CafzQAxKJVkbVhn5sz16rqdx1YWRMQvEx1igUzSkQOUgoPsZahaJCoUBZUZFBArG2SE0kFCuxdqFobKQmbXG9afzQDxKJVgjX0L18fSC3gkGwLnehUUN/TFWhmJWa1tDFqRHGGNIvXzFIIDLG9ArZSELxMdYoFM0Vqak6ti4UGWN6jQfWLBTNHamJxo/aaZyL7DaAQCBAh6goZN68pXZcJpPhzNbthgdjl8nMXUQAlV/42TdvmWRkXBvVY7F6+voYU1SbgBOKp/fvh7Da8psl1Q2FQgFHD3eDBGLOrSS964Ytx2I1tH1wQvHwzl1IiI/Hk927a5xjSXXD2EhN1Z3wa6N6LG8nV1dTi2sRMMZw7FCcQe1DXz+8llQ39KH6CoWqFt+X1hDLuyEhkWjFCAQCja9nkUiENr2iYGfAgKiUy3H9wEFzF483Mg5o19YkI2N9sPXICYbgHxpSGcJv3z6145ZUNwQCAXxatdRbIGbduImyoqJaZ4uq38PWIieUlJQYtXpQVSheOHJEI93S6oY+1BapSRe2JhQZYzi8bz/uZWZCbMD70yYUtX1IWVLdqA1jTVhIKOqGRKKNIRQK4dLEGyIDInwoZLI6GTwVCgX8DNyFps3IuDFGTqjt67c2/EKaafh8s6S6IRKJDBOIhYUIbP8EshMvGXQfW4qcUFJcjH+2bTd68OKEYvz2HRofYpZUN/RBr0hNNWArQpETiDkZGXh25AjsWrvOoOurC8WnBw3UOMda6oapNs4kFLVj3Z/VhEVjLiPjxhY54U5yilkct1r7rJm53KDYQuSEkuJi7Nm0GU39/Q2aLaqO1MkJPYYM1rkT2Bowl42ztdsoVhWIQ14YDScjw+5Z62bIqphrExzZKGpi3aOIFaOvkbE1Yy4j48YUOSEt6TaO7N9vteU3F/oKxMYQOYETiD4BAejRt4/J+UmdnEwSmg2JuTfBqQlFPT9ELQENgejsbFJ+1rYZsirm9pJAQlEdEokNgKFGxraMPg28sUROSEu6jbi//kJU//51GurR0jFkBtHWIydUFYi9BvQ32/KXNS6jGSwQ9exfOaGYm56ht2lLQ2JugcjBbYa0phWIunCjBZBQrIr11AYbwVgjY1vEkAZu65ETOIHYZ9AgBDcPbejiNBiGLjHbcuSEuhKI1ogxM4hyhUJv90dOrq7wDgyAwsJtmetKIHJo2wxpqdSVQOSoKhQb82ZIEon1SHUj48bc6RvTwK3dhkgXVQVis5YtGro4DYZRNog2GjmBBOJjjF1iFgoEyEm7o79QdHGByIJn8OtaIFoTpgpEQzdDVpSVGbw5ylYgkVhPmMvI2BYwpYHbmlAkgViJKZtUbG1piATiY0yxQbQTiWAvlRrkUN0QX4D1CQnEx5hjBrGxbYY0BctsETYGNfDHmKOB24pQJIFYiTl2MduKUCSB+BhzbFLx8vez+sg7NH48xlyRmhrTZkhTIZFYx1ADf4w5bUisXSiSQKzEXG5uAOsXiiQQH1Oc98BggajtfVt7iEYaP9RRKBSQuriYHKmpsWyGNAckEusQauCPqQsjY2sViiQQKzGnQOSwVqFIAvExXKQmgzap1BCpyVqFIo0fmpgzUpOtb4Y0FyQS6whjGrg1O7itibrchWZtQpEE4mNybiUZLBD1aSPWJhRJIKqjUCjg1zrM5EhNVbFGoXjsUBwJxGoYG6lJ1zXWNn40BI1zkb2OMfYLUK5QICs1DcFhrYy+t0KhQMq5BIP87KmUSqPiJeuDvKICGVeu1pmbAkAzxJauQPUNTUMLREuqGwqFAoqiIjTrEK63QCzOe6B3WawlxFZJSQn279jZ4ALRkuqGsZGa5MqCGs/VFstbW6xiS0Aul+NeZib+M+bFBheIllQ39KH6CkVt5baVEI11Bc0kmhlTlgjEIhES4uORmZJadwWsR8xlZKwPlh45wVSBqNAzsoi1wBhDYPsn9BaIRbl5yLpx0yAfbpY+o8gYwz/btje4QLQ0zBWpSRvWMqPIGMOzI0c0uEC0Now1YaEZRd3QTKIZMdWGRCgUokN0NM4cOIDO/frBPzTE4DKIRCKEdoowOBj7g6TbBt+r1nwVCjh6uJtsZGxI5AQEBeLenbtwsKCdaHeSU3D0wAGTZhBVKhUuHDmCzs88Y3xcUguqGyKRyCCBmHntOvxah+Hh7WTD7lNtRtHT18eY4tYJcrkcwf7+JgtEc4hfS6ob+lDdhEVlgBNsa5hRFIvFFuMmzVrqhqk2zjSjqB2aSTQT5jIy9gtphs79+uHMgQNWP6NoLiNja46coFIqcWT/fpOXmMViMfKyc5AQH29xM2LGoK8oquoGRd8lyOpYauQEgUCAHn37mDyDKJfLUVZSYqZSWT7msHG29BlFmlU2DHNtgqMZRU3MIhL37t2Lfv36wdPTE05OToiIiMD3339v8EaMhQsXQiAQ1Ph3/fp1cxTZ7JjTyNg/NMQmhKK5jIytOXKCXKFAVP/+JtsgCgQC9BgyGLlZ2TYjFGtDHz951hw5QSwWm0UMCIVCHNuzt1EIRXNugrN0oWgObHUzZFXM7SWBhKI6JovERYsWYciQITh48CA8PDzQsmVLJCYmYvr06RgxYoRRlTQoKAg9evTQ+ufo6Ghqkc0OZ2Rszl1otiIUa0OfBm7NkRPEIpHZYjFLnZzQa9hzjUIo6utImSInVH6Mefn64PDOXTYtFOvCS0JVoZiTdkdv0xZrgdsMaavUhRstgIRiVUwaSU+cOIF58+ZBKBRiw4YNuH37NhITE5GQkAAfHx/s2rULS5cuNTjfKVOm4OjRo1r/goODTSlynVBXRsa2LhQNaeDWGjnBkB2B+tAYhKIhkTYockIlHaKi4O3na7NC0RiBqNRzsxcvFKVSyC1kltlc2NpmyKrUlUDksPTNkPWFSSLx888/B2MMU6dOxdixY/nj4eHhvDhctGgR5FY0qBtDXRoZ26pQNLSBN4alIX2xZaFoaCg2ipxQiUAgQER0tE0KRWNnEFWMIS8zS2+h6OXvB6GN1Q2hUIiIR5shG/P4oSUDvU7jhGJueobepi22htEisbCwEAcOHAAAvPzyyxrpo0ePhqurK/Ly8hAXF2d8Ca2AujYytjWhaGwDJ6H4GFsUisbG6qXICZXYolA0ZYlZLBKhoqxMb/dHAoEAdjY4y2xLmyEB88wgWvNmyPrGaJF4/vx5yGQyODg4ICIiQiNdLBajc+fOAIBTp04ZlHdcXBxGjx6Nvn37YtSoUfj666+RnZ1tbFFtAlsRiqY2cBKKj7EloWisQOQgG6JKbEkommyDKBDAp1mwxfrJrE9sZfwAzBOpyZo3Q9Y3RovEW7duAQCCg4N1Orht3ry52rn6cvjwYWzZsgVxcXHYunUr5s6di+bNmyM2NtbY4toE1t7QzWVDQkLxMbYgFE0ViBwkFCuxBaFork0qlu5QvT6x9vEDqPS9W1ZUZND4oS1SkzVvhqxvjP7VDx8+BAB4eHjoPIdL486tDT8/P8ybNw9nzpxBXl4eSktLcezYMQwaNAhlZWWYMmUKdu/ebWyRbYKqDd2adq2Z28iYhOJjrFkomksgcpBQrMSahaK5IzWRUHyMtQtFc0ZqstbNkPWNgBnZYj777DMsWLAAUVFROHz4sNZzFixYgM8++wzPPPMMb79oDIwxPP/889i+fTtatGiBW7duae04li5dqrabOjs7G76+vkbftzFQXFwMZwr9RGiB6gahC6obhC6oblgG9+/fR0VFhcn5GG2l6+DgAACQyWQ6z+EKKJVKjb0NgMqv4kWLFmH79u24ffs2Ll68iPDwcI3zZs6ciZkzZ5p0r8ZGYGAg0tPTG7oYhAVCdYPQBdUNQhdUN2wLo5eb9VlK1mdJWl/CwsLg6VkZlispKcnk/AiCIAiCIAjdGC0SW7VqBQC4c+eOTluQ5ORktXNNRfwoCLuu+xEEQRAEQRDmwWiR2LFjR4jFYpSXlyMhIUEjXS6X48yZMwCArl27Gl/CR+Tm5uLevXsAKqezCfNAy/OELqhuELqgukHoguqGbWH0xhUAGDx4MP766y+8+uqr+Omnn9TSNmzYgHHjxsHLywuZmZmQSCQmFXTevHn48ssv4ebmhnv37pmcH0EQBEEQBKEbkxz/zJ8/HwKBACtXrsTvv//OH09MTOS/JubMmaMm6JYtW4aQkBCMGTNGLa8rV65g2rRpuHLlitrx8vJyfPHFF/jqq68AAHPnziWBSBAEQRAEUceYNJMIAP/973/x4YcfAqh0nu3s7IzLly9DpVJhyJAh2LlzJ+yqeCpfuHAhPvnkE/Tu3Rvx8fH88QsXLqBjx44AgCZNmiA4OBgAcO3aNZSWlgKoDP/3yy+/1HkYPIIgCIIgiMaOyS7E58+fj927d6Nv377Iy8tDUlISnnzySSxbtkxDINZESEgIPvvsMwwaNAjOzs64ceMGLl26BE9PT4waNQp///03Vq5cSQKRIOqB2NhYCAQCTJo0yaR8Fi5cCIFAgIULF5qlXITtkpqaCoFAgJCQEI20kJAQCAQCpKam1nu5CKIxY5Y4M0OHDsXBgweRn5+PkpISXLhwATNmzNAqEBcuXAjGmNosIgC4u7vjww8/xN69e5GcnIyioiJUVFTg7t272Lx5M5599llzFLXOefLJJyEQCCCVSlHYiCM+EJVwg1vVP6lUihYtWmDKlCka5hUEoS/a6paDgwNCQ0Mxfvx4fuMgYZ1oe7/V/5YtW6Z2zZkzZ7B06VKMGTMGoaGh/HlHjx41qSx37tzBzJkz0b59ezg5OUEqlSI4OBjdu3fHe++9h3/++cek/AnLxWhn2oQmFy5cwOXLlwFU2lJu2bIFU6ZMaeBSEZZAq1at0LRpUwBAfn4+bt26hd9++w0bNmzA5s2b8Z///KeBS6iOm5sbWrduDT8/P5Py8fb2RuvWreHt7W2mkhHVqVq3CgoKkJSUhPXr12Pjxo347bffEBMT08AlJEyh6vutTkBAgNq/X3nlFSQmJpr1/ocOHcLw4cNRVFQEOzs7BAUFoWnTpnjw4AFOnjyJEydO4LfffkNubq5Z70tYCIwwGzNnzmQAmLu7OwPAoqOjG7pIRAPTrFkzBoD99ttvasezs7NZv379GADm5eXFioqKGqaAhNWiq249ePCAjRo1igFgLi4u7MGDBw1TQANJSUlhAFizZs000rjfmpKSUu/laih0vd+aGDFiBBs7diz79ttv2bFjx1hgYCADwI4cOWJUGQoKCpi3tzcDwIYMGcJSU1PV0h8+fMhiY2PZ4MGDjcqfsHzMstxMAEqlkt/h/cMPP8DOzg7//vsv7ty508AlIywRHx8frF27Fvb29sjLy8P+/fsbukiEjeDh4YFVq1bByckJRUVF2LdvX0MXiagntm3bhg0bNuCdd95B9+7d9d4ToIu9e/ciNzcXrq6u2LRpE5o1a6aW7u7ujokTJ2LPnj0m3YewXEgkmokDBw4gKysLvr6+GDNmDPr27QvGGNavX6/zmtLSUixevBjdunWDu7s7HB0d0apVK8TExODff//VOJ8xhs2bN2Pw4MFo2rQp7O3tERwcjEGDBiE2Nlbt3OjoaAgEAg3bT45JkyZBIBBoXFf1eEpKCiZNmoSAgACIRCJ+84FSqcTOnTsxZcoUPPHEE3Bzc4OjoyPatm2LOXPm1LrssH//fowcORL+/v6wt7eHv78/+vTpgx9//JGP9z1mzBgIBAIsWbJEZz5btmyBQCBA586da7yfpeLr68tHI7p165aG4f4vv/yCzp07w8XFRWPDVnp6OqZPn46wsDBIpVK4u7ujT58+2LJlS4331OfZAzVvXDl69ChGjBgBX19fiMVieHp6om3btpg6dSpOnjypdm5tG1eOHz+OkSNHwsfHBxKJBIGBgZgwYQKuXbum9fyq9fr69esYPXo0vL29IZVK0alTJ2zatKnG399YcHV1RVhYGABo3ezxzz//4LnnnoOPjw/s7e0RGBiIyZMn4/bt2zrzNKS/Sk5OxldffYXo6GgEBQXB3t4eTZo0wcCBA0lQWBFc1LSwsDA4OjoafL0hYxZ3/rp169C7d2+4u7tDKpWiTZs2mDt3Lh48eKD1HpzdJQBs3boVvXr1gru7u8ZGpwcPHmD+/Pm8XaWLiwu6deuGX375BSqVyuDf1mho2IlM2+Gll15iANiMGTMYY4zFxsYyAKxt27Zaz09LS2Nt27ZlABgA1qpVKxYREcE8PT0ZANa7d2+18ysqKtiIESP48/38/Fjnzp1ZQEAAEwgErPqr7N27NwPA4uLitN5/4sSJWpcyuOPvv/8+c3d3Z/b29iwiIoK1adOGLVy4kDHG2N27dxkAJhQKmZ+fH5/u4ODAALCQkBCWnZ2t9b5vvvkm/xu8vLxYZGQka9asGRMKhWrLSf/88w8DwJ588kmdz3zo0KEMAPvhhx90ntPQ1LZk9MQTTzAA7KuvvlJbbnv99dcZABYUFMQiIyOZu7s7f018fDxzc3NjAJhUKmVPPvkkCwoK4p/rrFmztN5L32fPGGO//fYbA8AmTpyolseOHTv48728vPh37+TkpFb/OT7++GMGgH388cca5VmxYgVfd5s2bcr/TgDMwcGB/fnnnxrXcPV68eLFzNnZmbm4uLBOnTqxJk2a8L9t7dq1Wn+/rVFb3WrdujUDwL777ju14zNmzOCfVdOmTVnHjh2Zq6srA8BcXV3ZsWPHNPIytL96+eWXGQDm7OzMwsLCWGRkJPPz8+OvX7RokcY9aLlZHWOWm3XlYexy8/fff88AMDc3N/bw4UODrjV0zFKpVPw4CoA1b96cRUREMIlEwteL27dva9ynap0CwHx8fFjnzp1ZkyZN+Ppy+fJlFhAQwAAwiUTC2rVrx1q0aMGXY9SoUUylUhn1jGwdEolmoKioiDk6OjIA7PTp04wxxgoLC5lUKmUA2NmzZ9XOVygUrFOnTgwAi4yMZFevXlVLP3/+PFuxYoXasXfeeYcBYN7e3uyvv/5SS8vIyNAYhE0ViXZ2duy5555jeXl5fFpZWRljjLH8/HwWGxurlsZYpX3KW2+9xQCwSZMmadxz2bJlDABzdHRka9euZUqlkk/Ly8tjS5YsYffu3WOMMaZUKllwcDADwBISEjTyysnJYSKRiEkkEo1yWBI1dfRZWVnM3t6eAWBbt27lB0k7Ozvm5OTEdu7cyZ9bWlrKGKt8156enkwgELAvvviClZeX8+ccO3aM7wh3796tdi9Dnj1jukVi+/btGQC2YsUKplAo+OMqlYrFxcWxXbt2qZ2vSySeP3+eiUQiBoB9/fXXfHnKy8vZtGnT+IEpMzNT7TquXovFYvbWW2/xdVKlUrG5c+cyAMzf31+tbLZKTXXr5s2b/PM9fPgwf/z//u//GAAWGhqq1jcoFAr2+eefMwAsMDCQf65cmqH91d69e9nJkyc1Bt7Dhw8zPz8/Zmdnx5KSktTSSCSqYwki8caNG/xHYadOndiWLVtYfn6+XtcaOmZxgtTFxYXt27ePP56VlcV69OjBALCuXbtq3IcTiRKJhP388898nZPL5Uwul7Pi4mLWokULBoBNnz6dFRQU8NdeuXKF/1C35MmGhoREohngZg1btmypdnz06NFaZ1c2bdrEf8Xn5ubWmn9GRgYTi8UaHX5NmCoSfX19WXFxsV73qk5QUBBzdHRkcrmcP1ZaWsq8vLwYALZmzRq98vnoo4+0Pj/GGFu6dCn/BWjJ6Oroc3Jy+I0rHh4erLCwkB8kAbAlS5ZozY/bHPXuu+9qTd+9ezcDwPr27csfM+bZ6xKJ9vb2zMPDQ688GNMtEseNG8cAsGHDhmlco1Kp+I77o48+Ukvj6nV4eLia0GWMMZlMxnx9fXV+WNga2upWQUEB279/P2vXrh0DwHr06MGnVVRUMF9fX2ZnZ6fz+Tz//PMa9cTQ/qo2Vq5cyQCw//73v2rHSSSqw/1mXX/VZ29rysNYkcgYY//973/V7isQCFjr1q3ZpEmT2MaNG9U+VDkMHbNUKhW/GvLtt99qpKenp/MzigcPHlRL48r19ttva837u+++YwDYiBEjtKYnJiYygUDAmjdvXms5GyNkk2gG1q5dCwB46aWX1I6PGzcOAPD7779DoVDwx3fu3AkAmDJlCry8vGrNf+/evZDL5ejWrRuioqLMVewaef755+Hk5FTjOYcOHcK7776LIUOGoFevXujZsyd69uyJgoIClJaW4tatW/y5x44dQ15eHvz9/fnnUhuTJ0+GQCDAhg0bIJfL1dJWr14NACY7e64vvvjiC/75tG/fHkFBQThw4ADEYjF++eUXuLi4qJ0/YcIErfls27YNADB16lSt6QMHDoREIsHx48f5OmfMs9dFUFAQ8vPzTd5ow22mePvttzXSBAIBpk+frnZedaZMmQKhUL37EovFCA8PB/DYlqoxwLUTgUAANzc39O/fH9evX8eLL76I3bt38+edOHEC2dnZiIiI4KNbVee5554DADUbQ0P7K4779+9j+fLleOmll9CvXz++/nO+/cztqsVWadWqFXr06KHx9+STT9bL/efNm4dDhw5h8ODBkEgkYIzhxo0biI2NxZgxYxAWFqZh+27omHXt2jXcvXsXDg4OeOWVVzTSAwIC8PzzzwPQ3ScY22c+9dRTCAkJQXJyMtLT02sta2OD/CSaSEZGBuLi4gBoisRBgwbBw8MD9+7dw759+zB48GAA4I3yu3Xrptc9DD3fHLRt21Znmkwmw4svvogdO3bUmEdVQ2PuN3Tp0kVjcNdFaGgooqOjERcXh7/++osfwBITE5GYmAhfX18MHDhQr7wamlu3bvGiWSKRwNfXF7169cKsWbPQoUMHtXO9vb21+hUsLi7mDbFfffXVGu9XXl6OvLw8+Pj4GPXsdfHuu+/izTffxIABA9CpUyd+8O/du7eG0NVFfn4+7t+/DwBo166d1nOeeOIJAMDNmze1prdo0ULrcc6fXHFxsV5lsQU4P3qMMWRnZyM5ORlisRidO3eGh4cHf96lS5cAVG5k6dmzp9a88vPzAVT2axzG9D/79u3DCy+8gIKCAp3n6NqIQKgzb968Bv8Y7tOnD/r06YOysjKcPXsWp06dwt69exEfH487d+5g8ODBSEhIQJs2bQAYXme4dh4cHKxzcqK2PkHXmMXV+wULFuCLL77Qeg632TIjIwOBgYF6lbmxQCLRRNavXw+VSoWIiAi0bt1aLU0ikWD06NH4+eefsXbtWl4kcpFY3N3d9bqHoeebg5pmERctWoQdO3bA19cXX3/9NXr16gVfX1/Y29sDAHr27Iljx46pzf4Z+xumTJmCuLg4rF69mheJ3Czi+PHjTXbxUF/89ttvenf0up591QH32LFjteZTVlYGwLz1Z9q0aXBxccGSJUtw7tw5nDt3Dl999RUcHBwQExODb775Bm5ubjXmUVXA6XIS7OPjAwAoKirSmq7rGXEimJkWkt6qqC4ijh07huHDh2P27Nnw8fHB+PHjATyuP/fv3+dFui64ugMYXn/y8/MxZswYFBQUYMKECZg2bRpat24NV1dXCIVCHDhwAP3799dYHSAsH6lUiqioKERFRWH27Nk4evQoBg4ciJKSEixZsgS//PILAMPrDNcn6OoPAOP7BK7enzt3rtZyVK33RCW03Gwi3FJzQkKC1rBJP//8M4DKJRuu4XAzLtxXe20Yej4A3iWArsGypKRE77yqw7n1iY2NRUxMDJo1a8YLRAC4e/euxjXG/Aagctnbzc0Nf/75J/Ly8qBQKLBhwwYA1rPUbC6cnZ35/5fJZGCVNsU6/zhXOsY+e13ExMTgwoULyMrKwsaNG/Hyyy9DJBLhl19+4QWJvr/j3r17Ws/JyckBAL1nJ4nH9OjRgx+sZ8yYwfc73HMfN25crXWn6vKhofXnr7/+wsOHD/H0008jNjYWXbt2hbu7Oy/gtfUPhHXSs2dPTJs2DQBw+vRp/rihdYarm7r6A8D4PoHL+9atW7XW++joaIPybgyQSDSB8+fP4/LlyxAIBPDx8dH5J5FIUFZWhq1btwJ4PG1e3aecLgw9H3j8VaVrxiApKUnvvKrDLXl2795dIy0vL09tqYqD+w1nzpwxyCeVVCrFmDFjIJPJ8Pvvv+Ovv/5CTk4OIiMj+TwbC25ubvD39wcAg2I+G/vsa8PX1xcvvvgiVq5ciVOnTkEoFOLPP/9EVlZWjde5u7ujSZMmAICrV69qPYf7fZyvP8Iwhg8fjm7duuHBgwdYunQpgMdL+1zoUH0xtP/h+oenn35aw78nQLaItkbz5s0BVH64chhaZ7h2fufOHZ2mIsb2CcbWe6ISEokmwM0i9urVC9nZ2Tr/Zs2apXb+8OHDAQC//vqrXnY5gwcPhlgsxsmTJ/VaZgQeN9wzZ85opJ09e9akjloqlQJ4/GVXlSVLlkCpVGoc79GjB7y9vZGRkcFHptEXLv716tWrrW7DirkZOXIkAPDG//pgyrPXl3bt2vHLzJmZmbWe/+yzzwIAvv/+e400xhh/nDuPMJz3338fAPDdd9+huLgYUVFR8Pb2RmJiok4n+9owtL+qqX/Iy8vDqlWr9L430bDk5ubWarpx/PhxAOADAwCGj1lt27ZFcHAwysvLsXLlSo30zMxMfpLF0D6B6zO/++67RmWGYi5IJBpJ1TB8MTExNZ7LLcHFx8fj7t27GD58OCIjI3Hv3j0MHjwYN27cUDs/MTER//vf//h/+/n54a233gJQWeGr7+7KzMzEp59+qnZs0KBBACqjdlRdBrh16xYmTpwIkch4c1TO6H3WrFn8Vx9jDGvWrMHixYvh4OCgcY2DgwM++ugjAMBrr72G33//Xa3BPnz4EN9++63Wmc8uXbqgffv2OHv2LHbu3AmJRIKxY8caXX5rZu7cufD09MTq1asxc+ZMjeWcBw8e4Ndff8Xnn3/OHzPl2VelsLAQY8aMQXx8vNqMpFKpxHfffYeHDx/CyclJwzZXG7NmzYJIJMLOnTuxZMkSPj+ZTIYZM2bg8uXLcHNzwxtvvFFrXoR2nnvuObRt2xYPHz7E//73Pzg4OPD9xOjRo7F9+3aNQfPy5cuYO3eu2sBuaH/F7WbdtGkTDhw4wB/PysrC888/r+bpgbBs1q1bhw4dOuCXX35BXl6eWlp+fj4WLFiAdevWAajcZc9h6JglEAjw3nvvAQA+/vhjHDx4kE/LycnhV5O6deuGPn36GPQbXnvtNTRv3hxxcXEYN26cxkpHcXExNm3ahJkzZxqUb6Ohjl3s2Cx//fUXHxlCH+eiHTt2ZADYl19+yRirjGDARUQAwMLCwlinTp14f3bVfWCVl5ezYcOG8ef7+/uzzp07s8DAQJ3e6zk/fEKhkLVu3Zq1b9+eCYVC1qtXL96zvS4/iTU5cD179izvBNrV1ZV16tSJ+fv7MwAsJiZGp49GlUrF3njjDf43eHt7s86dO7OQkBBmZ2dXox+0JUuW8NdZum/EqhjiELcmP3FVOXr0KPP29uadSj/55JOsa9eurHnz5nxdePHFF9WuMfTZa/OT+PDhQ/56JycnFh4eziIjI/myCAQC9ssvv6jdV9+IK1yUBC7iir29fY0RVwz1/2mL6FO3Vq1axfs95Rxkv//++/x79PT0ZJ07d1aLngJAw/mxof3VqFGj+HNbtmzJOnTowEQiEXNxceEdu1e/hvwkqmOMM+2vvvqKeXl58X+cI2w3Nzf+WMeOHfXOj3tX3F9oaCjr0qULa9WqFe+3EACbPXu2xrXGjFlVI660bNlSLeJKcHBwjRFXauLatWssNDSUHw/btm3LunbtysLCwvj+T5ujboKcaRsNV5lHjx6t1/mcyGnXrh1/rLi4mH355ZcsIiKCOTs7M0dHR9aqVSs2ceJErQ5IVSoVW79+PXvmmWeYp6cnk0gkLDg4mA0ZMkSrk+SioiI2c+ZMFhgYyCQSCQsNDWXz589n5eXltTrTrq1jOnXqFOvfvz9zdnZmTk5OrEOHDuy7775jKpWq1oF8z549bOjQoaxJkyZMIpGwgIAA1rdvX7ZixQpWUVGh9Zp79+7xjVmbeLBU6kIkMlb5PObPn8/Cw8OZs7Mzk0qlrGXLlmzQoEFsxYoVOsMi6vvstYlEhULB1q5dy2JiYlibNm2Ym5sbk0qlLCwsjI0fP55duHBB4341iUTGKgXv8OHDWZMmTZhYLGb+/v5s/Pjx7MqVK1rPJ5H4GH3qVkVFBf8B9+OPP/LHjx07xl566SUWFBTEJBIJ8/T0ZE899RSbMmUK27NnD5PJZBp5GdJfVVRUsI8++oiFhIQwsVjMfH192ZgxY9j169dZXFwciUQ9MEYkcu2tpj99+hcOmUzGDh06xN577z3WvXt3FhwczCQSCf/uJ0yYUKOjbkPHLJVKxdasWcOioqKYq6srs7e3Z61atWLvvfeeTkfu+ohExiqjoC1atIh17dqVzzskJIT17duXLV68uFHVLUMQMEaL9ITlc/36dbRt2xa+vr5IT0+3Gtc3BEEQBGGtkE0iYRVwxu4xMTEkEAmCIAiiHqCZRMLiSUlJQXh4OEpLS3Hjxg2d0TYIgiAIgjAfFHGFsFjeeecdnD59GomJiSgtLcWrr75KApEgCIIg6glabiYslgsXLuDEiRNwcXHB9OnTDfINSBAEQRCEadByM0EQBEEQBKEBzSQSBEEQBEEQGpBIJAiCIAiCIDQgkUgQBEEQBEFoQCKRIAiCIAiC0IBEIkEQBEEQBKEBiUSCIAiCIAhCAxKJBEEQBEEQhAb/D0e0/OF6cn1WAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 720x240 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The results are given in above Figure, evaluating different variants to Concoction.\n"
     ]
    }
   ],
   "source": [
    "from Evaluation.demo2.chart.ablation import graphEM\n",
    "\n",
    "print(\"Output Figure 9:  Comparing implementation variants of Concoction on the CVE dataset.\")\n",
    "graphEM()\n",
    "print(\"The results are given in above Figure, evaluating different variants to Concoction.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ***Reference***\n",
    "\n",
    "| Source code                                                  | Title                                                        | Authors                                                   |\n",
    "| :----------------------------------------------------------- | :----------------------------------------------------------- | :-------------------------------------------------------- |\n",
    "| [Funded](https://github.com/HuantWang/FUNDED_NISL)[1]        | Combining Graph-Based Learning With Automated Data Collection for Code Vulnerability Detection | H. Wang, G. Ye, Z. Tang, et al.                           |\n",
    "| [Vuldeepecker](https://github.com/CGCL-codes/VulDeePecker)[2] | VulDeePecker: A Deep Learning-Based System for Vulnerability Detection | Zhen Li, Deqing Zou, Shouhuai Xu, et al.                  |\n",
    "| [ReVeal](https://github.com/VulDetProject/ReVeal)[3]         | Deep learning based vulnerability detection: Are we there yet | Saikat Chakraborty, Rahul Krishna, Yangruibo Ding, et al. |\n",
    "| [Devign](https://github.com/epicosy/devign)[4]               | Devign: Effective vulnerability identification by learning comprehensive program semantics via graph neural networks | Yaqin Zhou, Shangqing Liu, Jingkai Siow, et al.           |\n",
    "| [ReGVD](https://github.com/daiquocnguyen/GNN-ReGVD)[5]       | ReGVD: Revisiting Graph Neural Networks for Vulnerability Detection | Van-Anh Nguyen, Dai Quoc Nguyen, Van Nguyen, et al.       |\n",
    "| [LineVul](https://github.com/awsm-research/LineVul)[6]       | Linevul: A transformer-based line-level vulnerability prediction | Michael Fu and Chakkrit Tantithamthavorn.                 |\n",
    "| [LineVD](https://github.com/davidhin/linevd)[7]              | LineVD: Statement-level vulnerability detection using graph neural networks | David Hin, Andrey Kan, Huaming Chen, et al.               |\n",
    "| [CodeXGLUE](https://github.com/microsoft/CodeXGLUE)[8]       | CodeXGLUE: A Machine Learning Benchmark Dataset for Code Understanding and Generation | Shuai Lu, Daya Guo, Shuo Ren, et al.                      |\n",
    "| [GraphcodeBERT](https://github.com/microsoft/CodeBERT/tree/master/GraphCodeBERT)[9] | GraphCodeBERT: Pre-training Code Representations with Data Flow | Daya Guo, Shuo Ren, Shuai Lu, et al.                      |\n",
    "| [Contraflow](https://dl.acm.org/doi/10.1145/3533767.3534371)[10] | Path-Sensitive Code Embedding via Contrastive Learning for Software Vulnerability Detection | Xiao Cheng, Guanqin Zhang, Haoyu Wang, et al.             |\n",
    "| [LIGER](https://github.com/keowang/dynamic-program-embedding)[11] | Blended, Precise Semantic Program Embeddings                 | Ke Wang and Zhendong Su.                                  |\n",
    "| [CodeQL](https://github.com/github/codeql)[12]               | CodeQL, discover vulnerabilities with semantic code analysis engine | /                                                         |\n",
    "| [Infer](https://github.com/facebook/infer)[13]               | Infer, a static program analyzer                             | /                                                         |\n",
    "| [KLEE](https://klee.github.io/)[14]                          | Klee: unassisted and automatic generation of high-coverage tests for complex systems programs | Cristian Cadar, Daniel Dunbar, Dawson R Engler, et al.    |\n",
    "| [MoKLEE](https://srg.doc.ic.ac.uk/projects/moklee/)[15]      | Running symbolic execution forever                           | Frank Busse, Martin Nowack, and Cristian Cadar.           |\n",
    "| [AFL++](https://github.com/AFLplusplus/AFLplusplus)[16]      | AFL++:Combining Incremental Steps of Fuzzing Research        | Andrea Fioraldi, Dominik Maier, Heiko Eißfeldt, et al.    |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}