Add files using upload-large-folder tool

benchmark/IOAI/IOAI2025/Individual-Contest/Radar/Solution/Radar_Solution.ipynb

@@ -0,0 +1,1056 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "ab23242e-3c5e-4ba6-9cb9-dfc4d8c22321",
+   "metadata": {},
+   "source": [
+    "<img src=\"./figs/IOAI-Logo.png\" alt=\"IOAI Logo\" width=\"200\" height=\"auto\">\n",
+    "\n",
+    "[IOAI 2025 (Beijing, China), Individual Contest](https://ioai-official.org/china-2025)\n",
+    "\n",
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/IOAI-official/IOAI-2025/blob/main/Individual-Contest/Radar/Solution/Radar_Solution.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f2ea67c2-ec81-4ced-b8a4-a19b591376bb",
+   "metadata": {},
+   "source": [
+    "# Radar: Reference Solution"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "97ae6685",
+   "metadata": {},
+   "source": [
+    "## Configs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4243ca5d",
+   "metadata": {
+    "jupyter": {
+     "source_hidden": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "radar_configs = {\n",
+    "    'c': 3e8, \n",
+    "    'startFreq': 77e9, \n",
+    "    'Tr': 60e-6,                    # Sweeping frequency time\n",
+    "    'Idle_time': 100e-6,            # free time\n",
+    "    'Fs': 10e6,                     # Sampling frequency\n",
+    "    'Slope': 29.982e12,             # chirp slope\n",
+    "    'Bandwidth': 60e-6 * 29.982e12, # Transmission signal bandwidth\n",
+    "    'BandwidthValid': 0.767539200e9,# Effective bandwidth of the transmitted signal\n",
+    "    'range_size': 256,              # range size\n",
+    "    'azimuth_size': 181,            # azimuth size\n",
+    "    'elevation_size': 181,          # elevation size\n",
+    "    'crop_num': 3,                  # crop some indices in range domain\n",
+    "    'n_chirps': 128,                # number of chirps in one frame\n",
+    "    'min_azimuth': -90,             # min radar azimuth\n",
+    "    'max_azimuth': 90,              # max radar azimuth\n",
+    "    'min_elevation': -90,           # min radar elevation\n",
+    "    'max_elevation': 90,            # max radar elevation    \n",
+    "    'min_range': 1.0,               # min radar range\n",
+    "    'max_range': 25.0,              # max radar range\n",
+    "    'range_res': 3e8/(2*0.767539200e9), \n",
+    "    'angle_res': 1\n",
+    "}\n",
+    "\n",
+    "dimssnet_configs = {\n",
+    "    'n_epoch': 10,\n",
+    "    'batch_size': 2,\n",
+    "    'learning_rate': 1e-5,\n",
+    "    'range_size': 50,\n",
+    "    'azimuth_size': 181,\n",
+    "    'elevation_size': 181,\n",
+    "    'doppler_size': 181, \n",
+    "    'min_azimuth': -90,             # min radar azimuth\n",
+    "    'max_azimuth': 90,              # max radar azimuth\n",
+    "    'min_elevation': -90,           # min radar elevation\n",
+    "    'max_elevation': 90,            # max radar elevation    \n",
+    "    'min_range': 1.0,               # min radar range\n",
+    "    'max_range': 25.0,              # max radar range\n",
+    "}\n",
+    "\n",
+    "n_class = 5\n",
+    "class_table = {\n",
+    "    -1: 'background', \n",
+    "    0: 'suicase', \n",
+    "    1: 'chair', \n",
+    "    2: 'person',\n",
+    "    3: 'wall'\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c39a54f5",
+   "metadata": {},
+   "source": [
+    "## Models"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "10817ce8",
+   "metadata": {
+    "jupyter": {
+     "source_hidden": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "\n",
+    "class SRA_Encode(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(SRA_Encode, self).__init__()\n",
+    "        self.conv1a = nn.Conv2d(in_channels=1, out_channels=64, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv1b = nn.Conv2d(in_channels=64, out_channels=64, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.conv2a = nn.Conv2d(in_channels=64, out_channels=128, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv2b = nn.Conv2d(in_channels=128, out_channels=128, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.conv3a = nn.Conv2d(in_channels=128, out_channels=256, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv3b = nn.Conv2d(in_channels=256, out_channels=256, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "\n",
+    "        self.bn1a = nn.BatchNorm2d(num_features=64)\n",
+    "        self.bn1b = nn.BatchNorm2d(num_features=64)\n",
+    "        self.bn2a = nn.BatchNorm2d(num_features=128)\n",
+    "        self.bn2b = nn.BatchNorm2d(num_features=128)\n",
+    "        self.bn3a = nn.BatchNorm2d(num_features=256)\n",
+    "        self.bn3b = nn.BatchNorm2d(num_features=256)\n",
+    "\n",
+    "        self.relu = nn.ReLU()\n",
+    "        \n",
+    "    def forward(self, x):\n",
+    "        x = self.relu(self.bn1a(self.conv1a(x)))\n",
+    "        x = self.relu(self.bn1b(self.conv1b(x)))\n",
+    "        x = self.relu(self.bn2a(self.conv2a(x)))\n",
+    "        x = self.relu(self.bn2b(self.conv2b(x)))\n",
+    "        x = self.relu(self.bn3a(self.conv3a(x)))\n",
+    "        x = self.relu(self.bn3b(self.conv3b(x)))\n",
+    "        \n",
+    "        return x\n",
+    "\n",
+    "class SRA_Decode(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(SRA_Decode, self).__init__()\n",
+    "        self.convt1 = nn.ConvTranspose2d(in_channels=256, out_channels=128,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.convt2 = nn.ConvTranspose2d(in_channels=128, out_channels=64,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.convt3 = nn.ConvTranspose2d(in_channels=64, out_channels=32,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.prelu = nn.PReLU()\n",
+    "        self.sigmoid = nn.Sigmoid()\n",
+    "        self.upsample = nn.Upsample(size=(dimssnet_configs['range_size'],\n",
+    "                                          dimssnet_configs['azimuth_size']), mode='nearest')\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.prelu(self.convt1(x))\n",
+    "        x = self.prelu(self.convt2(x))\n",
+    "        x = self.prelu(self.convt3(x))\n",
+    "\n",
+    "        return x\n",
+    "\n",
+    "class DRA_Encode(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(DRA_Encode, self).__init__()\n",
+    "        self.conv1a = nn.Conv2d(in_channels=1, out_channels=64, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) # (1 50 181)->(64 50 181)\n",
+    "        self.conv1b = nn.Conv2d(in_channels=64, out_channels=64, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)) # (64 50 181)->(64 25 91)\n",
+    "        self.conv2a = nn.Conv2d(in_channels=64, out_channels=128, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) # (64 25 91)->(128 25 91)\n",
+    "        self.conv2b = nn.Conv2d(in_channels=128, out_channels=128, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)) # (128 25 91)->(128 13 46)\n",
+    "        self.conv3a = nn.Conv2d(in_channels=128, out_channels=256, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) # (128 13 46)->(256 13 46)\n",
+    "        self.conv3b = nn.Conv2d(in_channels=256, out_channels=256, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)) # (256 13 46)->(256 7 23)\n",
+    "\n",
+    "        self.bn1a = nn.BatchNorm2d(num_features=64)\n",
+    "        self.bn1b = nn.BatchNorm2d(num_features=64)\n",
+    "        self.bn2a = nn.BatchNorm2d(num_features=128)\n",
+    "        self.bn2b = nn.BatchNorm2d(num_features=128)\n",
+    "        self.bn3a = nn.BatchNorm2d(num_features=256)\n",
+    "        self.bn3b = nn.BatchNorm2d(num_features=256)\n",
+    "\n",
+    "        self.relu = nn.ReLU()\n",
+    "        \n",
+    "    def forward(self, x):\n",
+    "        x = self.relu(self.bn1a(self.conv1a(x)))\n",
+    "        x = self.relu(self.bn1b(self.conv1b(x)))\n",
+    "        x = self.relu(self.bn2a(self.conv2a(x)))\n",
+    "        x = self.relu(self.bn2b(self.conv2b(x)))\n",
+    "        x = self.relu(self.bn3a(self.conv3a(x)))\n",
+    "        x = self.relu(self.bn3b(self.conv3b(x)))\n",
+    "\n",
+    "        return x\n",
+    "\n",
+    "class DRA_Decode(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(DRA_Decode, self).__init__()\n",
+    "        self.convt1 = nn.ConvTranspose2d(in_channels=256, out_channels=128,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)) # (256 7 23)->(128 13 45)\n",
+    "        self.convt2 = nn.ConvTranspose2d(in_channels=128, out_channels=64,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)) # (128 13 45)->(64 25 89)\n",
+    "        self.convt3 = nn.ConvTranspose2d(in_channels=64, out_channels=32,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)) # (64 25 89)->(32 49 177)\n",
+    "        self.prelu = nn.PReLU()\n",
+    "        self.sigmoid = nn.Sigmoid()\n",
+    "        self.upsample = nn.Upsample(size=(dimssnet_configs['range_size'],\n",
+    "                                          dimssnet_configs['elevation_size']), mode='nearest')\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.prelu(self.convt1(x))\n",
+    "        x = self.prelu(self.convt2(x))\n",
+    "        x = self.prelu(self.convt3(x))\n",
+    "\n",
+    "        return x\n",
+    "\n",
+    "class SRE_Encode(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(SRE_Encode, self).__init__()\n",
+    "        self.conv1a = nn.Conv2d(in_channels=1, out_channels=64, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv1b = nn.Conv2d(in_channels=64, out_channels=64, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.conv2a = nn.Conv2d(in_channels=64, out_channels=128, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv2b = nn.Conv2d(in_channels=128, out_channels=128, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.conv3a = nn.Conv2d(in_channels=128, out_channels=256, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv3b = nn.Conv2d(in_channels=256, out_channels=256, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "\n",
+    "        self.bn1a = nn.BatchNorm2d(num_features=64)\n",
+    "        self.bn1b = nn.BatchNorm2d(num_features=64)\n",
+    "        self.bn2a = nn.BatchNorm2d(num_features=128)\n",
+    "        self.bn2b = nn.BatchNorm2d(num_features=128)\n",
+    "        self.bn3a = nn.BatchNorm2d(num_features=256)\n",
+    "        self.bn3b = nn.BatchNorm2d(num_features=256)\n",
+    "\n",
+    "        self.relu = nn.ReLU()\n",
+    "        \n",
+    "    def forward(self, x):\n",
+    "        x = self.relu(self.bn1a(self.conv1a(x)))\n",
+    "        x = self.relu(self.bn1b(self.conv1b(x)))\n",
+    "        x = self.relu(self.bn2a(self.conv2a(x)))\n",
+    "        x = self.relu(self.bn2b(self.conv2b(x)))\n",
+    "        x = self.relu(self.bn3a(self.conv3a(x)))\n",
+    "        x = self.relu(self.bn3b(self.conv3b(x)))\n",
+    "\n",
+    "        return x\n",
+    "\n",
+    "class SRE_Decode(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(SRE_Decode, self).__init__()\n",
+    "        self.convt1 = nn.ConvTranspose2d(in_channels=256, out_channels=128,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.convt2 = nn.ConvTranspose2d(in_channels=128, out_channels=64,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.convt3 = nn.ConvTranspose2d(in_channels=64, out_channels=32,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.prelu = nn.PReLU()\n",
+    "        self.sigmoid = nn.Sigmoid()\n",
+    "        self.upsample = nn.Upsample(size=(dimssnet_configs['range_size'],\n",
+    "                                          dimssnet_configs['elevation_size']), mode='nearest')\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.prelu(self.convt1(x))\n",
+    "        x = self.prelu(self.convt2(x))\n",
+    "        x = self.prelu(self.convt3(x))\n",
+    "\n",
+    "        return x\n",
+    "    \n",
+    "class DRE_Encode(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(DRE_Encode, self).__init__()\n",
+    "        self.conv1a = nn.Conv2d(in_channels=1, out_channels=64, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv1b = nn.Conv2d(in_channels=64, out_channels=64, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.conv2a = nn.Conv2d(in_channels=64, out_channels=128, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv2b = nn.Conv2d(in_channels=128, out_channels=128, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.conv3a = nn.Conv2d(in_channels=128, out_channels=256, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv3b = nn.Conv2d(in_channels=256, out_channels=256, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "\n",
+    "        self.bn1a = nn.BatchNorm2d(num_features=64)\n",
+    "        self.bn1b = nn.BatchNorm2d(num_features=64)\n",
+    "        self.bn2a = nn.BatchNorm2d(num_features=128)\n",
+    "        self.bn2b = nn.BatchNorm2d(num_features=128)\n",
+    "        self.bn3a = nn.BatchNorm2d(num_features=256)\n",
+    "        self.bn3b = nn.BatchNorm2d(num_features=256)\n",
+    "\n",
+    "        self.relu = nn.ReLU()\n",
+    "        \n",
+    "    def forward(self, x):\n",
+    "        x = self.relu(self.bn1a(self.conv1a(x)))\n",
+    "        x = self.relu(self.bn1b(self.conv1b(x)))\n",
+    "        x = self.relu(self.bn2a(self.conv2a(x)))\n",
+    "        x = self.relu(self.bn2b(self.conv2b(x)))\n",
+    "        x = self.relu(self.bn3a(self.conv3a(x)))\n",
+    "        x = self.relu(self.bn3b(self.conv3b(x)))\n",
+    "\n",
+    "        return x\n",
+    "\n",
+    "class DRE_Decode(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(DRE_Decode, self).__init__()\n",
+    "        self.convt1 = nn.ConvTranspose2d(in_channels=256, out_channels=128,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.convt2 = nn.ConvTranspose2d(in_channels=128, out_channels=64,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.convt3 = nn.ConvTranspose2d(in_channels=64, out_channels=32,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.prelu = nn.PReLU()\n",
+    "        self.sigmoid = nn.Sigmoid()\n",
+    "        self.upsample = nn.Upsample(size=(dimssnet_configs['range_size'],\n",
+    "                                          dimssnet_configs['elevation_size']), mode='nearest')\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.prelu(self.convt1(x))\n",
+    "        x = self.prelu(self.convt2(x))\n",
+    "        x = self.prelu(self.convt3(x))\n",
+    "\n",
+    "        return x\n",
+    "    \n",
+    "class SRD_Encode(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(SRD_Encode, self).__init__()\n",
+    "        self.conv1a = nn.Conv2d(in_channels=1, out_channels=64, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv1b = nn.Conv2d(in_channels=64, out_channels=64, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.conv2a = nn.Conv2d(in_channels=64, out_channels=128, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv2b = nn.Conv2d(in_channels=128, out_channels=128, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.conv3a = nn.Conv2d(in_channels=128, out_channels=256, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv3b = nn.Conv2d(in_channels=256, out_channels=256, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "\n",
+    "        self.bn1a = nn.BatchNorm2d(num_features=64)\n",
+    "        self.bn1b = nn.BatchNorm2d(num_features=64)\n",
+    "        self.bn2a = nn.BatchNorm2d(num_features=128)\n",
+    "        self.bn2b = nn.BatchNorm2d(num_features=128)\n",
+    "        self.bn3a = nn.BatchNorm2d(num_features=256)\n",
+    "        self.bn3b = nn.BatchNorm2d(num_features=256)\n",
+    "\n",
+    "        self.relu = nn.ReLU()\n",
+    "        \n",
+    "    def forward(self, x):\n",
+    "        x = self.relu(self.bn1a(self.conv1a(x)))\n",
+    "        x = self.relu(self.bn1b(self.conv1b(x)))\n",
+    "        x = self.relu(self.bn2a(self.conv2a(x)))\n",
+    "        x = self.relu(self.bn2b(self.conv2b(x)))\n",
+    "        x = self.relu(self.bn3a(self.conv3a(x)))\n",
+    "        x = self.relu(self.bn3b(self.conv3b(x)))\n",
+    "\n",
+    "        return x\n",
+    "\n",
+    "class SRD_Decode(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(SRD_Decode, self).__init__()\n",
+    "        self.convt1 = nn.ConvTranspose2d(in_channels=256, out_channels=128,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.convt2 = nn.ConvTranspose2d(in_channels=128, out_channels=64,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.convt3 = nn.ConvTranspose2d(in_channels=64, out_channels=32,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.prelu = nn.PReLU()\n",
+    "        self.sigmoid = nn.Sigmoid()\n",
+    "        self.upsample = nn.Upsample(size=(dimssnet_configs['range_size'],\n",
+    "                                          dimssnet_configs['doppler_size']), mode='nearest')\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.prelu(self.convt1(x))\n",
+    "        x = self.prelu(self.convt2(x))\n",
+    "        x = self.prelu(self.convt3(x))\n",
+    "\n",
+    "        return x\n",
+    "    \n",
+    "class DRD_Encode(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(DRD_Encode, self).__init__()\n",
+    "        self.conv1a = nn.Conv2d(in_channels=1, out_channels=64, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv1b = nn.Conv2d(in_channels=64, out_channels=64, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.conv2a = nn.Conv2d(in_channels=64, out_channels=128, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv2b = nn.Conv2d(in_channels=128, out_channels=128, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.conv3a = nn.Conv2d(in_channels=128, out_channels=256, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv3b = nn.Conv2d(in_channels=256, out_channels=256, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "\n",
+    "        self.bn1a = nn.BatchNorm2d(num_features=64)\n",
+    "        self.bn1b = nn.BatchNorm2d(num_features=64)\n",
+    "        self.bn2a = nn.BatchNorm2d(num_features=128)\n",
+    "        self.bn2b = nn.BatchNorm2d(num_features=128)\n",
+    "        self.bn3a = nn.BatchNorm2d(num_features=256)\n",
+    "        self.bn3b = nn.BatchNorm2d(num_features=256)\n",
+    "\n",
+    "        self.relu = nn.ReLU()\n",
+    "        \n",
+    "    def forward(self, x):\n",
+    "        x = self.relu(self.bn1a(self.conv1a(x)))\n",
+    "        x = self.relu(self.bn1b(self.conv1b(x)))\n",
+    "        x = self.relu(self.bn2a(self.conv2a(x)))\n",
+    "        x = self.relu(self.bn2b(self.conv2b(x)))\n",
+    "        x = self.relu(self.bn3a(self.conv3a(x)))\n",
+    "        x = self.relu(self.bn3b(self.conv3b(x)))\n",
+    "\n",
+    "        return x\n",
+    "\n",
+    "class DRD_Decode(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(DRD_Decode, self).__init__()\n",
+    "        self.convt1 = nn.ConvTranspose2d(in_channels=256, out_channels=128,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.convt2 = nn.ConvTranspose2d(in_channels=128, out_channels=64,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.convt3 = nn.ConvTranspose2d(in_channels=64, out_channels=32,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.prelu = nn.PReLU()\n",
+    "        self.sigmoid = nn.Sigmoid()\n",
+    "        self.upsample = nn.Upsample(size=(dimssnet_configs['range_size'],\n",
+    "                                          dimssnet_configs['doppler_size']), mode='nearest')\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.prelu(self.convt1(x))\n",
+    "        x = self.prelu(self.convt2(x))\n",
+    "        x = self.prelu(self.convt3(x))\n",
+    "\n",
+    "        return x"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "483a5ba6",
+   "metadata": {
+    "jupyter": {
+     "source_hidden": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "class DIMSSNet(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(DIMSSNet, self).__init__()\n",
+    "        self.encode_sra = SRA_Encode()\n",
+    "        self.decode_sra = SRA_Decode()\n",
+    "        self.encode_dra = DRA_Encode()\n",
+    "        self.decode_dra = DRA_Decode()\n",
+    "        self.encode_sre = SRE_Encode()\n",
+    "        self.decode_sre = SRE_Decode()\n",
+    "        self.encode_dre = DRE_Encode()\n",
+    "        self.decode_dre = DRE_Decode()\n",
+    "        self.encode_srd = SRD_Encode()\n",
+    "        self.decode_srd = SRD_Decode()\n",
+    "        self.encode_drd = DRD_Encode()\n",
+    "        self.decode_drd = DRD_Decode()\n",
+    "        self.fuse_fea = Fuse_fea()\n",
+    "        # self.fuse_fea = Fuse_fea_2D()\n",
+    "        \n",
+    "    def forward(self, x_sra, x_dra, x_sre, x_dre, x_srd, x_drd):\n",
+    "        x_sra = self.encode_sra(x_sra)\n",
+    "        feas_sra = self.decode_sra(x_sra)  # (B, 32, 50, 181)\n",
+    "        \n",
+    "        x_dra = self.encode_dra(x_dra)\n",
+    "        feas_dra = self.decode_dra(x_dra)  # (B, 32, 50, 181)\n",
+    "        \n",
+    "        x_sre = self.encode_sre(x_sre)\n",
+    "        feas_sre = self.decode_sre(x_sre)  # (B, 32, 50, 181)\n",
+    "        \n",
+    "        x_dre = self.encode_dre(x_dre)\n",
+    "        feas_dre = self.decode_dre(x_dre)  # (B, 32, 50, 181)\n",
+    "\n",
+    "        x_srd = self.encode_sre(x_srd)\n",
+    "        feas_srd = self.decode_sre(x_srd)  # (B, 32, 50, 181)\n",
+    "        \n",
+    "        x_drd = self.encode_dre(x_drd)\n",
+    "        feas_drd = self.decode_dre(x_drd)  # (B, 32, 50, 181)        \n",
+    "        \n",
+    "        feas = self.fuse_fea(feas_sra, feas_dra, feas_sre, feas_dre, feas_srd, feas_drd) # (B, 32, 50, 181)\n",
+    "\n",
+    "        return feas"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ddb913e6",
+   "metadata": {
+    "jupyter": {
+     "source_hidden": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "range_size=radar_configs['range_size']\n",
+    "azimuth_size=radar_configs['azimuth_size']\n",
+    "elevation_size=radar_configs['elevation_size']\n",
+    "\n",
+    "class Fuse_fea(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(Fuse_fea, self).__init__()\n",
+    "        self.convt1 = nn.Conv2d(in_channels=192, out_channels=96,\n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.convt2 = nn.Conv2d(in_channels=96, out_channels=48,\n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.convt3 = nn.Conv2d(in_channels=48, out_channels=24,\n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.convt4 = nn.Conv2d(in_channels=24, out_channels=n_class,\n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))        \n",
+    "        self.relu = nn.ReLU()\n",
+    "        self.sigmoid = nn.Sigmoid()\n",
+    "\n",
+    "    def forward(self, feas_sra, feas_dra, feas_sre, feas_dre, feas_srd, feas_drd):\n",
+    "        feas_sre = torch.sum(feas_sre, 3, keepdim=True) # (B, 32, 50, 181) -> (B, 32, 50, 1)\n",
+    "        feas_sre = feas_sre.expand(-1, -1, -1, azimuth_size)\n",
+    "        \n",
+    "        feas_dre = torch.sum(feas_dre, 3, keepdim=True)  # (B, 32, 50, 181) -> (B, 32, 50, 1)\n",
+    "        feas_dre = feas_dre.expand(-1, -1, -1, azimuth_size)\n",
+    "\n",
+    "        feas_srd = torch.sum(feas_srd, 3, keepdim=True)  # (B, 32, 50, 181) -> (B, 32, 50, 1)\n",
+    "        feas_srd = feas_srd.expand(-1, -1, -1, azimuth_size)\n",
+    "\n",
+    "        feas_drd = torch.sum(feas_drd, 3, keepdim=True)  # (B, 32, 50, 181) -> (B, 32, 50, 1)\n",
+    "        feas_drd = feas_drd.expand(-1, -1, -1, azimuth_size)\n",
+    "\n",
+    "        # Resize using bilinear interpolation\n",
+    "        feas_sra = F.interpolate(feas_sra, size=(range_size, azimuth_size), mode='bilinear', align_corners=False)\n",
+    "        feas_dra = F.interpolate(feas_dra, size=(range_size, azimuth_size), mode='bilinear', align_corners=False)\n",
+    "        feas_sre = F.interpolate(feas_sre, size=(range_size, azimuth_size), mode='bilinear', align_corners=False)\n",
+    "        feas_dre = F.interpolate(feas_dre, size=(range_size, azimuth_size), mode='bilinear', align_corners=False)\n",
+    "        feas_srd = F.interpolate(feas_srd, size=(range_size, azimuth_size), mode='bilinear', align_corners=False)\n",
+    "        feas_drd = F.interpolate(feas_drd, size=(range_size, azimuth_size), mode='bilinear', align_corners=False)\n",
+    "        \n",
+    "        feas_ra = torch.cat((feas_sra, feas_dra, feas_sre, feas_dre, feas_srd, feas_drd), 1) # 6*(B, 32, 50, 181) -> (B, 192, 50, 181)\n",
+    "\n",
+    "        x = self.relu(self.convt1(feas_ra))  # (B, 192, 50, 181) -> (B, 96, 50, 181)\n",
+    "        x = self.relu(self.convt2(x))  # (B, 96, 50, 181) -> (B, 48, 50, 181)\n",
+    "        x = self.relu(self.convt3(x))  # (B, 48, 50, 181) -> (B, 24, 50, 181)        \n",
+    "        x = self.sigmoid(self.convt4(x))  # (B, 24, 50, 181) -> (B, 5, 50, 181)\n",
+    "        \n",
+    "        return x\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b8d86ece",
+   "metadata": {},
+   "source": [
+    "## Utils"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "49705a8f",
+   "metadata": {
+    "jupyter": {
+     "source_hidden": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import scipy.io\n",
+    "import numpy as np\n",
+    "\n",
+    "# Define the target size\n",
+    "TARGET_HEIGHT = 50\n",
+    "TARGET_WIDTH = 181\n",
+    "\n",
+    "def load_raw_data(file_path):\n",
+    "    data = scipy.io.loadmat(file_path)\n",
+    "\n",
+    "    # Range-Azimuth Static\n",
+    "    range_az_static = data['range_az_static']\n",
+    "    range_az_static_prob = data['range_az_music_average_static_probability']\n",
+    "    range_az_static_class2_prob = range_az_static_prob[:, :, 1]  # 椅子的概率\n",
+    "\n",
+    "    # Range-Elevation Static\n",
+    "    range_ele_static = data['range_ele_static_all']\n",
+    "\n",
+    "    # Range-Azimuth Dynamic\n",
+    "    range_az_dynamic = data['range_az_dynamic']\n",
+    "    range_az_dynamic_prob = data['range_az_music_average_dynamic_probability']\n",
+    "    range_az_dynamic_class1_prob = range_az_dynamic_prob[:, :, 0]  # 人的概率\n",
+    "\n",
+    "    # Range-Elevation Dynamic\n",
+    "    range_ele_dynamic = data['range_ele_dynamic_all'] \n",
+    "\n",
+    "    return [range_az_static, range_az_dynamic, range_ele_static,\n",
+    "            range_ele_dynamic, range_az_dynamic_class1_prob, range_az_static_class2_prob]\n",
+    "\n",
+    "def generate_parameter():\n",
+    "    parameter = {\n",
+    "        'c': 3e8,  # the speed of light\n",
+    "        'start_freq': 77e9,  # starting frequency\n",
+    "        'tr': 60e-6,  # Sweeping time, that is, the cycle\n",
+    "        'samples': 256,  # sampling point\n",
+    "        'fs': 10e6,  # Sampling rate\n",
+    "        'tframe_set': 80e-3,  # Frame period\n",
+    "        'range_bin': 256,  # range bin\n",
+    "        'chirps': 128,  # chirp number\n",
+    "        'doppler_bin': 128,  # doppler bin\n",
+    "        'slope': 29.982e12,  # chirp slope\n",
+    "        'bandwidth': 29.982e12 * 60e-6,  # Effective bandwidth of the transmitted signal\n",
+    "        'bandwidth_valid': 256 / 10e6 * 29.982e12,  # Transmission signal bandwidth\n",
+    "        'center_freq': 77e9 + (29.982e12 * 60e-6) / 2,  # center frequency\n",
+    "        'lambda': 3e8 / (77e9 + (29.982e12 * 60e-6) / 2),  # wavelength\n",
+    "        'tx_antenna': [1, 1, 1],  # The number of transmitting antennas\n",
+    "        'rx_antenna': [1, 1, 1, 1],  # Number of receiving antennas\n",
+    "        'tx_num': 3,  # The number of transmitting antennas\n",
+    "        'rx_num': 4,  # The number of receiving antennas\n",
+    "        'virtual_antenna': 12,  # Number of virtual antennas\n",
+    "        'dz': (3e8 / (77e9 + (29.982e12 * 60e-6) / 2)) / 2,  # Pitch spacing of the receiving antenna\n",
+    "        'dx': (3e8 / (77e9 + (29.982e12 * 60e-6) / 2)) / 2,  # Horizontal spacing of receiving antennas\n",
+    "        'num_cpi': 50,  # 帧数\n",
+    "    }\n",
+    "    return parameter\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c266f24b",
+   "metadata": {},
+   "source": [
+    "## Dataloaders"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "892cfb3a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from torch.utils.data import Dataset, DataLoader\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "\n",
+    "class CustomDataset(Dataset):\n",
+    "    def __init__(self, file_paths, transform=None):\n",
+    "        self.file_paths = file_paths\n",
+    "        self.transform = transform\n",
+    "        self.file_names = [os.path.basename(path) for path in file_paths]\n",
+    "\n",
+    "    def __len__(self):\n",
+    "        return len(self.file_paths)\n",
+    "\n",
+    "    def __getitem__(self, idx):\n",
+    "        data = torch.load(self.file_paths[idx], weights_only=True)\n",
+    "        \n",
+    "        images = data[:6]  #first 6 channels are the heatmaps\n",
+    "        labels = data[6]   #last channel is the label\n",
+    "        \n",
+    "        images = images.float()  \n",
+    "        labels = labels.long()   \n",
+    "        labels = labels + 1     #labels are -1 to 3, add 1 to make them 0 to 4\n",
+    "\n",
+    "        if self.transform:\n",
+    "            images = self.transform(images)\n",
+    "            labels = self.transform(labels)\n",
+    "        \n",
+    "        return images, labels, self.file_names[idx]\n",
+    "\n",
+    "class CustomDataset_test(Dataset):\n",
+    "    def __init__(self, file_paths, transform=None):\n",
+    "        self.file_paths = file_paths\n",
+    "        self.transform = transform\n",
+    "        self.file_names = [os.path.basename(path) for path in file_paths]\n",
+    "\n",
+    "    def __len__(self):\n",
+    "        return len(self.file_paths)\n",
+    "\n",
+    "    def __getitem__(self, idx):\n",
+    "        data = torch.load(self.file_paths[idx], weights_only=True)\n",
+    "        \n",
+    "        images = data[:6] #only load first 6 channels, labels are not in val_set and test_set\n",
+    "        \n",
+    "        images = images.float()  \n",
+    "\n",
+    "        if self.transform:\n",
+    "            images = self.transform(images)\n",
+    "        \n",
+    "        return images, self.file_names[idx]\n",
+    "\n",
+    "# extend base_path to file_path\n",
+    "def generate_file_paths(base_path):\n",
+    "    file_paths = []\n",
+    "    for frame in os.listdir(base_path):\n",
+    "        frame_path = os.path.join(base_path, frame)\n",
+    "        if frame_path.endswith('.mat.pt'):\n",
+    "            file_paths.append(frame_path)\n",
+    "    return [path for path in file_paths if os.path.exists(path)]\n",
+    "\n",
+    "def load_data(base_path, batch_size=4, num_workers=2, test_size=0.2):\n",
+    "    file_paths = generate_file_paths(base_path)\n",
+    "    \n",
+    "    train_paths, test_paths = train_test_split(file_paths, test_size=test_size, random_state=42)\n",
+    "    \n",
+    "    train_dataset = CustomDataset(file_paths=train_paths)\n",
+    "    test_dataset = CustomDataset(file_paths=test_paths)\n",
+    "    \n",
+    "    train_loader = DataLoader(\n",
+    "        train_dataset, \n",
+    "        batch_size=batch_size, \n",
+    "        shuffle=True, \n",
+    "        num_workers=num_workers, \n",
+    "        drop_last=True\n",
+    "    )\n",
+    "    \n",
+    "    test_loader = DataLoader(\n",
+    "        test_dataset, \n",
+    "        batch_size=batch_size, \n",
+    "        shuffle=False, \n",
+    "        num_workers=num_workers, \n",
+    "        drop_last=True\n",
+    "    )\n",
+    "    \n",
+    "    return train_loader, test_loader\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "67cd6c15",
+   "metadata": {},
+   "source": [
+    "## Loss Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4c573803",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Used to handle the problem of class imbalance\n",
+    "\n",
+    "def to_one_hot(tensor, nClasses):\n",
+    "    n, h, w = tensor.size()\n",
+    "    one_hot = torch.zeros(n, nClasses, h, w, device=tensor.device)\n",
+    "    index_tensor = tensor.long().view(n, 1, h, w)\n",
+    "    one_hot = one_hot.scatter_(1, index_tensor, 1)\n",
+    "    return one_hot\n",
+    "\n",
+    "def _neg_loss(pred, gt):\n",
+    "    pred = torch.clamp(pred, 1e-5, 1-1e-5)\n",
+    "\n",
+    "    pos_inds = gt.eq(1).float()\n",
+    "    neg_inds = gt.eq(0).float()\n",
+    "\n",
+    "    balance_cof = 1.0\n",
+    "    pos_loss = torch.log(pred) * torch.pow(1 - pred, 2) * pos_inds * balance_cof\n",
+    "    neg_loss = torch.log(1 - pred) * torch.pow(pred, 2) * neg_inds\n",
+    "    num_pos = pos_inds.float().sum()\n",
+    "    pos_loss_sum = pos_loss.sum()\n",
+    "    neg_loss_sum = neg_loss.sum()\n",
+    "    if num_pos == 0:\n",
+    "        loss = -neg_loss_sum\n",
+    "    else:\n",
+    "        loss = -(pos_loss_sum + neg_loss_sum) / num_pos\n",
+    "    return loss\n",
+    "\n",
+    "class FocalLoss(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(FocalLoss, self).__init__()\n",
+    "        self.neg_loss = _neg_loss\n",
+    "\n",
+    "    def forward(self, out, target):\n",
+    "        return self.neg_loss(out, target)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dec2b582",
+   "metadata": {},
+   "source": [
+    "## Train"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7c2f0301",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch.optim as optim\n",
+    "import matplotlib.pyplot as plt\n",
+    "import time\n",
+    "\n",
+    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+    "\n",
+    "num_epochs = 20\n",
+    "\n",
+    "base_path = '/bohr/train-22pn/v2/training_set'\n",
+    "train_loader, test_loader = load_data(\n",
+    "    base_path=base_path,\n",
+    "    batch_size=4,\n",
+    "    num_workers=2,\n",
+    "    test_size=0.2\n",
+    ")\n",
+    "\n",
+    "dimssnet = DIMSSNet().to(device)\n",
+    "criterion = FocalLoss()\n",
+    "optimizer = optim.Adam(dimssnet.parameters(), lr=0.001)\n",
+    "start_time = time.time()\n",
+    "test_loss_record = []\n",
+    "train_loss_record = []\n",
+    "\n",
+    "for epoch in range(num_epochs):\n",
+    "    dimssnet.train()\n",
+    "    running_loss = 0.0\n",
+    "    for images, labels, _ in train_loader:\n",
+    "        images = images.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "        \n",
+    "        images = [image.unsqueeze(1) for image in images]\n",
+    "        images = torch.stack(images, dim=0)\n",
+    "        images = images.float()\n",
+    "        \n",
+    "        outputs = dimssnet(images[:, 0, :, :], images[:, 1, :, :], images[:, 2, :, :],\n",
+    "                            images[:, 3, :, :], images[:, 4, :, :], images[:, 5, :, :])\n",
+    "\n",
+    "        outputs_resized = F.interpolate(outputs, size=(TARGET_HEIGHT, TARGET_WIDTH), mode='bilinear', align_corners=False)\n",
+    "        labels = to_one_hot(labels, n_class)\n",
+    "        \n",
+    "        loss = criterion(outputs_resized, labels.long())\n",
+    "        optimizer.zero_grad()\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        \n",
+    "        running_loss += loss.item()\n",
+    "\n",
+    "    test_loss = 0.0\n",
+    "    dimssnet.eval()\n",
+    "    with torch.no_grad():\n",
+    "        for images, labels, _ in test_loader:\n",
+    "            images = images.to(device)\n",
+    "            labels = labels.to(device)\n",
+    "            \n",
+    "            images = [image.unsqueeze(1) for image in images]\n",
+    "            images = torch.stack(images, dim=0)\n",
+    "            images = images.float()\n",
+    "            \n",
+    "            outputs = dimssnet(images[:, 0, :, :], images[:, 1, :, :], images[:, 2, :, :],\n",
+    "                                images[:, 3, :, :], images[:, 4, :, :], images[:, 5, :, :])\n",
+    "            \n",
+    "            outputs_resized = F.interpolate(outputs, size=(TARGET_HEIGHT, TARGET_WIDTH), mode='bilinear', align_corners=False)\n",
+    "            labels = to_one_hot(labels, n_class)\n",
+    "            \n",
+    "            loss = criterion(outputs_resized, labels.long())\n",
+    "            test_loss += loss.item()\n",
+    "    \n",
+    "    test_loss_record.append(test_loss/len(test_loader))\n",
+    "    train_loss_record.append(running_loss/len(train_loader))\n",
+    "    print(f\"Epoch {epoch+1}/{num_epochs}, Training Loss: {running_loss/len(train_loader):.4f}, Test Loss: {test_loss/len(test_loader):.4f}\")\n",
+    "\n",
+    "# Create a new state_dict and add the \"model\" prefix, in order to match the loading method in metrics\n",
+    "new_state_dict = {}\n",
+    "for k, v in dimssnet.state_dict().items():\n",
+    "    new_key = f\"model.{k}\" \n",
+    "    new_state_dict[new_key] = v\n",
+    "\n",
+    "print(\"dimssnet successfully saved!\")    \n",
+    "print(\"Training finished.\")\n",
+    "end_time = time.time()\n",
+    "total_time = end_time - start_time\n",
+    "print(f\"Training completed in {total_time} seconds\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f001aee8",
+   "metadata": {},
+   "source": [
+    "## Inference"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8b330819",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Run inference on validation set and testing set\n",
+    "import pandas as pd\n",
+    "\n",
+    "def run_inference(model, data_loader):\n",
+    "    model.eval()\n",
+    "    predictions = []\n",
+    "    filenames = []\n",
+    "    \n",
+    "    with torch.no_grad():\n",
+    "        for images, file_names in data_loader:\n",
+    "            images = images.cuda() if torch.cuda.is_available() else images\n",
+    "            \n",
+    "            x = [image.unsqueeze(1) for image in images]\n",
+    "            x = torch.stack(x, dim=0)\n",
+    "            x = x.float()\n",
+    "            \n",
+    "            # Forward propagation\n",
+    "            outputs = model(x[:, 0, :, :], x[:, 1, :, :], x[:, 2, :, :],\n",
+    "                            x[:, 3, :, :], x[:, 4, :, :], x[:, 5, :, :])\n",
+    "            \n",
+    "            # Adjust the output size\n",
+    "            outputs = F.interpolate(outputs, size=(50, 181), mode='bilinear', align_corners=False)\n",
+    "\n",
+    "            preds = torch.argmax(outputs, dim=1)\n",
+    "            \n",
+    "            preds = preds - 1\n",
+    "            \n",
+    "            for i, pred in enumerate(preds):\n",
+    "                predictions.append(pred.cpu().numpy().flatten())\n",
+    "                filenames.append(file_names[i])\n",
+    "    \n",
+    "    return predictions, filenames\n",
+    "\n",
+    "# Load validation set\n",
+    "if os.environ.get('DATA_PATH'):\n",
+    "    DATA_PATH = os.environ.get(\"DATA_PATH\") + \"/\" \n",
+    "else:\n",
+    "    DATA_PATH = \"\"  # Fallback for local testing\n",
+    "# Load validation set\n",
+    "val_paths = generate_file_paths(DATA_PATH + 'validation_set')\n",
+    "val_dataset = CustomDataset_test(file_paths=val_paths)\n",
+    "val_loader = DataLoader(\n",
+    "    val_dataset,\n",
+    "    batch_size=1,\n",
+    "    shuffle=False,\n",
+    "    num_workers=0\n",
+    ")\n",
+    "\n",
+    "# Load testing set\n",
+    "if os.environ.get('DATA_PATH'):\n",
+    "    DATA_PATH = os.environ.get(\"DATA_PATH\") + \"/\" \n",
+    "else:\n",
+    "    DATA_PATH = \"\"  # Fallback for local testing\n",
+    "# Load testing set\n",
+    "test_paths = generate_file_paths(DATA_PATH + 'testing_set')\n",
+    "test_dataset = CustomDataset_test(file_paths=test_paths)\n",
+    "test_loader = DataLoader(\n",
+    "    test_dataset,\n",
+    "    batch_size=1,\n",
+    "    shuffle=False,\n",
+    "    num_workers=0\n",
+    ")\n",
+    "\n",
+    "# Run inference on validation set\n",
+    "print(\"Running inference on validation set...\")\n",
+    "val_predictions, val_filenames = run_inference(dimssnet, val_loader)\n",
+    "\n",
+    "# Save validation results to CSV\n",
+    "val_results = []\n",
+    "for filename, pred in zip(val_filenames, val_predictions):\n",
+    "    # Create a row with filename and flattened predictions\n",
+    "    row = {'filename': filename}\n",
+    "    for i, p in enumerate(pred):\n",
+    "        row[f'pixel_{i}'] = p\n",
+    "    val_results.append(row)\n",
+    "\n",
+    "val_df = pd.DataFrame(val_results)\n",
+    "val_df.to_csv('submission_val.csv', index=False)\n",
+    "print(f\"Validation results saved to output_validation.csv with shape: {val_df.shape}\")\n",
+    "\n",
+    "# Run inference on testing set\n",
+    "print(\"Running inference on testing set...\")\n",
+    "test_predictions, test_filenames = run_inference(dimssnet, test_loader)\n",
+    "\n",
+    "# Save testing results to CSV\n",
+    "test_results = []\n",
+    "for filename, pred in zip(test_filenames, test_predictions):\n",
+    "    # Create a row with filename and flattened predictions\n",
+    "    row = {'filename': filename}\n",
+    "    for i, p in enumerate(pred):\n",
+    "        row[f'pixel_{i}'] = p\n",
+    "    test_results.append(row)\n",
+    "\n",
+    "test_df = pd.DataFrame(test_results)\n",
+    "test_df.to_csv('submission_test.csv', index=False)\n",
+    "print(f\"Testing results saved to output_testing.csv with shape: {test_df.shape}\")\n",
+    "\n",
+    "print(\"\\nInference completed! Results saved to:\")\n",
+    "print(\"- submission_val_ref.csv (for validation set leaderboard)\")\n",
+    "print(\"- submission_test_ref.csv (for testing set leaderboard)\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "72fde72d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import zipfile\n",
+    "import os\n",
+    "\n",
+    "# Define the files to zip and the zip file name.\n",
+    "files_to_zip = ['submission_val.csv', 'submission_test.csv']\n",
+    "zip_filename = 'submission.zip'\n",
+    "\n",
+    "# Create a zip file\n",
+    "with zipfile.ZipFile(zip_filename, 'w') as zipf:\n",
+    "    for file in files_to_zip:\n",
+    "        # Add the file to the zip fil\n",
+    "        zipf.write(file, os.path.basename(file))\n",
+    "\n",
+    "print(f'{zip_filename} Created successfully!')"
+   ]
+  }
+ ],
+ "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.12.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

benchmark/IOL/ioling_hf/evals/results/HuggingFaceTB__SmolLM3-3B__diverse5.scores.jsonl

@@ -0,0 +1,5 @@
+{"record_id": "iol-2006-individual-p1-sub-assignment_1", "score": 0.0, "max_score": 4.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["assignment_1.1", "assignment_1.2", "assignment_1.3", "assignment_1.4"], "unit_results": [{"unit_id": "assignment_1.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 39.437, "full_output_similarity": 75.0}, {"unit_id": "assignment_1.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 39.286, "full_output_similarity": 75.758}, {"unit_id": "assignment_1.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 41.667, "full_output_similarity": 56.818}, {"unit_id": "assignment_1.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 46.154, "full_output_similarity": 85.714}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "HuggingFaceTB/SmolLM3-3B"}
+{"record_id": "iol-2011-individual-p1-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 48.5, "full_output_similarity": 48.5}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "HuggingFaceTB/SmolLM3-3B"}
+{"record_id": "iol-2015-individual-p5-sub-b", "score": 0.0, "max_score": 9.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["b.1", "b.2", "b.3", "b.4", "b.5", "b.6", "b.7", "b.8", "b.9"], "unit_results": [{"unit_id": "b.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 21.739, "full_output_similarity": 77.778}, {"unit_id": "b.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 21.053, "full_output_similarity": 82.609}, {"unit_id": "b.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 21.739, "full_output_similarity": 77.778}, {"unit_id": "b.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 23.256, "full_output_similarity": 75.0}, {"unit_id": "b.5", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 20.513, "full_output_similarity": 75.0}, {"unit_id": "b.6", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 25.0, "full_output_similarity": 75.862}, {"unit_id": "b.7", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 22.727, "full_output_similarity": 80.0}, {"unit_id": "b.8", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 24.561, "full_output_similarity": 70.0}, {"unit_id": "b.9", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 21.739, "full_output_similarity": 77.778}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "HuggingFaceTB/SmolLM3-3B"}
+{"record_id": "iol-2021-individual-p2-sub-a", "score": 0.0, "max_score": 9.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1", "a.2", "a.3", "a.4", "a.5", "a.6", "a.7", "a.8", "a.9"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 25.197, "full_output_similarity": 48.718}, {"unit_id": "a.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 30.0, "full_output_similarity": 66.667}, {"unit_id": "a.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 31.25, "full_output_similarity": 70.0}, {"unit_id": "a.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 25.0, "full_output_similarity": 89.286}, {"unit_id": "a.5", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 31.579, "full_output_similarity": 60.606}, {"unit_id": "a.6", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 27.586, "full_output_similarity": 73.333}, {"unit_id": "a.7", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 30.769, "full_output_similarity": 77.778}, {"unit_id": "a.8", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 29.032, "full_output_similarity": 67.742}, {"unit_id": "a.9", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 28.571, "full_output_similarity": 77.778}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "HuggingFaceTB/SmolLM3-3B"}
+{"record_id": "iol-2025-team-p1-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 32.738, "full_output_similarity": 32.738}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "HuggingFaceTB/SmolLM3-3B"}

benchmark/IOL/ioling_hf/evals/results/Qwen__Qwen2.5-3B-Instruct__diverse5.scores.jsonl

@@ -0,0 +1,5 @@
+{"record_id": "iol-2006-individual-p1-sub-assignment_1", "score": 0.0, "max_score": 4.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["assignment_1.1", "assignment_1.2", "assignment_1.3", "assignment_1.4"], "unit_results": [{"unit_id": "assignment_1.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 92.5}, {"unit_id": "assignment_1.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 84.848}, {"unit_id": "assignment_1.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 54.545}, {"unit_id": "assignment_1.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 78.571}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "Qwen/Qwen2.5-3B-Instruct"}
+{"record_id": "iol-2011-individual-p1-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 49.0, "full_output_similarity": 49.0}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "Qwen/Qwen2.5-3B-Instruct"}
+{"record_id": "iol-2015-individual-p5-sub-b", "score": 0.0, "max_score": 9.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["b.1", "b.2", "b.3", "b.4", "b.5", "b.6", "b.7", "b.8", "b.9"], "unit_results": [{"unit_id": "b.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 22.857, "full_output_similarity": 77.778}, {"unit_id": "b.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 22.222, "full_output_similarity": 82.609}, {"unit_id": "b.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 20.0, "full_output_similarity": 77.778}, {"unit_id": "b.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 25.0, "full_output_similarity": 75.0}, {"unit_id": "b.5", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 22.222, "full_output_similarity": 75.0}, {"unit_id": "b.6", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 25.0, "full_output_similarity": 75.862}, {"unit_id": "b.7", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 22.222, "full_output_similarity": 52.0}, {"unit_id": "b.8", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 24.242, "full_output_similarity": 50.0}, {"unit_id": "b.9", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 22.222, "full_output_similarity": 77.778}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "Qwen/Qwen2.5-3B-Instruct"}
+{"record_id": "iol-2021-individual-p2-sub-a", "score": 0.0, "max_score": 9.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1", "a.2", "a.3", "a.4", "a.5", "a.6", "a.7", "a.8", "a.9"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 30.769, "full_output_similarity": 46.154}, {"unit_id": "a.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 33.333, "full_output_similarity": 66.667}, {"unit_id": "a.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 34.483, "full_output_similarity": 70.0}, {"unit_id": "a.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 28.571, "full_output_similarity": 89.286}, {"unit_id": "a.5", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 36.364, "full_output_similarity": 60.606}, {"unit_id": "a.6", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 35.714, "full_output_similarity": 73.333}, {"unit_id": "a.7", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 33.333, "full_output_similarity": 77.778}, {"unit_id": "a.8", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 35.484, "full_output_similarity": 67.742}, {"unit_id": "a.9", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 32.787, "full_output_similarity": 75.0}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "Qwen/Qwen2.5-3B-Instruct"}
+{"record_id": "iol-2025-team-p1-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 32.143, "full_output_similarity": 36.31}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "Qwen/Qwen2.5-3B-Instruct"}

benchmark/IOL/ioling_hf/evals/results/google__gemma-3-12b-it__diverse5.scores.jsonl

@@ -0,0 +1,5 @@
+{"record_id": "iol-2006-individual-p1-sub-assignment_1", "score": 0.0, "max_score": 4.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["assignment_1.1", "assignment_1.2", "assignment_1.3", "assignment_1.4"], "unit_results": [{"unit_id": "assignment_1.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 80.0, "full_output_similarity": 80.0}, {"unit_id": "assignment_1.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 75.758, "full_output_similarity": 75.758}, {"unit_id": "assignment_1.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 51.19, "full_output_similarity": 51.19}, {"unit_id": "assignment_1.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 72.727, "full_output_similarity": 72.727}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2011-individual-p1-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 57.0, "full_output_similarity": 50.98}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2015-individual-p5-sub-b", "score": 0.0, "max_score": 9.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["b.1", "b.2", "b.3", "b.4", "b.5", "b.6", "b.7", "b.8", "b.9"], "unit_results": [{"unit_id": "b.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 29.63, "full_output_similarity": 77.778}, {"unit_id": "b.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 30.435, "full_output_similarity": 82.609}, {"unit_id": "b.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 29.787, "full_output_similarity": 77.778}, {"unit_id": "b.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 29.167, "full_output_similarity": 75.0}, {"unit_id": "b.5", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 25.532, "full_output_similarity": 75.0}, {"unit_id": "b.6", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 31.034, "full_output_similarity": 75.862}, {"unit_id": "b.7", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 32.0, "full_output_similarity": 80.0}, {"unit_id": "b.8", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 30.0, "full_output_similarity": 70.0}, {"unit_id": "b.9", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 29.63, "full_output_similarity": 77.778}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2021-individual-p2-sub-a", "score": 0.0, "max_score": 9.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1", "a.2", "a.3", "a.4", "a.5", "a.6", "a.7", "a.8", "a.9"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 50.0, "full_output_similarity": 50.0}, {"unit_id": "a.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 66.667, "full_output_similarity": 66.667}, {"unit_id": "a.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 70.0, "full_output_similarity": 70.0}, {"unit_id": "a.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 89.286, "full_output_similarity": 89.286}, {"unit_id": "a.5", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 60.606, "full_output_similarity": 60.606}, {"unit_id": "a.6", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 73.333, "full_output_similarity": 73.333}, {"unit_id": "a.7", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 77.778, "full_output_similarity": 77.778}, {"unit_id": "a.8", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 67.742, "full_output_similarity": 67.742}, {"unit_id": "a.9", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 75.0, "full_output_similarity": 75.0}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2025-team-p1-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 44.444, "full_output_similarity": 28.571}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}

benchmark/IOL/ioling_hf/evals/results/google__gemma-3-12b-it__strict30.scores.jsonl

@@ -0,0 +1,30 @@
+{"record_id": "iol-2006-individual-p1-sub-assignment_1", "score": 0.0, "max_score": 4.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["assignment_1.1", "assignment_1.2", "assignment_1.3", "assignment_1.4"], "unit_results": [{"unit_id": "assignment_1.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 81.013, "full_output_similarity": 80.0}, {"unit_id": "assignment_1.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 75.758, "full_output_similarity": 75.758}, {"unit_id": "assignment_1.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 55.682, "full_output_similarity": 55.682}, {"unit_id": "assignment_1.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 74.074, "full_output_similarity": 71.429}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2006-individual-p5", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["full.1"], "unit_results": [{"unit_id": "full.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 52.83, "full_output_similarity": 45.879}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2007-individual-p5", "score": 0.0, "max_score": 4.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["full.1", "full.2", "full.3", "full.4"], "unit_results": [{"unit_id": "full.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 41.379, "full_output_similarity": 65.517}, {"unit_id": "full.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 43.333, "full_output_similarity": 45.714}, {"unit_id": "full.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 47.826, "full_output_similarity": 56.522}, {"unit_id": "full.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 44.444, "full_output_similarity": 45.161}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2008-individual-p2-sub-b", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["b.1"], "unit_results": [{"unit_id": "b.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 34.703, "full_output_similarity": 47.953}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2008-team-p1-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 44.646, "full_output_similarity": 46.552}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2009-individual-p4-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 53.927, "full_output_similarity": 53.927}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2010-individual-p2-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 86.653, "full_output_similarity": 86.885}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2010-team-p1", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["full.1"], "unit_results": [{"unit_id": "full.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 39.037, "full_output_similarity": 35.579}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2011-individual-p3-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 51.667, "full_output_similarity": 79.137}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2012-individual-p1-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 33.333, "full_output_similarity": 46.377}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2012-individual-p5-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 82.796, "full_output_similarity": 80.412}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2013-individual-p3", "score": 0.0, "max_score": 5.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["full.1", "full.2", "full.3", "full.4", "full.5"], "unit_results": [{"unit_id": "full.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 50.0, "full_output_similarity": 66.667}, {"unit_id": "full.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 31.765, "full_output_similarity": 47.059}, {"unit_id": "full.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 27.5, "full_output_similarity": 43.75}, {"unit_id": "full.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 26.846, "full_output_similarity": 40.0}, {"unit_id": "full.5", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 29.885, "full_output_similarity": 55.172}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2014-individual-p2", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["full.1"], "unit_results": [{"unit_id": "full.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 66.667, "full_output_similarity": 66.667}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2014-individual-p5-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 44.531, "full_output_similarity": 48.59}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2015-individual-p3-sub-a", "score": 0.0, "max_score": 5.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1", "a.2", "a.3", "a.4", "a.5"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 60.0, "full_output_similarity": 60.0}, {"unit_id": "a.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 49.367, "full_output_similarity": 50.633}, {"unit_id": "a.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 48.571, "full_output_similarity": 52.857}, {"unit_id": "a.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 70.27, "full_output_similarity": 72.973}, {"unit_id": "a.5", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 51.25, "full_output_similarity": 53.75}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2016-individual-p1", "score": 0.0, "max_score": 15.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["full.1", "full.2", "full.3", "full.4", "full.5", "full.6", "full.7", "full.8", "full.9", "full.10", "full.11", "full.12", "full.13", "full.14", "full.15"], "unit_results": [{"unit_id": "full.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 16.216, "full_output_similarity": 74.468}, {"unit_id": "full.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 16.667, "full_output_similarity": 84.444}, {"unit_id": "full.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 17.143, "full_output_similarity": 75.0}, {"unit_id": "full.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 17.647, "full_output_similarity": 73.171}, {"unit_id": "full.5", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 16.216, "full_output_similarity": 77.778}, {"unit_id": "full.6", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 16.438, "full_output_similarity": 73.171}, {"unit_id": "full.7", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 16.216, "full_output_similarity": 77.083}, {"unit_id": "full.8", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 16.901, "full_output_similarity": 79.487}, {"unit_id": "full.9", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 16.667, "full_output_similarity": 83.333}, {"unit_id": "full.10", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 16.667, "full_output_similarity": 72.5}, {"unit_id": "full.11", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 16.667, "full_output_similarity": 73.81}, {"unit_id": "full.12", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 16.901, "full_output_similarity": 77.273}, {"unit_id": "full.13", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 16.901, "full_output_similarity": 69.048}, {"unit_id": "full.14", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 16.216, "full_output_similarity": 75.0}, {"unit_id": "full.15", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 16.216, "full_output_similarity": 76.596}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2016-individual-p5-sub-a", "score": 0.0, "max_score": 2.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1", "a.2"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 53.659, "full_output_similarity": 60.87}, {"unit_id": "a.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 53.125, "full_output_similarity": 56.25}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2017-individual-p2-sub-a", "score": 0.0, "max_score": 16.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1", "a.2", "a.3", "a.4", "a.5", "a.6", "a.7", "a.8", "a.9", "a.10", "a.11", "a.12", "a.13", "a.14", "a.15", "a.16"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 25.21, "full_output_similarity": 62.295}, {"unit_id": "a.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 24.528, "full_output_similarity": 66.038}, {"unit_id": "a.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 26.667, "full_output_similarity": 83.333}, {"unit_id": "a.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 25.688, "full_output_similarity": 65.079}, {"unit_id": "a.5", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 26.829, "full_output_similarity": 95.122}, {"unit_id": "a.6", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 26.19, "full_output_similarity": 52.381}, {"unit_id": "a.7", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 29.787, "full_output_similarity": 52.0}, {"unit_id": "a.8", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 36.842, "full_output_similarity": 73.684}, {"unit_id": "a.9", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 25.714, "full_output_similarity": 68.571}, {"unit_id": "a.10", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 33.333, "full_output_similarity": 77.778}, {"unit_id": "a.11", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 28.0, "full_output_similarity": 92.0}, {"unit_id": "a.12", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 26.667, "full_output_similarity": 72.0}, {"unit_id": "a.13", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 29.268, "full_output_similarity": 80.488}, {"unit_id": "a.14", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 23.256, "full_output_similarity": 51.163}, {"unit_id": "a.15", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 27.273, "full_output_similarity": 52.273}, {"unit_id": "a.16", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 30.0, "full_output_similarity": 76.667}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2017-team-p1", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["full.1"], "unit_results": [{"unit_id": "full.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 45.161, "full_output_similarity": 71.398}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2018-individual-p4-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 31.944, "full_output_similarity": 40.278}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2019-individual-p2-sub-a", "score": 0.0, "max_score": 17.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1", "a.2", "a.3", "a.4", "a.5", "a.6", "a.7", "a.8", "a.9", "a.10", "a.11", "a.12", "a.13", "a.14", "a.15", "a.16", "a.17"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 20.93, "full_output_similarity": 72.093}, {"unit_id": "a.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 25.0, "full_output_similarity": 69.697}, {"unit_id": "a.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 25.532, "full_output_similarity": 68.571}, {"unit_id": "a.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 22.5, "full_output_similarity": 70.0}, {"unit_id": "a.5", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 26.923, "full_output_similarity": 65.385}, {"unit_id": "a.6", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 24.0, "full_output_similarity": 71.429}, {"unit_id": "a.7", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 25.0, "full_output_similarity": 72.727}, {"unit_id": "a.8", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 26.471, "full_output_similarity": 76.471}, {"unit_id": "a.9", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 26.087, "full_output_similarity": 69.697}, {"unit_id": "a.10", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 21.429, "full_output_similarity": 63.415}, {"unit_id": "a.11", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 26.087, "full_output_similarity": 70.968}, {"unit_id": "a.12", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 26.087, "full_output_similarity": 66.667}, {"unit_id": "a.13", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 25.641, "full_output_similarity": 59.259}, {"unit_id": "a.14", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 22.857, "full_output_similarity": 75.61}, {"unit_id": "a.15", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 27.907, "full_output_similarity": 62.963}, {"unit_id": "a.16", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 25.532, "full_output_similarity": 68.75}, {"unit_id": "a.17", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 25.926, "full_output_similarity": 66.667}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2019-team-p1", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["full.1"], "unit_results": [{"unit_id": "full.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 48.485, "full_output_similarity": 77.582}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2021-individual-p3-sub-a", "score": 0.0, "max_score": 4.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1", "a.2", "a.3", "a.4"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 39.216, "full_output_similarity": 100.0}, {"unit_id": "a.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 30.435, "full_output_similarity": 100.0}, {"unit_id": "a.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 30.769, "full_output_similarity": 100.0}, {"unit_id": "a.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 38.71, "full_output_similarity": 100.0}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2022-individual-p1-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 73.684, "full_output_similarity": 86.486}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2022-individual-p5-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 50.0, "full_output_similarity": 66.667}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2023-individual-p3", "score": 0.0, "max_score": 13.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["full.1", "full.2", "full.3", "full.4", "full.5", "full.6", "full.7", "full.8", "full.9", "full.10", "full.11", "full.12", "full.13"], "unit_results": [{"unit_id": "full.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 87.5, "full_output_similarity": 87.5}, {"unit_id": "full.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 51.613, "full_output_similarity": 51.613}, {"unit_id": "full.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 55.556, "full_output_similarity": 55.556}, {"unit_id": "full.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 69.231, "full_output_similarity": 69.231}, {"unit_id": "full.5", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 45.714, "full_output_similarity": 45.714}, {"unit_id": "full.6", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 66.667, "full_output_similarity": 66.667}, {"unit_id": "full.7", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 64.583, "full_output_similarity": 64.583}, {"unit_id": "full.8", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 65.789, "full_output_similarity": 65.789}, {"unit_id": "full.9", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 55.102, "full_output_similarity": 55.102}, {"unit_id": "full.10", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 91.176, "full_output_similarity": 91.176}, {"unit_id": "full.11", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 82.353, "full_output_similarity": 82.353}, {"unit_id": "full.12", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 81.081, "full_output_similarity": 81.081}, {"unit_id": "full.13", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 83.333, "full_output_similarity": 83.333}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2024-individual-p1", "score": 0.0, "max_score": 17.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["full.1", "full.2", "full.3", "full.4", "full.5", "full.6", "full.7", "full.8", "full.9", "full.10", "full.11", "full.12", "full.13", "full.14", "full.15", "full.16", "full.17"], "unit_results": [{"unit_id": "full.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 32.258, "full_output_similarity": 45.161}, {"unit_id": "full.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 34.375, "full_output_similarity": 43.75}, {"unit_id": "full.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 35.0, "full_output_similarity": 47.5}, {"unit_id": "full.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 36.0, "full_output_similarity": 45.333}, {"unit_id": "full.5", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 33.333, "full_output_similarity": 55.556}, {"unit_id": "full.6", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 33.929, "full_output_similarity": 46.429}, {"unit_id": "full.7", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 30.303, "full_output_similarity": 48.485}, {"unit_id": "full.8", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 34.375, "full_output_similarity": 43.75}, {"unit_id": "full.9", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 32.857, "full_output_similarity": 44.737}, {"unit_id": "full.10", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 43.75, "full_output_similarity": 71.875}, {"unit_id": "full.11", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 51.852, "full_output_similarity": 62.963}, {"unit_id": "full.12", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 54.054, "full_output_similarity": 81.081}, {"unit_id": "full.13", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 50.0, "full_output_similarity": 86.667}, {"unit_id": "full.14", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 48.0, "full_output_similarity": 84.0}, {"unit_id": "full.15", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 51.064, "full_output_similarity": 67.742}, {"unit_id": "full.16", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 48.387, "full_output_similarity": 83.871}, {"unit_id": "full.17", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 50.0, "full_output_similarity": 83.333}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2024-individual-p4-sub-a", "score": 0.0, "max_score": 19.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1", "a.2", "a.3", "a.4", "a.5", "a.6", "a.7", "a.8", "a.9", "a.10", "a.11", "a.12", "a.13", "a.14", "a.15", "a.16", "a.17", "a.18", "a.19"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 33.962, "full_output_similarity": 54.545}, {"unit_id": "a.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 33.333, "full_output_similarity": 50.0}, {"unit_id": "a.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 27.66, "full_output_similarity": 55.556}, {"unit_id": "a.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 29.508, "full_output_similarity": 56.098}, {"unit_id": "a.5", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 29.358, "full_output_similarity": 48.529}, {"unit_id": "a.6", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 33.962, "full_output_similarity": 51.515}, {"unit_id": "a.7", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 28.571, "full_output_similarity": 63.636}, {"unit_id": "a.8", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 34.375, "full_output_similarity": 50.0}, {"unit_id": "a.9", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 30.137, "full_output_similarity": 54.348}, {"unit_id": "a.10", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 29.73, "full_output_similarity": 48.649}, {"unit_id": "a.11", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 33.962, "full_output_similarity": 45.455}, {"unit_id": "a.12", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 28.571, "full_output_similarity": 52.381}, {"unit_id": "a.13", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 31.746, "full_output_similarity": 50.0}, {"unit_id": "a.14", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 32.727, "full_output_similarity": 56.757}, {"unit_id": "a.15", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 30.189, "full_output_similarity": 56.757}, {"unit_id": "a.16", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 28.235, "full_output_similarity": 60.0}, {"unit_id": "a.17", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 26.829, "full_output_similarity": 61.111}, {"unit_id": "a.18", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 25.0, "full_output_similarity": 63.333}, {"unit_id": "a.19", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 30.508, "full_output_similarity": 53.846}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2025-individual-p2-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 38.298, "full_output_similarity": 38.298}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}
+{"record_id": "iol-2025-team-p1-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 44.444, "full_output_similarity": 27.976}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-12b-it"}

benchmark/IOL/ioling_hf/evals/results/meta-llama__Llama-3.2-3B-Instruct__diverse5.scores.jsonl

@@ -0,0 +1,5 @@
+{"record_id": "iol-2006-individual-p1-sub-assignment_1", "score": 1.0, "max_score": 4.0, "score_fraction": 0.25, "verdict": "partial", "matched_units": ["assignment_1.1"], "missed_units": ["assignment_1.2", "assignment_1.3", "assignment_1.4"], "unit_results": [{"unit_id": "assignment_1.1", "points": 1.0, "matched": true, "match_type": "fuzzy_final_partial_ratio", "final_similarity": 95.0, "full_output_similarity": 95.0}, {"unit_id": "assignment_1.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 57.576, "full_output_similarity": 60.606}, {"unit_id": "assignment_1.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 48.0, "full_output_similarity": 56.818}, {"unit_id": "assignment_1.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 75.0, "full_output_similarity": 72.0}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2011-individual-p1-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 46.832, "full_output_similarity": 59.0}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2015-individual-p5-sub-b", "score": 0.0, "max_score": 9.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["b.1", "b.2", "b.3", "b.4", "b.5", "b.6", "b.7", "b.8", "b.9"], "unit_results": [{"unit_id": "b.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 22.857, "full_output_similarity": 40.741}, {"unit_id": "b.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 22.222, "full_output_similarity": 39.13}, {"unit_id": "b.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 20.0, "full_output_similarity": 40.741}, {"unit_id": "b.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 25.0, "full_output_similarity": 45.833}, {"unit_id": "b.5", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 22.222, "full_output_similarity": 41.667}, {"unit_id": "b.6", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 25.0, "full_output_similarity": 44.828}, {"unit_id": "b.7", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 22.222, "full_output_similarity": 48.0}, {"unit_id": "b.8", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 24.242, "full_output_similarity": 46.667}, {"unit_id": "b.9", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 22.222, "full_output_similarity": 40.741}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2021-individual-p2-sub-a", "score": 0.0, "max_score": 9.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1", "a.2", "a.3", "a.4", "a.5", "a.6", "a.7", "a.8", "a.9"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 44.872, "full_output_similarity": 44.872}, {"unit_id": "a.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 60.0, "full_output_similarity": 60.0}, {"unit_id": "a.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 65.0, "full_output_similarity": 65.0}, {"unit_id": "a.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 57.143, "full_output_similarity": 57.143}, {"unit_id": "a.5", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 54.545, "full_output_similarity": 54.545}, {"unit_id": "a.6", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 53.333, "full_output_similarity": 53.333}, {"unit_id": "a.7", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 66.667, "full_output_similarity": 66.667}, {"unit_id": "a.8", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 58.065, "full_output_similarity": 58.065}, {"unit_id": "a.9", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 63.889, "full_output_similarity": 63.889}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2025-team-p1-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 36.842, "full_output_similarity": 32.738}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}

benchmark/IOL/ioling_hf/evals/results/meta-llama__Llama-3.2-3B-Instruct__strict30.scores.jsonl

@@ -0,0 +1,30 @@
+{"record_id": "iol-2006-individual-p1-sub-assignment_1", "score": 0.0, "max_score": 4.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["assignment_1.1", "assignment_1.2", "assignment_1.3", "assignment_1.4"], "unit_results": [{"unit_id": "assignment_1.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 82.5, "full_output_similarity": 82.5}, {"unit_id": "assignment_1.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 66.667, "full_output_similarity": 66.667}, {"unit_id": "assignment_1.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 46.591, "full_output_similarity": 53.409}, {"unit_id": "assignment_1.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 64.286, "full_output_similarity": 64.286}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2006-individual-p5", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["full.1"], "unit_results": [{"unit_id": "full.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 61.446, "full_output_similarity": 43.173}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2007-individual-p5", "score": 0.0, "max_score": 4.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["full.1", "full.2", "full.3", "full.4"], "unit_results": [{"unit_id": "full.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 41.379, "full_output_similarity": 55.172}, {"unit_id": "full.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 34.286, "full_output_similarity": 48.571}, {"unit_id": "full.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 39.13, "full_output_similarity": 56.522}, {"unit_id": "full.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 38.71, "full_output_similarity": 41.935}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2008-individual-p2-sub-b", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["b.1"], "unit_results": [{"unit_id": "b.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 45.029, "full_output_similarity": 45.029}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2008-team-p1-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 43.284, "full_output_similarity": 46.207}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2009-individual-p4-sub-a", "score": 1.0, "max_score": 1.0, "score_fraction": 1.0, "verdict": "correct", "matched_units": ["a.1"], "missed_units": [], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": true, "match_type": "fuzzy_final_partial_ratio", "final_similarity": 100.0, "full_output_similarity": 49.738}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2010-individual-p2-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 41.163, "full_output_similarity": 41.163}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2010-team-p1", "score": 1.0, "max_score": 1.0, "score_fraction": 1.0, "verdict": "correct", "matched_units": ["full.1"], "missed_units": [], "unit_results": [{"unit_id": "full.1", "points": 1.0, "matched": true, "match_type": "fuzzy_final_partial_ratio", "final_similarity": 100.0, "full_output_similarity": 34.182}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2011-individual-p3-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 51.079, "full_output_similarity": 51.079}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2012-individual-p1-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 49.275, "full_output_similarity": 49.275}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2012-individual-p5-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 73.885, "full_output_similarity": 69.892}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2013-individual-p3", "score": 0.0, "max_score": 5.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["full.1", "full.2", "full.3", "full.4", "full.5"], "unit_results": [{"unit_id": "full.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 33.333, "full_output_similarity": 66.667}, {"unit_id": "full.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 37.037, "full_output_similarity": 50.588}, {"unit_id": "full.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 32.0, "full_output_similarity": 47.5}, {"unit_id": "full.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 30.645, "full_output_similarity": 45.333}, {"unit_id": "full.5", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 40.23, "full_output_similarity": 55.172}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2014-individual-p2", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["full.1"], "unit_results": [{"unit_id": "full.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 66.667, "full_output_similarity": 66.667}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2014-individual-p5-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 40.796, "full_output_similarity": 40.796}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2015-individual-p3-sub-a", "score": 0.0, "max_score": 5.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1", "a.2", "a.3", "a.4", "a.5"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 33.333, "full_output_similarity": 53.333}, {"unit_id": "a.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 25.0, "full_output_similarity": 51.899}, {"unit_id": "a.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 25.0, "full_output_similarity": 45.714}, {"unit_id": "a.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 25.0, "full_output_similarity": 51.351}, {"unit_id": "a.5", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 52.5}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2016-individual-p1", "score": 15.0, "max_score": 15.0, "score_fraction": 1.0, "verdict": "correct", "matched_units": ["full.1", "full.2", "full.3", "full.4", "full.5", "full.6", "full.7", "full.8", "full.9", "full.10", "full.11", "full.12", "full.13", "full.14", "full.15"], "missed_units": [], "unit_results": [{"unit_id": "full.1", "points": 1.0, "matched": true, "match_type": "fuzzy_final_partial_ratio", "final_similarity": 100.0, "full_output_similarity": 74.468}, {"unit_id": "full.2", "points": 1.0, "matched": true, "match_type": "fuzzy_final_partial_ratio", "final_similarity": 100.0, "full_output_similarity": 77.778}, {"unit_id": "full.3", "points": 1.0, "matched": true, "match_type": "fuzzy_final_partial_ratio", "final_similarity": 100.0, "full_output_similarity": 85.0}, {"unit_id": "full.4", "points": 1.0, "matched": true, "match_type": "fuzzy_final_partial_ratio", "final_similarity": 100.0, "full_output_similarity": 78.049}, {"unit_id": "full.5", "points": 1.0, "matched": true, "match_type": "fuzzy_final_partial_ratio", "final_similarity": 100.0, "full_output_similarity": 75.556}, {"unit_id": "full.6", "points": 1.0, "matched": true, "match_type": "fuzzy_final_partial_ratio", "final_similarity": 100.0, "full_output_similarity": 75.61}, {"unit_id": "full.7", "points": 1.0, "matched": true, "match_type": "fuzzy_final_partial_ratio", "final_similarity": 100.0, "full_output_similarity": 83.333}, {"unit_id": "full.8", "points": 1.0, "matched": true, "match_type": "fuzzy_final_partial_ratio", "final_similarity": 100.0, "full_output_similarity": 79.487}, {"unit_id": "full.9", "points": 1.0, "matched": true, "match_type": "fuzzy_final_partial_ratio", "final_similarity": 100.0, "full_output_similarity": 76.19}, {"unit_id": "full.10", "points": 1.0, "matched": true, "match_type": "fuzzy_final_partial_ratio", "final_similarity": 100.0, "full_output_similarity": 90.0}, {"unit_id": "full.11", "points": 1.0, "matched": true, "match_type": "fuzzy_final_partial_ratio", "final_similarity": 100.0, "full_output_similarity": 88.095}, {"unit_id": "full.12", "points": 1.0, "matched": true, "match_type": "fuzzy_final_partial_ratio", "final_similarity": 100.0, "full_output_similarity": 79.545}, {"unit_id": "full.13", "points": 1.0, "matched": true, "match_type": "fuzzy_final_partial_ratio", "final_similarity": 100.0, "full_output_similarity": 83.333}, {"unit_id": "full.14", "points": 1.0, "matched": true, "match_type": "fuzzy_final_partial_ratio", "final_similarity": 100.0, "full_output_similarity": 85.417}, {"unit_id": "full.15", "points": 1.0, "matched": true, "match_type": "fuzzy_final_partial_ratio", "final_similarity": 100.0, "full_output_similarity": 82.979}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2016-individual-p5-sub-a", "score": 0.0, "max_score": 2.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1", "a.2"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 40.0, "full_output_similarity": 60.87}, {"unit_id": "a.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 40.0, "full_output_similarity": 53.125}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2017-individual-p2-sub-a", "score": 0.0, "max_score": 16.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1", "a.2", "a.3", "a.4", "a.5", "a.6", "a.7", "a.8", "a.9", "a.10", "a.11", "a.12", "a.13", "a.14", "a.15", "a.16"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 54.098}, {"unit_id": "a.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 60.377}, {"unit_id": "a.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 79.167}, {"unit_id": "a.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 57.143}, {"unit_id": "a.5", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 73.171}, {"unit_id": "a.6", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 54.762}, {"unit_id": "a.7", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 54.0}, {"unit_id": "a.8", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 78.947}, {"unit_id": "a.9", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 62.857}, {"unit_id": "a.10", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 72.222}, {"unit_id": "a.11", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 80.0}, {"unit_id": "a.12", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 76.0}, {"unit_id": "a.13", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 75.61}, {"unit_id": "a.14", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 53.488}, {"unit_id": "a.15", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 59.091}, {"unit_id": "a.16", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 76.667}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2017-team-p1", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["full.1"], "unit_results": [{"unit_id": "full.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 42.017, "full_output_similarity": 61.585}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2018-individual-p4-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 25.0, "full_output_similarity": 37.5}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2019-individual-p2-sub-a", "score": 0.0, "max_score": 17.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1", "a.2", "a.3", "a.4", "a.5", "a.6", "a.7", "a.8", "a.9", "a.10", "a.11", "a.12", "a.13", "a.14", "a.15", "a.16", "a.17"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 76.744}, {"unit_id": "a.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 75.758}, {"unit_id": "a.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 77.143}, {"unit_id": "a.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 75.0}, {"unit_id": "a.5", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 73.077}, {"unit_id": "a.6", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 71.429}, {"unit_id": "a.7", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 84.848}, {"unit_id": "a.8", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 88.235}, {"unit_id": "a.9", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 81.818}, {"unit_id": "a.10", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 68.293}, {"unit_id": "a.11", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 70.968}, {"unit_id": "a.12", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 66.667}, {"unit_id": "a.13", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 70.37}, {"unit_id": "a.14", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 78.049}, {"unit_id": "a.15", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 66.667}, {"unit_id": "a.16", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 71.875}, {"unit_id": "a.17", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 74.074}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2019-team-p1", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["full.1"], "unit_results": [{"unit_id": "full.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 41.491, "full_output_similarity": 41.491}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2021-individual-p3-sub-a", "score": 0.0, "max_score": 4.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1", "a.2", "a.3", "a.4"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 38.235, "full_output_similarity": 97.059}, {"unit_id": "a.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 43.478, "full_output_similarity": 100.0}, {"unit_id": "a.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 38.095, "full_output_similarity": 100.0}, {"unit_id": "a.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 41.026, "full_output_similarity": 97.436}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2022-individual-p1-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 80.0, "full_output_similarity": 83.784}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2022-individual-p5-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 16.667, "full_output_similarity": 50.0}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2023-individual-p3", "score": 0.0, "max_score": 13.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["full.1", "full.2", "full.3", "full.4", "full.5", "full.6", "full.7", "full.8", "full.9", "full.10", "full.11", "full.12", "full.13"], "unit_results": [{"unit_id": "full.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 37.5, "full_output_similarity": 87.5}, {"unit_id": "full.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 48.387, "full_output_similarity": 48.387}, {"unit_id": "full.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 37.037, "full_output_similarity": 59.259}, {"unit_id": "full.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 75.0, "full_output_similarity": 72.0}, {"unit_id": "full.5", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 40.0, "full_output_similarity": 54.286}, {"unit_id": "full.6", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 62.963, "full_output_similarity": 66.667}, {"unit_id": "full.7", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 72.0, "full_output_similarity": 72.917}, {"unit_id": "full.8", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 42.105, "full_output_similarity": 73.684}, {"unit_id": "full.9", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 48.98, "full_output_similarity": 65.306}, {"unit_id": "full.10", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 70.588, "full_output_similarity": 70.588}, {"unit_id": "full.11", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 67.647, "full_output_similarity": 73.529}, {"unit_id": "full.12", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 75.676, "full_output_similarity": 78.378}, {"unit_id": "full.13", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 80.0, "full_output_similarity": 79.012}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2024-individual-p1", "score": 0.0, "max_score": 17.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["full.1", "full.2", "full.3", "full.4", "full.5", "full.6", "full.7", "full.8", "full.9", "full.10", "full.11", "full.12", "full.13", "full.14", "full.15", "full.16", "full.17"], "unit_results": [{"unit_id": "full.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 34.667, "full_output_similarity": 46.237}, {"unit_id": "full.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 33.333, "full_output_similarity": 47.917}, {"unit_id": "full.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 37.5, "full_output_similarity": 47.5}, {"unit_id": "full.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 36.22, "full_output_similarity": 44.0}, {"unit_id": "full.5", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 33.333, "full_output_similarity": 66.667}, {"unit_id": "full.6", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 35.714, "full_output_similarity": 44.643}, {"unit_id": "full.7", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 36.364, "full_output_similarity": 45.455}, {"unit_id": "full.8", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 33.333, "full_output_similarity": 47.917}, {"unit_id": "full.9", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 35.714, "full_output_similarity": 42.105}, {"unit_id": "full.10", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 59.574, "full_output_similarity": 68.75}, {"unit_id": "full.11", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 40.741, "full_output_similarity": 59.259}, {"unit_id": "full.12", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 48.649, "full_output_similarity": 78.378}, {"unit_id": "full.13", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 46.667, "full_output_similarity": 86.667}, {"unit_id": "full.14", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 64.0, "full_output_similarity": 64.0}, {"unit_id": "full.15", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 61.29, "full_output_similarity": 67.742}, {"unit_id": "full.16", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 61.29, "full_output_similarity": 61.29}, {"unit_id": "full.17", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 73.684, "full_output_similarity": 71.795}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2024-individual-p4-sub-a", "score": 0.0, "max_score": 19.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1", "a.2", "a.3", "a.4", "a.5", "a.6", "a.7", "a.8", "a.9", "a.10", "a.11", "a.12", "a.13", "a.14", "a.15", "a.16", "a.17", "a.18", "a.19"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 39.394, "full_output_similarity": 39.394}, {"unit_id": "a.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 41.176, "full_output_similarity": 41.176}, {"unit_id": "a.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 44.444, "full_output_similarity": 44.444}, {"unit_id": "a.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 41.463, "full_output_similarity": 41.463}, {"unit_id": "a.5", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 44.118, "full_output_similarity": 44.118}, {"unit_id": "a.6", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 42.424, "full_output_similarity": 42.424}, {"unit_id": "a.7", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 41.818, "full_output_similarity": 41.818}, {"unit_id": "a.8", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 46.875, "full_output_similarity": 46.875}, {"unit_id": "a.9", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 45.652, "full_output_similarity": 45.652}, {"unit_id": "a.10", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 40.541, "full_output_similarity": 40.541}, {"unit_id": "a.11", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 42.424, "full_output_similarity": 42.424}, {"unit_id": "a.12", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 42.857, "full_output_similarity": 42.857}, {"unit_id": "a.13", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 41.667, "full_output_similarity": 41.667}, {"unit_id": "a.14", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 43.243, "full_output_similarity": 43.243}, {"unit_id": "a.15", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 43.243, "full_output_similarity": 43.243}, {"unit_id": "a.16", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 43.636, "full_output_similarity": 43.636}, {"unit_id": "a.17", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 40.741, "full_output_similarity": 40.741}, {"unit_id": "a.18", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 48.333, "full_output_similarity": 48.333}, {"unit_id": "a.19", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 46.154, "full_output_similarity": 46.154}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2025-individual-p2-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 32.979, "full_output_similarity": 32.979}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}
+{"record_id": "iol-2025-team-p1-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 36.842, "full_output_similarity": 32.738}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "meta-llama/Llama-3.2-3B-Instruct"}

benchmark/IOL/ioling_hf/evals/results/microsoft__Phi-4-mini-instruct.scores.jsonl

@@ -0,0 +1,3 @@
+{"record_id": "iol-2006-individual-p1", "score": 0.0, "max_score": 9.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["assignment_1.1", "assignment_1.2", "assignment_1.3", "assignment_1.4", "assignment_2.1", "assignment_3.1", "assignment_3.2", "assignment_3.3", "assignment_3.4"], "unit_results": [{"unit_id": "assignment_1.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 72.5, "full_output_similarity": 72.5}, {"unit_id": "assignment_1.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 57.576, "full_output_similarity": 57.576}, {"unit_id": "assignment_1.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 54.545, "full_output_similarity": 54.545}, {"unit_id": "assignment_1.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 64.286, "full_output_similarity": 64.286}, {"unit_id": "assignment_2.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 55.556, "full_output_similarity": 55.556}, {"unit_id": "assignment_3.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 69.767, "full_output_similarity": 69.767}, {"unit_id": "assignment_3.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 70.833, "full_output_similarity": 70.833}, {"unit_id": "assignment_3.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 69.231, "full_output_similarity": 69.231}, {"unit_id": "assignment_3.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 60.606, "full_output_similarity": 60.606}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "microsoft/Phi-4-mini-instruct"}
+{"record_id": "iol-2006-individual-p1-sub-assignment_1", "score": 0.0, "max_score": 4.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["assignment_1.1", "assignment_1.2", "assignment_1.3", "assignment_1.4"], "unit_results": [{"unit_id": "assignment_1.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 77.5, "full_output_similarity": 77.5}, {"unit_id": "assignment_1.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 60.606, "full_output_similarity": 60.606}, {"unit_id": "assignment_1.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 54.545, "full_output_similarity": 54.545}, {"unit_id": "assignment_1.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 71.429, "full_output_similarity": 71.429}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "microsoft/Phi-4-mini-instruct"}
+{"record_id": "iol-2006-individual-p1-sub-assignment_2", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["assignment_2.1"], "unit_results": [{"unit_id": "assignment_2.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 58.333, "full_output_similarity": 58.333}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "microsoft/Phi-4-mini-instruct"}

benchmark/IOL/ioling_hf/evals/results/microsoft__Phi-4-mini-instruct__diverse5.scores.jsonl

@@ -0,0 +1,5 @@
+{"record_id": "iol-2006-individual-p1-sub-assignment_1", "score": 0.0, "max_score": 4.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["assignment_1.1", "assignment_1.2", "assignment_1.3", "assignment_1.4"], "unit_results": [{"unit_id": "assignment_1.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 77.5, "full_output_similarity": 77.5}, {"unit_id": "assignment_1.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 54.545, "full_output_similarity": 54.545}, {"unit_id": "assignment_1.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 52.273, "full_output_similarity": 52.273}, {"unit_id": "assignment_1.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 72.727, "full_output_similarity": 72.727}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "microsoft/Phi-4-mini-instruct"}
+{"record_id": "iol-2011-individual-p1-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 0.0, "full_output_similarity": 0.0}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "microsoft/Phi-4-mini-instruct"}
+{"record_id": "iol-2015-individual-p5-sub-b", "score": 0.0, "max_score": 9.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["b.1", "b.2", "b.3", "b.4", "b.5", "b.6", "b.7", "b.8", "b.9"], "unit_results": [{"unit_id": "b.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 77.778, "full_output_similarity": 77.778}, {"unit_id": "b.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 73.913, "full_output_similarity": 73.913}, {"unit_id": "b.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 77.778, "full_output_similarity": 77.778}, {"unit_id": "b.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 75.0, "full_output_similarity": 75.0}, {"unit_id": "b.5", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 45.833, "full_output_similarity": 45.833}, {"unit_id": "b.6", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 44.828, "full_output_similarity": 44.828}, {"unit_id": "b.7", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 52.0, "full_output_similarity": 52.0}, {"unit_id": "b.8", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 46.667, "full_output_similarity": 46.667}, {"unit_id": "b.9", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 44.444, "full_output_similarity": 44.444}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "microsoft/Phi-4-mini-instruct"}
+{"record_id": "iol-2021-individual-p2-sub-a", "score": 0.0, "max_score": 9.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1", "a.2", "a.3", "a.4", "a.5", "a.6", "a.7", "a.8", "a.9"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 46.154, "full_output_similarity": 46.154}, {"unit_id": "a.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 46.667, "full_output_similarity": 46.667}, {"unit_id": "a.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 50.0, "full_output_similarity": 50.0}, {"unit_id": "a.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 42.857, "full_output_similarity": 42.857}, {"unit_id": "a.5", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 51.515, "full_output_similarity": 51.515}, {"unit_id": "a.6", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 46.667, "full_output_similarity": 46.667}, {"unit_id": "a.7", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 66.667, "full_output_similarity": 66.667}, {"unit_id": "a.8", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 41.935, "full_output_similarity": 41.935}, {"unit_id": "a.9", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 36.111, "full_output_similarity": 36.111}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "microsoft/Phi-4-mini-instruct"}
+{"record_id": "iol-2025-team-p1-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 32.738, "full_output_similarity": 32.738}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "microsoft/Phi-4-mini-instruct"}

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_code/__init__.py

@@ -0,0 +1 @@
+""" python inspection/code generation API """

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_code/_assertionnew.py

@@ -0,0 +1,322 @@
+"""
+Find intermediate evalutation results in assert statements through builtin AST.
+This should replace _assertionold.py eventually.
+"""
+
+import sys
+import ast
+
+import py
+from py._code.assertion import _format_explanation, BuiltinAssertionError
+
+
+def _is_ast_expr(node):
+    return isinstance(node, ast.expr)
+def _is_ast_stmt(node):
+    return isinstance(node, ast.stmt)
+
+
+class Failure(Exception):
+    """Error found while interpreting AST."""
+
+    def __init__(self, explanation=""):
+        self.cause = sys.exc_info()
+        self.explanation = explanation
+
+
+def interpret(source, frame, should_fail=False):
+    mod = ast.parse(source)
+    visitor = DebugInterpreter(frame)
+    try:
+        visitor.visit(mod)
+    except Failure:
+        failure = sys.exc_info()[1]
+        return getfailure(failure)
+    if should_fail:
+        return ("(assertion failed, but when it was re-run for "
+                "printing intermediate values, it did not fail.  Suggestions: "
+                "compute assert expression before the assert or use --no-assert)")
+
+def run(offending_line, frame=None):
+    if frame is None:
+        frame = py.code.Frame(sys._getframe(1))
+    return interpret(offending_line, frame)
+
+def getfailure(failure):
+    explanation = _format_explanation(failure.explanation)
+    value = failure.cause[1]
+    if str(value):
+        lines = explanation.splitlines()
+        if not lines:
+            lines.append("")
+        lines[0] += " << %s" % (value,)
+        explanation = "\n".join(lines)
+    text = "%s: %s" % (failure.cause[0].__name__, explanation)
+    if text.startswith("AssertionError: assert "):
+        text = text[16:]
+    return text
+
+
+operator_map = {
+    ast.BitOr : "|",
+    ast.BitXor : "^",
+    ast.BitAnd : "&",
+    ast.LShift : "<<",
+    ast.RShift : ">>",
+    ast.Add : "+",
+    ast.Sub : "-",
+    ast.Mult : "*",
+    ast.Div : "/",
+    ast.FloorDiv : "//",
+    ast.Mod : "%",
+    ast.Eq : "==",
+    ast.NotEq : "!=",
+    ast.Lt : "<",
+    ast.LtE : "<=",
+    ast.Gt : ">",
+    ast.GtE : ">=",
+    ast.Pow : "**",
+    ast.Is : "is",
+    ast.IsNot : "is not",
+    ast.In : "in",
+    ast.NotIn : "not in"
+}
+
+unary_map = {
+    ast.Not : "not %s",
+    ast.Invert : "~%s",
+    ast.USub : "-%s",
+    ast.UAdd : "+%s"
+}
+
+
+class DebugInterpreter(ast.NodeVisitor):
+    """Interpret AST nodes to gleam useful debugging information. """
+
+    def __init__(self, frame):
+        self.frame = frame
+
+    def generic_visit(self, node):
+        # Fallback when we don't have a special implementation.
+        if _is_ast_expr(node):
+            mod = ast.Expression(node)
+            co = self._compile(mod)
+            try:
+                result = self.frame.eval(co)
+            except Exception:
+                raise Failure()
+            explanation = self.frame.repr(result)
+            return explanation, result
+        elif _is_ast_stmt(node):
+            mod = ast.Module([node])
+            co = self._compile(mod, "exec")
+            try:
+                self.frame.exec_(co)
+            except Exception:
+                raise Failure()
+            return None, None
+        else:
+            raise AssertionError("can't handle %s" %(node,))
+
+    def _compile(self, source, mode="eval"):
+        return compile(source, "<assertion interpretation>", mode)
+
+    def visit_Expr(self, expr):
+        return self.visit(expr.value)
+
+    def visit_Module(self, mod):
+        for stmt in mod.body:
+            self.visit(stmt)
+
+    def visit_Name(self, name):
+        explanation, result = self.generic_visit(name)
+        # See if the name is local.
+        source = "%r in locals() is not globals()" % (name.id,)
+        co = self._compile(source)
+        try:
+            local = self.frame.eval(co)
+        except Exception:
+            # have to assume it isn't
+            local = False
+        if not local:
+            return name.id, result
+        return explanation, result
+
+    def visit_Compare(self, comp):
+        left = comp.left
+        left_explanation, left_result = self.visit(left)
+        for op, next_op in zip(comp.ops, comp.comparators):
+            next_explanation, next_result = self.visit(next_op)
+            op_symbol = operator_map[op.__class__]
+            explanation = "%s %s %s" % (left_explanation, op_symbol,
+                                        next_explanation)
+            source = "__exprinfo_left %s __exprinfo_right" % (op_symbol,)
+            co = self._compile(source)
+            try:
+                result = self.frame.eval(co, __exprinfo_left=left_result,
+                                         __exprinfo_right=next_result)
+            except Exception:
+                raise Failure(explanation)
+            try:
+                if not result:
+                    break
+            except KeyboardInterrupt:
+                raise
+            except:
+                break
+            left_explanation, left_result = next_explanation, next_result
+
+        rcomp = py.code._reprcompare
+        if rcomp:
+            res = rcomp(op_symbol, left_result, next_result)
+            if res:
+                explanation = res
+        return explanation, result
+
+    def visit_BoolOp(self, boolop):
+        is_or = isinstance(boolop.op, ast.Or)
+        explanations = []
+        for operand in boolop.values:
+            explanation, result = self.visit(operand)
+            explanations.append(explanation)
+            if result == is_or:
+                break
+        name = is_or and " or " or " and "
+        explanation = "(" + name.join(explanations) + ")"
+        return explanation, result
+
+    def visit_UnaryOp(self, unary):
+        pattern = unary_map[unary.op.__class__]
+        operand_explanation, operand_result = self.visit(unary.operand)
+        explanation = pattern % (operand_explanation,)
+        co = self._compile(pattern % ("__exprinfo_expr",))
+        try:
+            result = self.frame.eval(co, __exprinfo_expr=operand_result)
+        except Exception:
+            raise Failure(explanation)
+        return explanation, result
+
+    def visit_BinOp(self, binop):
+        left_explanation, left_result = self.visit(binop.left)
+        right_explanation, right_result = self.visit(binop.right)
+        symbol = operator_map[binop.op.__class__]
+        explanation = "(%s %s %s)" % (left_explanation, symbol,
+                                      right_explanation)
+        source = "__exprinfo_left %s __exprinfo_right" % (symbol,)
+        co = self._compile(source)
+        try:
+            result = self.frame.eval(co, __exprinfo_left=left_result,
+                                     __exprinfo_right=right_result)
+        except Exception:
+            raise Failure(explanation)
+        return explanation, result
+
+    def visit_Call(self, call):
+        func_explanation, func = self.visit(call.func)
+        arg_explanations = []
+        ns = {"__exprinfo_func" : func}
+        arguments = []
+        for arg in call.args:
+            arg_explanation, arg_result = self.visit(arg)
+            arg_name = "__exprinfo_%s" % (len(ns),)
+            ns[arg_name] = arg_result
+            arguments.append(arg_name)
+            arg_explanations.append(arg_explanation)
+        for keyword in call.keywords:
+            arg_explanation, arg_result = self.visit(keyword.value)
+            arg_name = "__exprinfo_%s" % (len(ns),)
+            ns[arg_name] = arg_result
+            keyword_source = "%s=%%s" % (keyword.arg)
+            arguments.append(keyword_source % (arg_name,))
+            arg_explanations.append(keyword_source % (arg_explanation,))
+        if call.starargs:
+            arg_explanation, arg_result = self.visit(call.starargs)
+            arg_name = "__exprinfo_star"
+            ns[arg_name] = arg_result
+            arguments.append("*%s" % (arg_name,))
+            arg_explanations.append("*%s" % (arg_explanation,))
+        if call.kwargs:
+            arg_explanation, arg_result = self.visit(call.kwargs)
+            arg_name = "__exprinfo_kwds"
+            ns[arg_name] = arg_result
+            arguments.append("**%s" % (arg_name,))
+            arg_explanations.append("**%s" % (arg_explanation,))
+        args_explained = ", ".join(arg_explanations)
+        explanation = "%s(%s)" % (func_explanation, args_explained)
+        args = ", ".join(arguments)
+        source = "__exprinfo_func(%s)" % (args,)
+        co = self._compile(source)
+        try:
+            result = self.frame.eval(co, **ns)
+        except Exception:
+            raise Failure(explanation)
+        pattern = "%s\n{%s = %s\n}"
+        rep = self.frame.repr(result)
+        explanation = pattern % (rep, rep, explanation)
+        return explanation, result
+
+    def _is_builtin_name(self, name):
+        pattern = "%r not in globals() and %r not in locals()"
+        source = pattern % (name.id, name.id)
+        co = self._compile(source)
+        try:
+            return self.frame.eval(co)
+        except Exception:
+            return False
+
+    def visit_Attribute(self, attr):
+        if not isinstance(attr.ctx, ast.Load):
+            return self.generic_visit(attr)
+        source_explanation, source_result = self.visit(attr.value)
+        explanation = "%s.%s" % (source_explanation, attr.attr)
+        source = "__exprinfo_expr.%s" % (attr.attr,)
+        co = self._compile(source)
+        try:
+            result = self.frame.eval(co, __exprinfo_expr=source_result)
+        except Exception:
+            raise Failure(explanation)
+        explanation = "%s\n{%s = %s.%s\n}" % (self.frame.repr(result),
+                                              self.frame.repr(result),
+                                              source_explanation, attr.attr)
+        # Check if the attr is from an instance.
+        source = "%r in getattr(__exprinfo_expr, '__dict__', {})"
+        source = source % (attr.attr,)
+        co = self._compile(source)
+        try:
+            from_instance = self.frame.eval(co, __exprinfo_expr=source_result)
+        except Exception:
+            from_instance = True
+        if from_instance:
+            rep = self.frame.repr(result)
+            pattern = "%s\n{%s = %s\n}"
+            explanation = pattern % (rep, rep, explanation)
+        return explanation, result
+
+    def visit_Assert(self, assrt):
+        test_explanation, test_result = self.visit(assrt.test)
+        if test_explanation.startswith("False\n{False =") and \
+                test_explanation.endswith("\n"):
+            test_explanation = test_explanation[15:-2]
+        explanation = "assert %s" % (test_explanation,)
+        if not test_result:
+            try:
+                raise BuiltinAssertionError
+            except Exception:
+                raise Failure(explanation)
+        return explanation, test_result
+
+    def visit_Assign(self, assign):
+        value_explanation, value_result = self.visit(assign.value)
+        explanation = "... = %s" % (value_explanation,)
+        name = ast.Name("__exprinfo_expr", ast.Load(),
+                        lineno=assign.value.lineno,
+                        col_offset=assign.value.col_offset)
+        new_assign = ast.Assign(assign.targets, name, lineno=assign.lineno,
+                                col_offset=assign.col_offset)
+        mod = ast.Module([new_assign])
+        co = self._compile(mod, "exec")
+        try:
+            self.frame.exec_(co, __exprinfo_expr=value_result)
+        except Exception:
+            raise Failure(explanation)
+        return explanation, value_result

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_code/_assertionold.py

@@ -0,0 +1,556 @@
+import py
+import sys, inspect
+from compiler import parse, ast, pycodegen
+from py._code.assertion import BuiltinAssertionError, _format_explanation
+import types
+
+passthroughex = py.builtin._sysex
+
+class Failure:
+    def __init__(self, node):
+        self.exc, self.value, self.tb = sys.exc_info()
+        self.node = node
+
+class View(object):
+    """View base class.
+
+    If C is a subclass of View, then C(x) creates a proxy object around
+    the object x.  The actual class of the proxy is not C in general,
+    but a *subclass* of C determined by the rules below.  To avoid confusion
+    we call view class the class of the proxy (a subclass of C, so of View)
+    and object class the class of x.
+
+    Attributes and methods not found in the proxy are automatically read on x.
+    Other operations like setting attributes are performed on the proxy, as
+    determined by its view class.  The object x is available from the proxy
+    as its __obj__ attribute.
+
+    The view class selection is determined by the __view__ tuples and the
+    optional __viewkey__ method.  By default, the selected view class is the
+    most specific subclass of C whose __view__ mentions the class of x.
+    If no such subclass is found, the search proceeds with the parent
+    object classes.  For example, C(True) will first look for a subclass
+    of C with __view__ = (..., bool, ...) and only if it doesn't find any
+    look for one with __view__ = (..., int, ...), and then ..., object,...
+    If everything fails the class C itself is considered to be the default.
+
+    Alternatively, the view class selection can be driven by another aspect
+    of the object x, instead of the class of x, by overriding __viewkey__.
+    See last example at the end of this module.
+    """
+
+    _viewcache = {}
+    __view__ = ()
+
+    def __new__(rootclass, obj, *args, **kwds):
+        self = object.__new__(rootclass)
+        self.__obj__ = obj
+        self.__rootclass__ = rootclass
+        key = self.__viewkey__()
+        try:
+            self.__class__ = self._viewcache[key]
+        except KeyError:
+            self.__class__ = self._selectsubclass(key)
+        return self
+
+    def __getattr__(self, attr):
+        # attributes not found in the normal hierarchy rooted on View
+        # are looked up in the object's real class
+        return getattr(self.__obj__, attr)
+
+    def __viewkey__(self):
+        return self.__obj__.__class__
+
+    def __matchkey__(self, key, subclasses):
+        if inspect.isclass(key):
+            keys = inspect.getmro(key)
+        else:
+            keys = [key]
+        for key in keys:
+            result = [C for C in subclasses if key in C.__view__]
+            if result:
+                return result
+        return []
+
+    def _selectsubclass(self, key):
+        subclasses = list(enumsubclasses(self.__rootclass__))
+        for C in subclasses:
+            if not isinstance(C.__view__, tuple):
+                C.__view__ = (C.__view__,)
+        choices = self.__matchkey__(key, subclasses)
+        if not choices:
+            return self.__rootclass__
+        elif len(choices) == 1:
+            return choices[0]
+        else:
+            # combine the multiple choices
+            return type('?', tuple(choices), {})
+
+    def __repr__(self):
+        return '%s(%r)' % (self.__rootclass__.__name__, self.__obj__)
+
+
+def enumsubclasses(cls):
+    for subcls in cls.__subclasses__():
+        for subsubclass in enumsubclasses(subcls):
+            yield subsubclass
+    yield cls
+
+
+class Interpretable(View):
+    """A parse tree node with a few extra methods."""
+    explanation = None
+
+    def is_builtin(self, frame):
+        return False
+
+    def eval(self, frame):
+        # fall-back for unknown expression nodes
+        try:
+            expr = ast.Expression(self.__obj__)
+            expr.filename = '<eval>'
+            self.__obj__.filename = '<eval>'
+            co = pycodegen.ExpressionCodeGenerator(expr).getCode()
+            result = frame.eval(co)
+        except passthroughex:
+            raise
+        except:
+            raise Failure(self)
+        self.result = result
+        self.explanation = self.explanation or frame.repr(self.result)
+
+    def run(self, frame):
+        # fall-back for unknown statement nodes
+        try:
+            expr = ast.Module(None, ast.Stmt([self.__obj__]))
+            expr.filename = '<run>'
+            co = pycodegen.ModuleCodeGenerator(expr).getCode()
+            frame.exec_(co)
+        except passthroughex:
+            raise
+        except:
+            raise Failure(self)
+
+    def nice_explanation(self):
+        return _format_explanation(self.explanation)
+
+
+class Name(Interpretable):
+    __view__ = ast.Name
+
+    def is_local(self, frame):
+        source = '%r in locals() is not globals()' % self.name
+        try:
+            return frame.is_true(frame.eval(source))
+        except passthroughex:
+            raise
+        except:
+            return False
+
+    def is_global(self, frame):
+        source = '%r in globals()' % self.name
+        try:
+            return frame.is_true(frame.eval(source))
+        except passthroughex:
+            raise
+        except:
+            return False
+
+    def is_builtin(self, frame):
+        source = '%r not in locals() and %r not in globals()' % (
+            self.name, self.name)
+        try:
+            return frame.is_true(frame.eval(source))
+        except passthroughex:
+            raise
+        except:
+            return False
+
+    def eval(self, frame):
+        super(Name, self).eval(frame)
+        if not self.is_local(frame):
+            self.explanation = self.name
+
+class Compare(Interpretable):
+    __view__ = ast.Compare
+
+    def eval(self, frame):
+        expr = Interpretable(self.expr)
+        expr.eval(frame)
+        for operation, expr2 in self.ops:
+            if hasattr(self, 'result'):
+                # shortcutting in chained expressions
+                if not frame.is_true(self.result):
+                    break
+            expr2 = Interpretable(expr2)
+            expr2.eval(frame)
+            self.explanation = "%s %s %s" % (
+                expr.explanation, operation, expr2.explanation)
+            source = "__exprinfo_left %s __exprinfo_right" % operation
+            try:
+                self.result = frame.eval(source,
+                                         __exprinfo_left=expr.result,
+                                         __exprinfo_right=expr2.result)
+            except passthroughex:
+                raise
+            except:
+                raise Failure(self)
+            expr = expr2
+
+class And(Interpretable):
+    __view__ = ast.And
+
+    def eval(self, frame):
+        explanations = []
+        for expr in self.nodes:
+            expr = Interpretable(expr)
+            expr.eval(frame)
+            explanations.append(expr.explanation)
+            self.result = expr.result
+            if not frame.is_true(expr.result):
+                break
+        self.explanation = '(' + ' and '.join(explanations) + ')'
+
+class Or(Interpretable):
+    __view__ = ast.Or
+
+    def eval(self, frame):
+        explanations = []
+        for expr in self.nodes:
+            expr = Interpretable(expr)
+            expr.eval(frame)
+            explanations.append(expr.explanation)
+            self.result = expr.result
+            if frame.is_true(expr.result):
+                break
+        self.explanation = '(' + ' or '.join(explanations) + ')'
+
+
+# == Unary operations ==
+keepalive = []
+for astclass, astpattern in {
+    ast.Not    : 'not __exprinfo_expr',
+    ast.Invert : '(~__exprinfo_expr)',
+    }.items():
+
+    class UnaryArith(Interpretable):
+        __view__ = astclass
+
+        def eval(self, frame, astpattern=astpattern):
+            expr = Interpretable(self.expr)
+            expr.eval(frame)
+            self.explanation = astpattern.replace('__exprinfo_expr',
+                                                  expr.explanation)
+            try:
+                self.result = frame.eval(astpattern,
+                                         __exprinfo_expr=expr.result)
+            except passthroughex:
+                raise
+            except:
+                raise Failure(self)
+
+    keepalive.append(UnaryArith)
+
+# == Binary operations ==
+for astclass, astpattern in {
+    ast.Add    : '(__exprinfo_left + __exprinfo_right)',
+    ast.Sub    : '(__exprinfo_left - __exprinfo_right)',
+    ast.Mul    : '(__exprinfo_left * __exprinfo_right)',
+    ast.Div    : '(__exprinfo_left / __exprinfo_right)',
+    ast.Mod    : '(__exprinfo_left % __exprinfo_right)',
+    ast.Power  : '(__exprinfo_left ** __exprinfo_right)',
+    }.items():
+
+    class BinaryArith(Interpretable):
+        __view__ = astclass
+
+        def eval(self, frame, astpattern=astpattern):
+            left = Interpretable(self.left)
+            left.eval(frame)
+            right = Interpretable(self.right)
+            right.eval(frame)
+            self.explanation = (astpattern
+                                .replace('__exprinfo_left',  left .explanation)
+                                .replace('__exprinfo_right', right.explanation))
+            try:
+                self.result = frame.eval(astpattern,
+                                         __exprinfo_left=left.result,
+                                         __exprinfo_right=right.result)
+            except passthroughex:
+                raise
+            except:
+                raise Failure(self)
+
+    keepalive.append(BinaryArith)
+
+
+class CallFunc(Interpretable):
+    __view__ = ast.CallFunc
+
+    def is_bool(self, frame):
+        source = 'isinstance(__exprinfo_value, bool)'
+        try:
+            return frame.is_true(frame.eval(source,
+                                            __exprinfo_value=self.result))
+        except passthroughex:
+            raise
+        except:
+            return False
+
+    def eval(self, frame):
+        node = Interpretable(self.node)
+        node.eval(frame)
+        explanations = []
+        vars = {'__exprinfo_fn': node.result}
+        source = '__exprinfo_fn('
+        for a in self.args:
+            if isinstance(a, ast.Keyword):
+                keyword = a.name
+                a = a.expr
+            else:
+                keyword = None
+            a = Interpretable(a)
+            a.eval(frame)
+            argname = '__exprinfo_%d' % len(vars)
+            vars[argname] = a.result
+            if keyword is None:
+                source += argname + ','
+                explanations.append(a.explanation)
+            else:
+                source += '%s=%s,' % (keyword, argname)
+                explanations.append('%s=%s' % (keyword, a.explanation))
+        if self.star_args:
+            star_args = Interpretable(self.star_args)
+            star_args.eval(frame)
+            argname = '__exprinfo_star'
+            vars[argname] = star_args.result
+            source += '*' + argname + ','
+            explanations.append('*' + star_args.explanation)
+        if self.dstar_args:
+            dstar_args = Interpretable(self.dstar_args)
+            dstar_args.eval(frame)
+            argname = '__exprinfo_kwds'
+            vars[argname] = dstar_args.result
+            source += '**' + argname + ','
+            explanations.append('**' + dstar_args.explanation)
+        self.explanation = "%s(%s)" % (
+            node.explanation, ', '.join(explanations))
+        if source.endswith(','):
+            source = source[:-1]
+        source += ')'
+        try:
+            self.result = frame.eval(source, **vars)
+        except passthroughex:
+            raise
+        except:
+            raise Failure(self)
+        if not node.is_builtin(frame) or not self.is_bool(frame):
+            r = frame.repr(self.result)
+            self.explanation = '%s\n{%s = %s\n}' % (r, r, self.explanation)
+
+class Getattr(Interpretable):
+    __view__ = ast.Getattr
+
+    def eval(self, frame):
+        expr = Interpretable(self.expr)
+        expr.eval(frame)
+        source = '__exprinfo_expr.%s' % self.attrname
+        try:
+            self.result = frame.eval(source, __exprinfo_expr=expr.result)
+        except passthroughex:
+            raise
+        except:
+            raise Failure(self)
+        self.explanation = '%s.%s' % (expr.explanation, self.attrname)
+        # if the attribute comes from the instance, its value is interesting
+        source = ('hasattr(__exprinfo_expr, "__dict__") and '
+                  '%r in __exprinfo_expr.__dict__' % self.attrname)
+        try:
+            from_instance = frame.is_true(
+                frame.eval(source, __exprinfo_expr=expr.result))
+        except passthroughex:
+            raise
+        except:
+            from_instance = True
+        if from_instance:
+            r = frame.repr(self.result)
+            self.explanation = '%s\n{%s = %s\n}' % (r, r, self.explanation)
+
+# == Re-interpretation of full statements ==
+
+class Assert(Interpretable):
+    __view__ = ast.Assert
+
+    def run(self, frame):
+        test = Interpretable(self.test)
+        test.eval(frame)
+        # simplify 'assert False where False = ...'
+        if (test.explanation.startswith('False\n{False = ') and
+            test.explanation.endswith('\n}')):
+            test.explanation = test.explanation[15:-2]
+        # print the result as  'assert <explanation>'
+        self.result = test.result
+        self.explanation = 'assert ' + test.explanation
+        if not frame.is_true(test.result):
+            try:
+                raise BuiltinAssertionError
+            except passthroughex:
+                raise
+            except:
+                raise Failure(self)
+
+class Assign(Interpretable):
+    __view__ = ast.Assign
+
+    def run(self, frame):
+        expr = Interpretable(self.expr)
+        expr.eval(frame)
+        self.result = expr.result
+        self.explanation = '... = ' + expr.explanation
+        # fall-back-run the rest of the assignment
+        ass = ast.Assign(self.nodes, ast.Name('__exprinfo_expr'))
+        mod = ast.Module(None, ast.Stmt([ass]))
+        mod.filename = '<run>'
+        co = pycodegen.ModuleCodeGenerator(mod).getCode()
+        try:
+            frame.exec_(co, __exprinfo_expr=expr.result)
+        except passthroughex:
+            raise
+        except:
+            raise Failure(self)
+
+class Discard(Interpretable):
+    __view__ = ast.Discard
+
+    def run(self, frame):
+        expr = Interpretable(self.expr)
+        expr.eval(frame)
+        self.result = expr.result
+        self.explanation = expr.explanation
+
+class Stmt(Interpretable):
+    __view__ = ast.Stmt
+
+    def run(self, frame):
+        for stmt in self.nodes:
+            stmt = Interpretable(stmt)
+            stmt.run(frame)
+
+
+def report_failure(e):
+    explanation = e.node.nice_explanation()
+    if explanation:
+        explanation = ", in: " + explanation
+    else:
+        explanation = ""
+    sys.stdout.write("%s: %s%s\n" % (e.exc.__name__, e.value, explanation))
+
+def check(s, frame=None):
+    if frame is None:
+        frame = sys._getframe(1)
+        frame = py.code.Frame(frame)
+    expr = parse(s, 'eval')
+    assert isinstance(expr, ast.Expression)
+    node = Interpretable(expr.node)
+    try:
+        node.eval(frame)
+    except passthroughex:
+        raise
+    except Failure:
+        e = sys.exc_info()[1]
+        report_failure(e)
+    else:
+        if not frame.is_true(node.result):
+            sys.stderr.write("assertion failed: %s\n" % node.nice_explanation())
+
+
+###########################################################
+# API / Entry points
+# #########################################################
+
+def interpret(source, frame, should_fail=False):
+    module = Interpretable(parse(source, 'exec').node)
+    #print "got module", module
+    if isinstance(frame, types.FrameType):
+        frame = py.code.Frame(frame)
+    try:
+        module.run(frame)
+    except Failure:
+        e = sys.exc_info()[1]
+        return getfailure(e)
+    except passthroughex:
+        raise
+    except:
+        import traceback
+        traceback.print_exc()
+    if should_fail:
+        return ("(assertion failed, but when it was re-run for "
+                "printing intermediate values, it did not fail.  Suggestions: "
+                "compute assert expression before the assert or use --nomagic)")
+    else:
+        return None
+
+def getmsg(excinfo):
+    if isinstance(excinfo, tuple):
+        excinfo = py.code.ExceptionInfo(excinfo)
+    #frame, line = gettbline(tb)
+    #frame = py.code.Frame(frame)
+    #return interpret(line, frame)
+
+    tb = excinfo.traceback[-1]
+    source = str(tb.statement).strip()
+    x = interpret(source, tb.frame, should_fail=True)
+    if not isinstance(x, str):
+        raise TypeError("interpret returned non-string %r" % (x,))
+    return x
+
+def getfailure(e):
+    explanation = e.node.nice_explanation()
+    if str(e.value):
+        lines = explanation.split('\n')
+        lines[0] += "  << %s" % (e.value,)
+        explanation = '\n'.join(lines)
+    text = "%s: %s" % (e.exc.__name__, explanation)
+    if text.startswith('AssertionError: assert '):
+        text = text[16:]
+    return text
+
+def run(s, frame=None):
+    if frame is None:
+        frame = sys._getframe(1)
+        frame = py.code.Frame(frame)
+    module = Interpretable(parse(s, 'exec').node)
+    try:
+        module.run(frame)
+    except Failure:
+        e = sys.exc_info()[1]
+        report_failure(e)
+
+
+if __name__ == '__main__':
+    # example:
+    def f():
+        return 5
+    def g():
+        return 3
+    def h(x):
+        return 'never'
+    check("f() * g() == 5")
+    check("not f()")
+    check("not (f() and g() or 0)")
+    check("f() == g()")
+    i = 4
+    check("i == f()")
+    check("len(f()) == 0")
+    check("isinstance(2+3+4, float)")
+
+    run("x = i")
+    check("x == 5")
+
+    run("assert not f(), 'oops'")
+    run("a, b, c = 1, 2")
+    run("a, b, c = f()")
+
+    check("max([f(),g()]) == 4")
+    check("'hello'[g()] == 'h'")
+    run("'guk%d' % h(f())")

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_code/_py2traceback.py

@@ -0,0 +1,79 @@
+# copied from python-2.7.3's traceback.py
+# CHANGES:
+# - some_str is replaced, trying to create unicode strings
+#
+import types
+
+def format_exception_only(etype, value):
+    """Format the exception part of a traceback.
+
+    The arguments are the exception type and value such as given by
+    sys.last_type and sys.last_value. The return value is a list of
+    strings, each ending in a newline.
+
+    Normally, the list contains a single string; however, for
+    SyntaxError exceptions, it contains several lines that (when
+    printed) display detailed information about where the syntax
+    error occurred.
+
+    The message indicating which exception occurred is always the last
+    string in the list.
+
+    """
+
+    # An instance should not have a meaningful value parameter, but
+    # sometimes does, particularly for string exceptions, such as
+    # >>> raise string1, string2  # deprecated
+    #
+    # Clear these out first because issubtype(string1, SyntaxError)
+    # would throw another exception and mask the original problem.
+    if (isinstance(etype, BaseException) or
+        isinstance(etype, types.InstanceType) or
+        etype is None or type(etype) is str):
+        return [_format_final_exc_line(etype, value)]
+
+    stype = etype.__name__
+
+    if not issubclass(etype, SyntaxError):
+        return [_format_final_exc_line(stype, value)]
+
+    # It was a syntax error; show exactly where the problem was found.
+    lines = []
+    try:
+        msg, (filename, lineno, offset, badline) = value.args
+    except Exception:
+        pass
+    else:
+        filename = filename or "<string>"
+        lines.append('  File "%s", line %d\n' % (filename, lineno))
+        if badline is not None:
+            lines.append('    %s\n' % badline.strip())
+            if offset is not None:
+                caretspace = badline.rstrip('\n')[:offset].lstrip()
+                # non-space whitespace (likes tabs) must be kept for alignment
+                caretspace = ((c.isspace() and c or ' ') for c in caretspace)
+                # only three spaces to account for offset1 == pos 0
+                lines.append('   %s^\n' % ''.join(caretspace))
+        value = msg
+
+    lines.append(_format_final_exc_line(stype, value))
+    return lines
+
+def _format_final_exc_line(etype, value):
+    """Return a list of a single line -- normal case for format_exception_only"""
+    valuestr = _some_str(value)
+    if value is None or not valuestr:
+        line = "%s\n" % etype
+    else:
+        line = "%s: %s\n" % (etype, valuestr)
+    return line
+
+def _some_str(value):
+    try:
+        return unicode(value)
+    except Exception:
+        try:
+            return str(value)
+        except Exception:
+            pass
+    return '<unprintable %s object>' % type(value).__name__

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_code/assertion.py

@@ -0,0 +1,90 @@
+import sys
+import py
+
+BuiltinAssertionError = py.builtin.builtins.AssertionError
+
+_reprcompare = None # if set, will be called by assert reinterp for comparison ops
+
+def _format_explanation(explanation):
+    """This formats an explanation
+
+    Normally all embedded newlines are escaped, however there are
+    three exceptions: \n{, \n} and \n~.  The first two are intended
+    cover nested explanations, see function and attribute explanations
+    for examples (.visit_Call(), visit_Attribute()).  The last one is
+    for when one explanation needs to span multiple lines, e.g. when
+    displaying diffs.
+    """
+    raw_lines = (explanation or '').split('\n')
+    # escape newlines not followed by {, } and ~
+    lines = [raw_lines[0]]
+    for l in raw_lines[1:]:
+        if l.startswith('{') or l.startswith('}') or l.startswith('~'):
+            lines.append(l)
+        else:
+            lines[-1] += '\\n' + l
+
+    result = lines[:1]
+    stack = [0]
+    stackcnt = [0]
+    for line in lines[1:]:
+        if line.startswith('{'):
+            if stackcnt[-1]:
+                s = 'and   '
+            else:
+                s = 'where '
+            stack.append(len(result))
+            stackcnt[-1] += 1
+            stackcnt.append(0)
+            result.append(' +' + '  '*(len(stack)-1) + s + line[1:])
+        elif line.startswith('}'):
+            assert line.startswith('}')
+            stack.pop()
+            stackcnt.pop()
+            result[stack[-1]] += line[1:]
+        else:
+            assert line.startswith('~')
+            result.append('  '*len(stack) + line[1:])
+    assert len(stack) == 1
+    return '\n'.join(result)
+
+
+class AssertionError(BuiltinAssertionError):
+    def __init__(self, *args):
+        BuiltinAssertionError.__init__(self, *args)
+        if args:
+            try:
+                self.msg = str(args[0])
+            except py.builtin._sysex:
+                raise
+            except:
+                self.msg = "<[broken __repr__] %s at %0xd>" %(
+                    args[0].__class__, id(args[0]))
+        else:
+            f = py.code.Frame(sys._getframe(1))
+            try:
+                source = f.code.fullsource
+                if source is not None:
+                    try:
+                        source = source.getstatement(f.lineno, assertion=True)
+                    except IndexError:
+                        source = None
+                    else:
+                        source = str(source.deindent()).strip()
+            except py.error.ENOENT:
+                source = None
+                # this can also occur during reinterpretation, when the
+                # co_filename is set to "<run>".
+            if source:
+                self.msg = reinterpret(source, f, should_fail=True)
+            else:
+                self.msg = "<could not determine information>"
+            if not self.args:
+                self.args = (self.msg,)
+
+if sys.version_info > (3, 0):
+    AssertionError.__module__ = "builtins"
+    reinterpret_old = "old reinterpretation not available for py3"
+else:
+    from py._code._assertionold import interpret as reinterpret_old
+from py._code._assertionnew import interpret as reinterpret

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_code/code.py

@@ -0,0 +1,796 @@
+import py
+import sys
+from inspect import CO_VARARGS, CO_VARKEYWORDS, isclass
+
+builtin_repr = repr
+
+reprlib = py.builtin._tryimport('repr', 'reprlib')
+
+if sys.version_info[0] >= 3:
+    from traceback import format_exception_only
+else:
+    from py._code._py2traceback import format_exception_only
+
+import traceback
+
+
+class Code(object):
+    """ wrapper around Python code objects """
+    def __init__(self, rawcode):
+        if not hasattr(rawcode, "co_filename"):
+            rawcode = py.code.getrawcode(rawcode)
+        try:
+            self.filename = rawcode.co_filename
+            self.firstlineno = rawcode.co_firstlineno - 1
+            self.name = rawcode.co_name
+        except AttributeError:
+            raise TypeError("not a code object: %r" % (rawcode,))
+        self.raw = rawcode
+
+    def __eq__(self, other):
+        return self.raw == other.raw
+
+    def __ne__(self, other):
+        return not self == other
+
+    @property
+    def path(self):
+        """ return a path object pointing to source code (note that it
+        might not point to an actually existing file). """
+        p = py.path.local(self.raw.co_filename)
+        # maybe don't try this checking
+        if not p.check():
+            # XXX maybe try harder like the weird logic
+            # in the standard lib [linecache.updatecache] does?
+            p = self.raw.co_filename
+        return p
+
+    @property
+    def fullsource(self):
+        """ return a py.code.Source object for the full source file of the code
+        """
+        from py._code import source
+        full, _ = source.findsource(self.raw)
+        return full
+
+    def source(self):
+        """ return a py.code.Source object for the code object's source only
+        """
+        # return source only for that part of code
+        return py.code.Source(self.raw)
+
+    def getargs(self, var=False):
+        """ return a tuple with the argument names for the code object
+
+            if 'var' is set True also return the names of the variable and
+            keyword arguments when present
+        """
+        # handfull shortcut for getting args
+        raw = self.raw
+        argcount = raw.co_argcount
+        if var:
+            argcount += raw.co_flags & CO_VARARGS
+            argcount += raw.co_flags & CO_VARKEYWORDS
+        return raw.co_varnames[:argcount]
+
+class Frame(object):
+    """Wrapper around a Python frame holding f_locals and f_globals
+    in which expressions can be evaluated."""
+
+    def __init__(self, frame):
+        self.lineno = frame.f_lineno - 1
+        self.f_globals = frame.f_globals
+        self.f_locals = frame.f_locals
+        self.raw = frame
+        self.code = py.code.Code(frame.f_code)
+
+    @property
+    def statement(self):
+        """ statement this frame is at """
+        if self.code.fullsource is None:
+            return py.code.Source("")
+        return self.code.fullsource.getstatement(self.lineno)
+
+    def eval(self, code, **vars):
+        """ evaluate 'code' in the frame
+
+            'vars' are optional additional local variables
+
+            returns the result of the evaluation
+        """
+        f_locals = self.f_locals.copy()
+        f_locals.update(vars)
+        return eval(code, self.f_globals, f_locals)
+
+    def exec_(self, code, **vars):
+        """ exec 'code' in the frame
+
+            'vars' are optiona; additional local variables
+        """
+        f_locals = self.f_locals.copy()
+        f_locals.update(vars)
+        py.builtin.exec_(code, self.f_globals, f_locals)
+
+    def repr(self, object):
+        """ return a 'safe' (non-recursive, one-line) string repr for 'object'
+        """
+        return py.io.saferepr(object)
+
+    def is_true(self, object):
+        return object
+
+    def getargs(self, var=False):
+        """ return a list of tuples (name, value) for all arguments
+
+            if 'var' is set True also include the variable and keyword
+            arguments when present
+        """
+        retval = []
+        for arg in self.code.getargs(var):
+            try:
+                retval.append((arg, self.f_locals[arg]))
+            except KeyError:
+                pass     # this can occur when using Psyco
+        return retval
+
+
+class TracebackEntry(object):
+    """ a single entry in a traceback """
+
+    _repr_style = None
+    exprinfo = None
+
+    def __init__(self, rawentry):
+        self._rawentry = rawentry
+        self.lineno = rawentry.tb_lineno - 1
+
+    def set_repr_style(self, mode):
+        assert mode in ("short", "long")
+        self._repr_style = mode
+
+    @property
+    def frame(self):
+        return py.code.Frame(self._rawentry.tb_frame)
+
+    @property
+    def relline(self):
+        return self.lineno - self.frame.code.firstlineno
+
+    def __repr__(self):
+        return "<TracebackEntry %s:%d>" % (self.frame.code.path, self.lineno+1)
+
+    @property
+    def statement(self):
+        """ py.code.Source object for the current statement """
+        source = self.frame.code.fullsource
+        return source.getstatement(self.lineno)
+
+    @property
+    def path(self):
+        """ path to the source code """
+        return self.frame.code.path
+
+    def getlocals(self):
+        return self.frame.f_locals
+    locals = property(getlocals, None, None, "locals of underlaying frame")
+
+    def reinterpret(self):
+        """Reinterpret the failing statement and returns a detailed information
+           about what operations are performed."""
+        if self.exprinfo is None:
+            source = str(self.statement).strip()
+            x = py.code._reinterpret(source, self.frame, should_fail=True)
+            if not isinstance(x, str):
+                raise TypeError("interpret returned non-string %r" % (x,))
+            self.exprinfo = x
+        return self.exprinfo
+
+    def getfirstlinesource(self):
+        # on Jython this firstlineno can be -1 apparently
+        return max(self.frame.code.firstlineno, 0)
+
+    def getsource(self, astcache=None):
+        """ return failing source code. """
+        # we use the passed in astcache to not reparse asttrees
+        # within exception info printing
+        from py._code.source import getstatementrange_ast
+        source = self.frame.code.fullsource
+        if source is None:
+            return None
+        key = astnode = None
+        if astcache is not None:
+            key = self.frame.code.path
+            if key is not None:
+                astnode = astcache.get(key, None)
+        start = self.getfirstlinesource()
+        try:
+            astnode, _, end = getstatementrange_ast(self.lineno, source,
+                                                    astnode=astnode)
+        except SyntaxError:
+            end = self.lineno + 1
+        else:
+            if key is not None:
+                astcache[key] = astnode
+        return source[start:end]
+
+    source = property(getsource)
+
+    def ishidden(self):
+        """ return True if the current frame has a var __tracebackhide__
+            resolving to True
+
+            mostly for internal use
+        """
+        try:
+            return self.frame.f_locals['__tracebackhide__']
+        except KeyError:
+            try:
+                return self.frame.f_globals['__tracebackhide__']
+            except KeyError:
+                return False
+
+    def __str__(self):
+        try:
+            fn = str(self.path)
+        except py.error.Error:
+            fn = '???'
+        name = self.frame.code.name
+        try:
+            line = str(self.statement).lstrip()
+        except KeyboardInterrupt:
+            raise
+        except:
+            line = "???"
+        return "  File %r:%d in %s\n  %s\n" % (fn, self.lineno+1, name, line)
+
+    def name(self):
+        return self.frame.code.raw.co_name
+    name = property(name, None, None, "co_name of underlaying code")
+
+
+class Traceback(list):
+    """ Traceback objects encapsulate and offer higher level
+        access to Traceback entries.
+    """
+    Entry = TracebackEntry
+
+    def __init__(self, tb):
+        """ initialize from given python traceback object. """
+        if hasattr(tb, 'tb_next'):
+            def f(cur):
+                while cur is not None:
+                    yield self.Entry(cur)
+                    cur = cur.tb_next
+            list.__init__(self, f(tb))
+        else:
+            list.__init__(self, tb)
+
+    def cut(self, path=None, lineno=None, firstlineno=None, excludepath=None):
+        """ return a Traceback instance wrapping part of this Traceback
+
+            by provding any combination of path, lineno and firstlineno, the
+            first frame to start the to-be-returned traceback is determined
+
+            this allows cutting the first part of a Traceback instance e.g.
+            for formatting reasons (removing some uninteresting bits that deal
+            with handling of the exception/traceback)
+        """
+        for x in self:
+            code = x.frame.code
+            codepath = code.path
+            if ((path is None or codepath == path) and
+                (excludepath is None or not hasattr(codepath, 'relto') or
+                 not codepath.relto(excludepath)) and
+                (lineno is None or x.lineno == lineno) and
+                (firstlineno is None or x.frame.code.firstlineno == firstlineno)):
+                return Traceback(x._rawentry)
+        return self
+
+    def __getitem__(self, key):
+        val = super(Traceback, self).__getitem__(key)
+        if isinstance(key, type(slice(0))):
+            val = self.__class__(val)
+        return val
+
+    def filter(self, fn=lambda x: not x.ishidden()):
+        """ return a Traceback instance with certain items removed
+
+            fn is a function that gets a single argument, a TracebackItem
+            instance, and should return True when the item should be added
+            to the Traceback, False when not
+
+            by default this removes all the TracebackItems which are hidden
+            (see ishidden() above)
+        """
+        return Traceback(filter(fn, self))
+
+    def getcrashentry(self):
+        """ return last non-hidden traceback entry that lead
+        to the exception of a traceback.
+        """
+        for i in range(-1, -len(self)-1, -1):
+            entry = self[i]
+            if not entry.ishidden():
+                return entry
+        return self[-1]
+
+    def recursionindex(self):
+        """ return the index of the frame/TracebackItem where recursion
+            originates if appropriate, None if no recursion occurred
+        """
+        cache = {}
+        for i, entry in enumerate(self):
+            # id for the code.raw is needed to work around
+            # the strange metaprogramming in the decorator lib from pypi
+            # which generates code objects that have hash/value equality
+            #XXX needs a test
+            key = entry.frame.code.path, id(entry.frame.code.raw), entry.lineno
+            #print "checking for recursion at", key
+            l = cache.setdefault(key, [])
+            if l:
+                f = entry.frame
+                loc = f.f_locals
+                for otherloc in l:
+                    if f.is_true(f.eval(co_equal,
+                        __recursioncache_locals_1=loc,
+                        __recursioncache_locals_2=otherloc)):
+                        return i
+            l.append(entry.frame.f_locals)
+        return None
+
+co_equal = compile('__recursioncache_locals_1 == __recursioncache_locals_2',
+                   '?', 'eval')
+
+class ExceptionInfo(object):
+    """ wraps sys.exc_info() objects and offers
+        help for navigating the traceback.
+    """
+    _striptext = ''
+    def __init__(self, tup=None, exprinfo=None):
+        if tup is None:
+            tup = sys.exc_info()
+            if exprinfo is None and isinstance(tup[1], AssertionError):
+                exprinfo = getattr(tup[1], 'msg', None)
+                if exprinfo is None:
+                    exprinfo = str(tup[1])
+                if exprinfo and exprinfo.startswith('assert '):
+                    self._striptext = 'AssertionError: '
+        self._excinfo = tup
+        #: the exception class
+        self.type = tup[0]
+        #: the exception instance
+        self.value = tup[1]
+        #: the exception raw traceback
+        self.tb = tup[2]
+        #: the exception type name
+        self.typename = self.type.__name__
+        #: the exception traceback (py.code.Traceback instance)
+        self.traceback = py.code.Traceback(self.tb)
+
+    def __repr__(self):
+        return "<ExceptionInfo %s tblen=%d>" % (
+            self.typename, len(self.traceback))
+
+    def exconly(self, tryshort=False):
+        """ return the exception as a string
+
+            when 'tryshort' resolves to True, and the exception is a
+            py.code._AssertionError, only the actual exception part of
+            the exception representation is returned (so 'AssertionError: ' is
+            removed from the beginning)
+        """
+        lines = format_exception_only(self.type, self.value)
+        text = ''.join(lines)
+        text = text.rstrip()
+        if tryshort:
+            if text.startswith(self._striptext):
+                text = text[len(self._striptext):]
+        return text
+
+    def errisinstance(self, exc):
+        """ return True if the exception is an instance of exc """
+        return isinstance(self.value, exc)
+
+    def _getreprcrash(self):
+        exconly = self.exconly(tryshort=True)
+        entry = self.traceback.getcrashentry()
+        path, lineno = entry.frame.code.raw.co_filename, entry.lineno
+        return ReprFileLocation(path, lineno+1, exconly)
+
+    def getrepr(self, showlocals=False, style="long",
+                abspath=False, tbfilter=True, funcargs=False):
+        """ return str()able representation of this exception info.
+            showlocals: show locals per traceback entry
+            style: long|short|no|native traceback style
+            tbfilter: hide entries (where __tracebackhide__ is true)
+
+            in case of style==native, tbfilter and showlocals is ignored.
+        """
+        if style == 'native':
+            return ReprExceptionInfo(ReprTracebackNative(
+                traceback.format_exception(
+                    self.type,
+                    self.value,
+                    self.traceback[0]._rawentry,
+                )), self._getreprcrash())
+
+        fmt = FormattedExcinfo(
+            showlocals=showlocals, style=style,
+            abspath=abspath, tbfilter=tbfilter, funcargs=funcargs)
+        return fmt.repr_excinfo(self)
+
+    def __str__(self):
+        entry = self.traceback[-1]
+        loc = ReprFileLocation(entry.path, entry.lineno + 1, self.exconly())
+        return str(loc)
+
+    def __unicode__(self):
+        entry = self.traceback[-1]
+        loc = ReprFileLocation(entry.path, entry.lineno + 1, self.exconly())
+        return loc.__unicode__()
+
+
+class FormattedExcinfo(object):
+    """ presenting information about failing Functions and Generators. """
+    # for traceback entries
+    flow_marker = ">"
+    fail_marker = "E"
+
+    def __init__(self, showlocals=False, style="long",
+                 abspath=True, tbfilter=True, funcargs=False):
+        self.showlocals = showlocals
+        self.style = style
+        self.tbfilter = tbfilter
+        self.funcargs = funcargs
+        self.abspath = abspath
+        self.astcache = {}
+
+    def _getindent(self, source):
+        # figure out indent for given source
+        try:
+            s = str(source.getstatement(len(source)-1))
+        except KeyboardInterrupt:
+            raise
+        except:
+            try:
+                s = str(source[-1])
+            except KeyboardInterrupt:
+                raise
+            except:
+                return 0
+        return 4 + (len(s) - len(s.lstrip()))
+
+    def _getentrysource(self, entry):
+        source = entry.getsource(self.astcache)
+        if source is not None:
+            source = source.deindent()
+        return source
+
+    def _saferepr(self, obj):
+        return py.io.saferepr(obj)
+
+    def repr_args(self, entry):
+        if self.funcargs:
+            args = []
+            for argname, argvalue in entry.frame.getargs(var=True):
+                args.append((argname, self._saferepr(argvalue)))
+            return ReprFuncArgs(args)
+
+    def get_source(self, source, line_index=-1, excinfo=None, short=False):
+        """ return formatted and marked up source lines. """
+        lines = []
+        if source is None or line_index >= len(source.lines):
+            source = py.code.Source("???")
+            line_index = 0
+        if line_index < 0:
+            line_index += len(source)
+        space_prefix = "    "
+        if short:
+            lines.append(space_prefix + source.lines[line_index].strip())
+        else:
+            for line in source.lines[:line_index]:
+                lines.append(space_prefix + line)
+            lines.append(self.flow_marker + "   " + source.lines[line_index])
+            for line in source.lines[line_index+1:]:
+                lines.append(space_prefix + line)
+        if excinfo is not None:
+            indent = 4 if short else self._getindent(source)
+            lines.extend(self.get_exconly(excinfo, indent=indent, markall=True))
+        return lines
+
+    def get_exconly(self, excinfo, indent=4, markall=False):
+        lines = []
+        indent = " " * indent
+        # get the real exception information out
+        exlines = excinfo.exconly(tryshort=True).split('\n')
+        failindent = self.fail_marker + indent[1:]
+        for line in exlines:
+            lines.append(failindent + line)
+            if not markall:
+                failindent = indent
+        return lines
+
+    def repr_locals(self, locals):
+        if self.showlocals:
+            lines = []
+            keys = [loc for loc in locals if loc[0] != "@"]
+            keys.sort()
+            for name in keys:
+                value = locals[name]
+                if name == '__builtins__':
+                    lines.append("__builtins__ = <builtins>")
+                else:
+                    # This formatting could all be handled by the
+                    # _repr() function, which is only reprlib.Repr in
+                    # disguise, so is very configurable.
+                    str_repr = self._saferepr(value)
+                    #if len(str_repr) < 70 or not isinstance(value,
+                    #                            (list, tuple, dict)):
+                    lines.append("%-10s = %s" %(name, str_repr))
+                    #else:
+                    #    self._line("%-10s =\\" % (name,))
+                    #    # XXX
+                    #    pprint.pprint(value, stream=self.excinfowriter)
+            return ReprLocals(lines)
+
+    def repr_traceback_entry(self, entry, excinfo=None):
+        source = self._getentrysource(entry)
+        if source is None:
+            source = py.code.Source("???")
+            line_index = 0
+        else:
+            # entry.getfirstlinesource() can be -1, should be 0 on jython
+            line_index = entry.lineno - max(entry.getfirstlinesource(), 0)
+
+        lines = []
+        style = entry._repr_style
+        if style is None:
+            style = self.style
+        if style in ("short", "long"):
+            short = style == "short"
+            reprargs = self.repr_args(entry) if not short else None
+            s = self.get_source(source, line_index, excinfo, short=short)
+            lines.extend(s)
+            if short:
+                message = "in %s" %(entry.name)
+            else:
+                message = excinfo and excinfo.typename or ""
+            path = self._makepath(entry.path)
+            filelocrepr = ReprFileLocation(path, entry.lineno+1, message)
+            localsrepr = None
+            if not short:
+                localsrepr =  self.repr_locals(entry.locals)
+            return ReprEntry(lines, reprargs, localsrepr, filelocrepr, style)
+        if excinfo:
+            lines.extend(self.get_exconly(excinfo, indent=4))
+        return ReprEntry(lines, None, None, None, style)
+
+    def _makepath(self, path):
+        if not self.abspath:
+            try:
+                np = py.path.local().bestrelpath(path)
+            except OSError:
+                return path
+            if len(np) < len(str(path)):
+                path = np
+        return path
+
+    def repr_traceback(self, excinfo):
+        traceback = excinfo.traceback
+        if self.tbfilter:
+            traceback = traceback.filter()
+        recursionindex = None
+        if excinfo.errisinstance(RuntimeError):
+            if "maximum recursion depth exceeded" in str(excinfo.value):
+                recursionindex = traceback.recursionindex()
+        last = traceback[-1]
+        entries = []
+        extraline = None
+        for index, entry in enumerate(traceback):
+            einfo = (last == entry) and excinfo or None
+            reprentry = self.repr_traceback_entry(entry, einfo)
+            entries.append(reprentry)
+            if index == recursionindex:
+                extraline = "!!! Recursion detected (same locals & position)"
+                break
+        return ReprTraceback(entries, extraline, style=self.style)
+
+    def repr_excinfo(self, excinfo):
+        reprtraceback = self.repr_traceback(excinfo)
+        reprcrash = excinfo._getreprcrash()
+        return ReprExceptionInfo(reprtraceback, reprcrash)
+
+class TerminalRepr:
+    def __str__(self):
+        s = self.__unicode__()
+        if sys.version_info[0] < 3:
+            s = s.encode('utf-8')
+        return s
+
+    def __unicode__(self):
+        # FYI this is called from pytest-xdist's serialization of exception
+        # information.
+        io = py.io.TextIO()
+        tw = py.io.TerminalWriter(file=io)
+        self.toterminal(tw)
+        return io.getvalue().strip()
+
+    def __repr__(self):
+        return "<%s instance at %0x>" %(self.__class__, id(self))
+
+
+class ReprExceptionInfo(TerminalRepr):
+    def __init__(self, reprtraceback, reprcrash):
+        self.reprtraceback = reprtraceback
+        self.reprcrash = reprcrash
+        self.sections = []
+
+    def addsection(self, name, content, sep="-"):
+        self.sections.append((name, content, sep))
+
+    def toterminal(self, tw):
+        self.reprtraceback.toterminal(tw)
+        for name, content, sep in self.sections:
+            tw.sep(sep, name)
+            tw.line(content)
+
+class ReprTraceback(TerminalRepr):
+    entrysep = "_ "
+
+    def __init__(self, reprentries, extraline, style):
+        self.reprentries = reprentries
+        self.extraline = extraline
+        self.style = style
+
+    def toterminal(self, tw):
+        # the entries might have different styles
+        last_style = None
+        for i, entry in enumerate(self.reprentries):
+            if entry.style == "long":
+                tw.line("")
+            entry.toterminal(tw)
+            if i < len(self.reprentries) - 1:
+                next_entry = self.reprentries[i+1]
+                if entry.style == "long" or \
+                   entry.style == "short" and next_entry.style == "long":
+                    tw.sep(self.entrysep)
+
+        if self.extraline:
+            tw.line(self.extraline)
+
+class ReprTracebackNative(ReprTraceback):
+    def __init__(self, tblines):
+        self.style = "native"
+        self.reprentries = [ReprEntryNative(tblines)]
+        self.extraline = None
+
+class ReprEntryNative(TerminalRepr):
+    style = "native"
+
+    def __init__(self, tblines):
+        self.lines = tblines
+
+    def toterminal(self, tw):
+        tw.write("".join(self.lines))
+
+class ReprEntry(TerminalRepr):
+    localssep = "_ "
+
+    def __init__(self, lines, reprfuncargs, reprlocals, filelocrepr, style):
+        self.lines = lines
+        self.reprfuncargs = reprfuncargs
+        self.reprlocals = reprlocals
+        self.reprfileloc = filelocrepr
+        self.style = style
+
+    def toterminal(self, tw):
+        if self.style == "short":
+            self.reprfileloc.toterminal(tw)
+            for line in self.lines:
+                red = line.startswith("E   ")
+                tw.line(line, bold=True, red=red)
+            #tw.line("")
+            return
+        if self.reprfuncargs:
+            self.reprfuncargs.toterminal(tw)
+        for line in self.lines:
+            red = line.startswith("E   ")
+            tw.line(line, bold=True, red=red)
+        if self.reprlocals:
+            #tw.sep(self.localssep, "Locals")
+            tw.line("")
+            self.reprlocals.toterminal(tw)
+        if self.reprfileloc:
+            if self.lines:
+                tw.line("")
+            self.reprfileloc.toterminal(tw)
+
+    def __str__(self):
+        return "%s\n%s\n%s" % ("\n".join(self.lines),
+                               self.reprlocals,
+                               self.reprfileloc)
+
+class ReprFileLocation(TerminalRepr):
+    def __init__(self, path, lineno, message):
+        self.path = str(path)
+        self.lineno = lineno
+        self.message = message
+
+    def toterminal(self, tw):
+        # filename and lineno output for each entry,
+        # using an output format that most editors unterstand
+        msg = self.message
+        i = msg.find("\n")
+        if i != -1:
+            msg = msg[:i]
+        tw.line("%s:%s: %s" %(self.path, self.lineno, msg))
+
+class ReprLocals(TerminalRepr):
+    def __init__(self, lines):
+        self.lines = lines
+
+    def toterminal(self, tw):
+        for line in self.lines:
+            tw.line(line)
+
+class ReprFuncArgs(TerminalRepr):
+    def __init__(self, args):
+        self.args = args
+
+    def toterminal(self, tw):
+        if self.args:
+            linesofar = ""
+            for name, value in self.args:
+                ns = "%s = %s" %(name, value)
+                if len(ns) + len(linesofar) + 2 > tw.fullwidth:
+                    if linesofar:
+                        tw.line(linesofar)
+                    linesofar =  ns
+                else:
+                    if linesofar:
+                        linesofar += ", " + ns
+                    else:
+                        linesofar = ns
+            if linesofar:
+                tw.line(linesofar)
+            tw.line("")
+
+
+
+oldbuiltins = {}
+
+def patch_builtins(assertion=True, compile=True):
+    """ put compile and AssertionError builtins to Python's builtins. """
+    if assertion:
+        from py._code import assertion
+        l = oldbuiltins.setdefault('AssertionError', [])
+        l.append(py.builtin.builtins.AssertionError)
+        py.builtin.builtins.AssertionError = assertion.AssertionError
+    if compile:
+        l = oldbuiltins.setdefault('compile', [])
+        l.append(py.builtin.builtins.compile)
+        py.builtin.builtins.compile = py.code.compile
+
+def unpatch_builtins(assertion=True, compile=True):
+    """ remove compile and AssertionError builtins from Python builtins. """
+    if assertion:
+        py.builtin.builtins.AssertionError = oldbuiltins['AssertionError'].pop()
+    if compile:
+        py.builtin.builtins.compile = oldbuiltins['compile'].pop()
+
+def getrawcode(obj, trycall=True):
+    """ return code object for given function. """
+    try:
+        return obj.__code__
+    except AttributeError:
+        obj = getattr(obj, 'im_func', obj)
+        obj = getattr(obj, 'func_code', obj)
+        obj = getattr(obj, 'f_code', obj)
+        obj = getattr(obj, '__code__', obj)
+        if trycall and not hasattr(obj, 'co_firstlineno'):
+            if hasattr(obj, '__call__') and not isclass(obj):
+                x = getrawcode(obj.__call__, trycall=False)
+                if hasattr(x, 'co_firstlineno'):
+                    return x
+        return obj
+

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_code/source.py

@@ -0,0 +1,410 @@
+from __future__ import generators
+
+from bisect import bisect_right
+import sys
+import inspect, tokenize
+import py
+from types import ModuleType
+cpy_compile = compile
+
+try:
+    import _ast
+    from _ast import PyCF_ONLY_AST as _AST_FLAG
+except ImportError:
+    _AST_FLAG = 0
+    _ast = None
+
+
+class Source(object):
+    """ a immutable object holding a source code fragment,
+        possibly deindenting it.
+    """
+    _compilecounter = 0
+    def __init__(self, *parts, **kwargs):
+        self.lines = lines = []
+        de = kwargs.get('deindent', True)
+        rstrip = kwargs.get('rstrip', True)
+        for part in parts:
+            if not part:
+                partlines = []
+            if isinstance(part, Source):
+                partlines = part.lines
+            elif isinstance(part, (tuple, list)):
+                partlines = [x.rstrip("\n") for x in part]
+            elif isinstance(part, py.builtin._basestring):
+                partlines = part.split('\n')
+                if rstrip:
+                    while partlines:
+                        if partlines[-1].strip():
+                            break
+                        partlines.pop()
+            else:
+                partlines = getsource(part, deindent=de).lines
+            if de:
+                partlines = deindent(partlines)
+            lines.extend(partlines)
+
+    def __eq__(self, other):
+        try:
+            return self.lines == other.lines
+        except AttributeError:
+            if isinstance(other, str):
+                return str(self) == other
+            return False
+
+    def __getitem__(self, key):
+        if isinstance(key, int):
+            return self.lines[key]
+        else:
+            if key.step not in (None, 1):
+                raise IndexError("cannot slice a Source with a step")
+            return self.__getslice__(key.start, key.stop)
+
+    def __len__(self):
+        return len(self.lines)
+
+    def __getslice__(self, start, end):
+        newsource = Source()
+        newsource.lines = self.lines[start:end]
+        return newsource
+
+    def strip(self):
+        """ return new source object with trailing
+            and leading blank lines removed.
+        """
+        start, end = 0, len(self)
+        while start < end and not self.lines[start].strip():
+            start += 1
+        while end > start and not self.lines[end-1].strip():
+            end -= 1
+        source = Source()
+        source.lines[:] = self.lines[start:end]
+        return source
+
+    def putaround(self, before='', after='', indent=' ' * 4):
+        """ return a copy of the source object with
+            'before' and 'after' wrapped around it.
+        """
+        before = Source(before)
+        after = Source(after)
+        newsource = Source()
+        lines = [ (indent + line) for line in self.lines]
+        newsource.lines = before.lines + lines +  after.lines
+        return newsource
+
+    def indent(self, indent=' ' * 4):
+        """ return a copy of the source object with
+            all lines indented by the given indent-string.
+        """
+        newsource = Source()
+        newsource.lines = [(indent+line) for line in self.lines]
+        return newsource
+
+    def getstatement(self, lineno, assertion=False):
+        """ return Source statement which contains the
+            given linenumber (counted from 0).
+        """
+        start, end = self.getstatementrange(lineno, assertion)
+        return self[start:end]
+
+    def getstatementrange(self, lineno, assertion=False):
+        """ return (start, end) tuple which spans the minimal
+            statement region which containing the given lineno.
+        """
+        if not (0 <= lineno < len(self)):
+            raise IndexError("lineno out of range")
+        ast, start, end = getstatementrange_ast(lineno, self)
+        return start, end
+
+    def deindent(self, offset=None):
+        """ return a new source object deindented by offset.
+            If offset is None then guess an indentation offset from
+            the first non-blank line.  Subsequent lines which have a
+            lower indentation offset will be copied verbatim as
+            they are assumed to be part of multilines.
+        """
+        # XXX maybe use the tokenizer to properly handle multiline
+        #     strings etc.pp?
+        newsource = Source()
+        newsource.lines[:] = deindent(self.lines, offset)
+        return newsource
+
+    def isparseable(self, deindent=True):
+        """ return True if source is parseable, heuristically
+            deindenting it by default.
+        """
+        try:
+            import parser
+        except ImportError:
+            syntax_checker = lambda x: compile(x, 'asd', 'exec')
+        else:
+            syntax_checker = parser.suite
+
+        if deindent:
+            source = str(self.deindent())
+        else:
+            source = str(self)
+        try:
+            #compile(source+'\n', "x", "exec")
+            syntax_checker(source+'\n')
+        except KeyboardInterrupt:
+            raise
+        except Exception:
+            return False
+        else:
+            return True
+
+    def __str__(self):
+        return "\n".join(self.lines)
+
+    def compile(self, filename=None, mode='exec',
+                flag=generators.compiler_flag,
+                dont_inherit=0, _genframe=None):
+        """ return compiled code object. if filename is None
+            invent an artificial filename which displays
+            the source/line position of the caller frame.
+        """
+        if not filename or py.path.local(filename).check(file=0):
+            if _genframe is None:
+                _genframe = sys._getframe(1) # the caller
+            fn,lineno = _genframe.f_code.co_filename, _genframe.f_lineno
+            base = "<%d-codegen " % self._compilecounter
+            self.__class__._compilecounter += 1
+            if not filename:
+                filename = base + '%s:%d>' % (fn, lineno)
+            else:
+                filename = base + '%r %s:%d>' % (filename, fn, lineno)
+        source = "\n".join(self.lines) + '\n'
+        try:
+            co = cpy_compile(source, filename, mode, flag)
+        except SyntaxError:
+            ex = sys.exc_info()[1]
+            # re-represent syntax errors from parsing python strings
+            msglines = self.lines[:ex.lineno]
+            if ex.offset:
+                msglines.append(" "*ex.offset + '^')
+            msglines.append("(code was compiled probably from here: %s)" % filename)
+            newex = SyntaxError('\n'.join(msglines))
+            newex.offset = ex.offset
+            newex.lineno = ex.lineno
+            newex.text = ex.text
+            raise newex
+        else:
+            if flag & _AST_FLAG:
+                return co
+            lines = [(x + "\n") for x in self.lines]
+            import linecache
+            linecache.cache[filename] = (1, None, lines, filename)
+            return co
+
+#
+# public API shortcut functions
+#
+
+def compile_(source, filename=None, mode='exec', flags=
+            generators.compiler_flag, dont_inherit=0):
+    """ compile the given source to a raw code object,
+        and maintain an internal cache which allows later
+        retrieval of the source code for the code object
+        and any recursively created code objects.
+    """
+    if _ast is not None and isinstance(source, _ast.AST):
+        # XXX should Source support having AST?
+        return cpy_compile(source, filename, mode, flags, dont_inherit)
+    _genframe = sys._getframe(1) # the caller
+    s = Source(source)
+    co = s.compile(filename, mode, flags, _genframe=_genframe)
+    return co
+
+
+def getfslineno(obj):
+    """ Return source location (path, lineno) for the given object.
+    If the source cannot be determined return ("", -1)
+    """
+    try:
+        code = py.code.Code(obj)
+    except TypeError:
+        try:
+            fn = (inspect.getsourcefile(obj) or
+                  inspect.getfile(obj))
+        except TypeError:
+            return "", -1
+
+        fspath = fn and py.path.local(fn) or None
+        lineno = -1
+        if fspath:
+            try:
+                _, lineno = findsource(obj)
+            except IOError:
+                pass
+    else:
+        fspath = code.path
+        lineno = code.firstlineno
+    assert isinstance(lineno, int)
+    return fspath, lineno
+
+#
+# helper functions
+#
+
+def findsource(obj):
+    try:
+        sourcelines, lineno = inspect.findsource(obj)
+    except py.builtin._sysex:
+        raise
+    except:
+        return None, -1
+    source = Source()
+    source.lines = [line.rstrip() for line in sourcelines]
+    return source, lineno
+
+def getsource(obj, **kwargs):
+    obj = py.code.getrawcode(obj)
+    try:
+        strsrc = inspect.getsource(obj)
+    except IndentationError:
+        strsrc = "\"Buggy python version consider upgrading, cannot get source\""
+    assert isinstance(strsrc, str)
+    return Source(strsrc, **kwargs)
+
+def deindent(lines, offset=None):
+    if offset is None:
+        for line in lines:
+            line = line.expandtabs()
+            s = line.lstrip()
+            if s:
+                offset = len(line)-len(s)
+                break
+        else:
+            offset = 0
+    if offset == 0:
+        return list(lines)
+    newlines = []
+    def readline_generator(lines):
+        for line in lines:
+            yield line + '\n'
+        while True:
+            yield ''
+
+    it = readline_generator(lines)
+
+    try:
+        for _, _, (sline, _), (eline, _), _ in tokenize.generate_tokens(lambda: next(it)):
+            if sline > len(lines):
+                break # End of input reached
+            if sline > len(newlines):
+                line = lines[sline - 1].expandtabs()
+                if line.lstrip() and line[:offset].isspace():
+                    line = line[offset:] # Deindent
+                newlines.append(line)
+
+            for i in range(sline, eline):
+                # Don't deindent continuing lines of
+                # multiline tokens (i.e. multiline strings)
+                newlines.append(lines[i])
+    except (IndentationError, tokenize.TokenError):
+        pass
+    # Add any lines we didn't see. E.g. if an exception was raised.
+    newlines.extend(lines[len(newlines):])
+    return newlines
+
+
+def get_statement_startend2(lineno, node):
+    import ast
+    # flatten all statements and except handlers into one lineno-list
+    # AST's line numbers start indexing at 1
+    l = []
+    for x in ast.walk(node):
+        if isinstance(x, _ast.stmt) or isinstance(x, _ast.ExceptHandler):
+            l.append(x.lineno - 1)
+            for name in "finalbody", "orelse":
+                val = getattr(x, name, None)
+                if val:
+                    # treat the finally/orelse part as its own statement
+                    l.append(val[0].lineno - 1 - 1)
+    l.sort()
+    insert_index = bisect_right(l, lineno)
+    start = l[insert_index - 1]
+    if insert_index >= len(l):
+        end = None
+    else:
+        end = l[insert_index]
+    return start, end
+
+
+def getstatementrange_ast(lineno, source, assertion=False, astnode=None):
+    if astnode is None:
+        content = str(source)
+        try:
+            astnode = compile(content, "source", "exec", 1024)  # 1024 for AST
+        except ValueError:
+            start, end = getstatementrange_old(lineno, source, assertion)
+            return None, start, end
+    start, end = get_statement_startend2(lineno, astnode)
+    # we need to correct the end:
+    # - ast-parsing strips comments
+    # - there might be empty lines
+    # - we might have lesser indented code blocks at the end
+    if end is None:
+        end = len(source.lines)
+
+    if end > start + 1:
+        # make sure we don't span differently indented code blocks
+        # by using the BlockFinder helper used which inspect.getsource() uses itself
+        block_finder = inspect.BlockFinder()
+        # if we start with an indented line, put blockfinder to "started" mode
+        block_finder.started = source.lines[start][0].isspace()
+        it = ((x + "\n") for x in source.lines[start:end])
+        try:
+            for tok in tokenize.generate_tokens(lambda: next(it)):
+                block_finder.tokeneater(*tok)
+        except (inspect.EndOfBlock, IndentationError):
+            end = block_finder.last + start
+        except Exception:
+            pass
+
+    # the end might still point to a comment or empty line, correct it
+    while end:
+        line = source.lines[end - 1].lstrip()
+        if line.startswith("#") or not line:
+            end -= 1
+        else:
+            break
+    return astnode, start, end
+
+
+def getstatementrange_old(lineno, source, assertion=False):
+    """ return (start, end) tuple which spans the minimal
+        statement region which containing the given lineno.
+        raise an IndexError if no such statementrange can be found.
+    """
+    # XXX this logic is only used on python2.4 and below
+    # 1. find the start of the statement
+    from codeop import compile_command
+    for start in range(lineno, -1, -1):
+        if assertion:
+            line = source.lines[start]
+            # the following lines are not fully tested, change with care
+            if 'super' in line and 'self' in line and '__init__' in line:
+                raise IndexError("likely a subclass")
+            if "assert" not in line and "raise" not in line:
+                continue
+        trylines = source.lines[start:lineno+1]
+        # quick hack to prepare parsing an indented line with
+        # compile_command() (which errors on "return" outside defs)
+        trylines.insert(0, 'def xxx():')
+        trysource = '\n '.join(trylines)
+        #              ^ space here
+        try:
+            compile_command(trysource)
+        except (SyntaxError, OverflowError, ValueError):
+            continue
+
+        # 2. find the end of the statement
+        for end in range(lineno+1, len(source)+1):
+            trysource = source[start:end]
+            if trysource.isparseable():
+                return start, end
+    raise SyntaxError("no valid source range around line %d " % (lineno,))
+
+

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_io/__init__.py

@@ -0,0 +1 @@
+""" input/output helping """

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_io/capture.py

@@ -0,0 +1,371 @@
+import os
+import sys
+import py
+import tempfile
+
+try:
+    from io import StringIO
+except ImportError:
+    from StringIO import StringIO
+
+if sys.version_info < (3,0):
+    class TextIO(StringIO):
+        def write(self, data):
+            if not isinstance(data, unicode):
+                data = unicode(data, getattr(self, '_encoding', 'UTF-8'), 'replace')
+            StringIO.write(self, data)
+else:
+    TextIO = StringIO
+
+try:
+    from io import BytesIO
+except ImportError:
+    class BytesIO(StringIO):
+        def write(self, data):
+            if isinstance(data, unicode):
+                raise TypeError("not a byte value: %r" %(data,))
+            StringIO.write(self, data)
+
+patchsysdict = {0: 'stdin', 1: 'stdout', 2: 'stderr'}
+
+class FDCapture:
+    """ Capture IO to/from a given os-level filedescriptor. """
+
+    def __init__(self, targetfd, tmpfile=None, now=True, patchsys=False):
+        """ save targetfd descriptor, and open a new
+            temporary file there.  If no tmpfile is
+            specified a tempfile.Tempfile() will be opened
+            in text mode.
+        """
+        self.targetfd = targetfd
+        if tmpfile is None and targetfd != 0:
+            f = tempfile.TemporaryFile('wb+')
+            tmpfile = dupfile(f, encoding="UTF-8")
+            f.close()
+        self.tmpfile = tmpfile
+        self._savefd = os.dup(self.targetfd)
+        if patchsys:
+            self._oldsys = getattr(sys, patchsysdict[targetfd])
+        if now:
+            self.start()
+
+    def start(self):
+        try:
+            os.fstat(self._savefd)
+        except OSError:
+            raise ValueError("saved filedescriptor not valid, "
+                "did you call start() twice?")
+        if self.targetfd == 0 and not self.tmpfile:
+            fd = os.open(devnullpath, os.O_RDONLY)
+            os.dup2(fd, 0)
+            os.close(fd)
+            if hasattr(self, '_oldsys'):
+                setattr(sys, patchsysdict[self.targetfd], DontReadFromInput())
+        else:
+            os.dup2(self.tmpfile.fileno(), self.targetfd)
+            if hasattr(self, '_oldsys'):
+                setattr(sys, patchsysdict[self.targetfd], self.tmpfile)
+
+    def done(self):
+        """ unpatch and clean up, returns the self.tmpfile (file object)
+        """
+        os.dup2(self._savefd, self.targetfd)
+        os.close(self._savefd)
+        if self.targetfd != 0:
+            self.tmpfile.seek(0)
+        if hasattr(self, '_oldsys'):
+            setattr(sys, patchsysdict[self.targetfd], self._oldsys)
+        return self.tmpfile
+
+    def writeorg(self, data):
+        """ write a string to the original file descriptor
+        """
+        tempfp = tempfile.TemporaryFile()
+        try:
+            os.dup2(self._savefd, tempfp.fileno())
+            tempfp.write(data)
+        finally:
+            tempfp.close()
+
+
+def dupfile(f, mode=None, buffering=0, raising=False, encoding=None):
+    """ return a new open file object that's a duplicate of f
+
+        mode is duplicated if not given, 'buffering' controls
+        buffer size (defaulting to no buffering) and 'raising'
+        defines whether an exception is raised when an incompatible
+        file object is passed in (if raising is False, the file
+        object itself will be returned)
+    """
+    try:
+        fd = f.fileno()
+        mode = mode or f.mode
+    except AttributeError:
+        if raising:
+            raise
+        return f
+    newfd = os.dup(fd)
+    if sys.version_info >= (3,0):
+        if encoding is not None:
+            mode = mode.replace("b", "")
+            buffering = True
+        return os.fdopen(newfd, mode, buffering, encoding, closefd=True)
+    else:
+        f = os.fdopen(newfd, mode, buffering)
+        if encoding is not None:
+            return EncodedFile(f, encoding)
+        return f
+
+class EncodedFile(object):
+    def __init__(self, _stream, encoding):
+        self._stream = _stream
+        self.encoding = encoding
+
+    def write(self, obj):
+        if isinstance(obj, unicode):
+            obj = obj.encode(self.encoding)
+        elif isinstance(obj, str):
+            pass
+        else:
+            obj = str(obj)
+        self._stream.write(obj)
+
+    def writelines(self, linelist):
+        data = ''.join(linelist)
+        self.write(data)
+
+    def __getattr__(self, name):
+        return getattr(self._stream, name)
+
+class Capture(object):
+    def call(cls, func, *args, **kwargs):
+        """ return a (res, out, err) tuple where
+            out and err represent the output/error output
+            during function execution.
+            call the given function with args/kwargs
+            and capture output/error during its execution.
+        """
+        so = cls()
+        try:
+            res = func(*args, **kwargs)
+        finally:
+            out, err = so.reset()
+        return res, out, err
+    call = classmethod(call)
+
+    def reset(self):
+        """ reset sys.stdout/stderr and return captured output as strings. """
+        if hasattr(self, '_reset'):
+            raise ValueError("was already reset")
+        self._reset = True
+        outfile, errfile = self.done(save=False)
+        out, err = "", ""
+        if outfile and not outfile.closed:
+            out = outfile.read()
+            outfile.close()
+        if errfile and errfile != outfile and not errfile.closed:
+            err = errfile.read()
+            errfile.close()
+        return out, err
+
+    def suspend(self):
+        """ return current snapshot captures, memorize tempfiles. """
+        outerr = self.readouterr()
+        outfile, errfile = self.done()
+        return outerr
+
+
+class StdCaptureFD(Capture):
+    """ This class allows to capture writes to FD1 and FD2
+        and may connect a NULL file to FD0 (and prevent
+        reads from sys.stdin).  If any of the 0,1,2 file descriptors
+        is invalid it will not be captured.
+    """
+    def __init__(self, out=True, err=True, mixed=False,
+        in_=True, patchsys=True, now=True):
+        self._options = {
+            "out": out,
+            "err": err,
+            "mixed": mixed,
+            "in_": in_,
+            "patchsys": patchsys,
+            "now": now,
+        }
+        self._save()
+        if now:
+            self.startall()
+
+    def _save(self):
+        in_ = self._options['in_']
+        out = self._options['out']
+        err = self._options['err']
+        mixed = self._options['mixed']
+        patchsys = self._options['patchsys']
+        if in_:
+            try:
+                self.in_ = FDCapture(0, tmpfile=None, now=False,
+                    patchsys=patchsys)
+            except OSError:
+                pass
+        if out:
+            tmpfile = None
+            if hasattr(out, 'write'):
+                tmpfile = out
+            try:
+                self.out = FDCapture(1, tmpfile=tmpfile,
+                           now=False, patchsys=patchsys)
+                self._options['out'] = self.out.tmpfile
+            except OSError:
+                pass
+        if err:
+            if out and mixed:
+                tmpfile = self.out.tmpfile
+            elif hasattr(err, 'write'):
+                tmpfile = err
+            else:
+                tmpfile = None
+            try:
+                self.err = FDCapture(2, tmpfile=tmpfile,
+                           now=False, patchsys=patchsys)
+                self._options['err'] = self.err.tmpfile
+            except OSError:
+                pass
+
+    def startall(self):
+        if hasattr(self, 'in_'):
+            self.in_.start()
+        if hasattr(self, 'out'):
+            self.out.start()
+        if hasattr(self, 'err'):
+            self.err.start()
+
+    def resume(self):
+        """ resume capturing with original temp files. """
+        self.startall()
+
+    def done(self, save=True):
+        """ return (outfile, errfile) and stop capturing. """
+        outfile = errfile = None
+        if hasattr(self, 'out') and not self.out.tmpfile.closed:
+            outfile = self.out.done()
+        if hasattr(self, 'err') and not self.err.tmpfile.closed:
+            errfile = self.err.done()
+        if hasattr(self, 'in_'):
+            tmpfile = self.in_.done()
+        if save:
+            self._save()
+        return outfile, errfile
+
+    def readouterr(self):
+        """ return snapshot value of stdout/stderr capturings. """
+        if hasattr(self, "out"):
+            out = self._readsnapshot(self.out.tmpfile)
+        else:
+            out = ""
+        if hasattr(self, "err"):
+            err = self._readsnapshot(self.err.tmpfile)
+        else:
+            err = ""
+        return [out, err]
+
+    def _readsnapshot(self, f):
+        f.seek(0)
+        res = f.read()
+        enc = getattr(f, "encoding", None)
+        if enc:
+            res = py.builtin._totext(res, enc, "replace")
+        f.truncate(0)
+        f.seek(0)
+        return res
+
+
+class StdCapture(Capture):
+    """ This class allows to capture writes to sys.stdout|stderr "in-memory"
+        and will raise errors on tries to read from sys.stdin. It only
+        modifies sys.stdout|stderr|stdin attributes and does not
+        touch underlying File Descriptors (use StdCaptureFD for that).
+    """
+    def __init__(self, out=True, err=True, in_=True, mixed=False, now=True):
+        self._oldout = sys.stdout
+        self._olderr = sys.stderr
+        self._oldin  = sys.stdin
+        if out and not hasattr(out, 'file'):
+            out = TextIO()
+        self.out = out
+        if err:
+            if mixed:
+                err = out
+            elif not hasattr(err, 'write'):
+                err = TextIO()
+        self.err = err
+        self.in_ = in_
+        if now:
+            self.startall()
+
+    def startall(self):
+        if self.out:
+            sys.stdout = self.out
+        if self.err:
+            sys.stderr = self.err
+        if self.in_:
+            sys.stdin  = self.in_  = DontReadFromInput()
+
+    def done(self, save=True):
+        """ return (outfile, errfile) and stop capturing. """
+        outfile = errfile = None
+        if self.out and not self.out.closed:
+            sys.stdout = self._oldout
+            outfile = self.out
+            outfile.seek(0)
+        if self.err and not self.err.closed:
+            sys.stderr = self._olderr
+            errfile = self.err
+            errfile.seek(0)
+        if self.in_:
+            sys.stdin = self._oldin
+        return outfile, errfile
+
+    def resume(self):
+        """ resume capturing with original temp files. """
+        self.startall()
+
+    def readouterr(self):
+        """ return snapshot value of stdout/stderr capturings. """
+        out = err = ""
+        if self.out:
+            out = self.out.getvalue()
+            self.out.truncate(0)
+            self.out.seek(0)
+        if self.err:
+            err = self.err.getvalue()
+            self.err.truncate(0)
+            self.err.seek(0)
+        return out, err
+
+class DontReadFromInput:
+    """Temporary stub class.  Ideally when stdin is accessed, the
+    capturing should be turned off, with possibly all data captured
+    so far sent to the screen.  This should be configurable, though,
+    because in automated test runs it is better to crash than
+    hang indefinitely.
+    """
+    def read(self, *args):
+        raise IOError("reading from stdin while output is captured")
+    readline = read
+    readlines = read
+    __iter__ = read
+
+    def fileno(self):
+        raise ValueError("redirected Stdin is pseudofile, has no fileno()")
+    def isatty(self):
+        return False
+    def close(self):
+        pass
+
+try:
+    devnullpath = os.devnull
+except AttributeError:
+    if os.name == 'nt':
+        devnullpath = 'NUL'
+    else:
+        devnullpath = '/dev/null'

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_io/saferepr.py

@@ -0,0 +1,71 @@
+import py
+import sys
+
+builtin_repr = repr
+
+reprlib = py.builtin._tryimport('repr', 'reprlib')
+
+class SafeRepr(reprlib.Repr):
+    """ subclass of repr.Repr that limits the resulting size of repr()
+        and includes information on exceptions raised during the call.
+    """
+    def repr(self, x):
+        return self._callhelper(reprlib.Repr.repr, self, x)
+
+    def repr_unicode(self, x, level):
+        # Strictly speaking wrong on narrow builds
+        def repr(u):
+            if "'" not in u:
+                return py.builtin._totext("'%s'") % u
+            elif '"' not in u:
+                return py.builtin._totext('"%s"') % u
+            else:
+                return py.builtin._totext("'%s'") % u.replace("'", r"\'")
+        s = repr(x[:self.maxstring])
+        if len(s) > self.maxstring:
+            i = max(0, (self.maxstring-3)//2)
+            j = max(0, self.maxstring-3-i)
+            s = repr(x[:i] + x[len(x)-j:])
+            s = s[:i] + '...' + s[len(s)-j:]
+        return s
+
+    def repr_instance(self, x, level):
+        return self._callhelper(builtin_repr, x)
+
+    def _callhelper(self, call, x, *args):
+        try:
+            # Try the vanilla repr and make sure that the result is a string
+            s = call(x, *args)
+        except py.builtin._sysex:
+            raise
+        except:
+            cls, e, tb = sys.exc_info()
+            exc_name = getattr(cls, '__name__', 'unknown')
+            try:
+                exc_info = str(e)
+            except py.builtin._sysex:
+                raise
+            except:
+                exc_info = 'unknown'
+            return '<[%s("%s") raised in repr()] %s object at 0x%x>' % (
+                exc_name, exc_info, x.__class__.__name__, id(x))
+        else:
+            if len(s) > self.maxsize:
+                i = max(0, (self.maxsize-3)//2)
+                j = max(0, self.maxsize-3-i)
+                s = s[:i] + '...' + s[len(s)-j:]
+            return s
+
+def saferepr(obj, maxsize=240):
+    """ return a size-limited safe repr-string for the given object.
+    Failing __repr__ functions of user instances will be represented
+    with a short exception info and 'saferepr' generally takes
+    care to never raise exceptions itself.  This function is a wrapper
+    around the Repr/reprlib functionality of the standard 2.6 lib.
+    """
+    # review exception handling
+    srepr = SafeRepr()
+    srepr.maxstring = maxsize
+    srepr.maxsize = maxsize
+    srepr.maxother = 160
+    return srepr.repr(obj)

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_io/terminalwriter.py

@@ -0,0 +1,421 @@
+"""
+
+Helper functions for writing to terminals and files.
+
+"""
+
+
+import sys, os, unicodedata
+import py
+py3k = sys.version_info[0] >= 3
+py33 = sys.version_info >= (3, 3)
+from py.builtin import text, bytes
+
+win32_and_ctypes = False
+colorama = None
+if sys.platform == "win32":
+    try:
+        import colorama
+    except ImportError:
+        try:
+            import ctypes
+            win32_and_ctypes = True
+        except ImportError:
+            pass
+
+
+def _getdimensions():
+    if py33:
+        import shutil
+        size = shutil.get_terminal_size()
+        return size.lines, size.columns
+    else:
+        import termios, fcntl, struct
+        call = fcntl.ioctl(1, termios.TIOCGWINSZ, "\000" * 8)
+        height, width = struct.unpack("hhhh", call)[:2]
+        return height, width
+
+
+def get_terminal_width():
+    width = 0
+    try:
+        _, width = _getdimensions()
+    except py.builtin._sysex:
+        raise
+    except:
+        # pass to fallback below
+        pass
+
+    if width == 0:
+        # FALLBACK:
+        # * some exception happened
+        # * or this is emacs terminal which reports (0,0)
+        width = int(os.environ.get('COLUMNS', 80))
+
+    # XXX the windows getdimensions may be bogus, let's sanify a bit
+    if width < 40:
+        width = 80
+    return width
+
+terminal_width = get_terminal_width()
+
+char_width = {
+    'A': 1,   # "Ambiguous"
+    'F': 2,   # Fullwidth
+    'H': 1,   # Halfwidth
+    'N': 1,   # Neutral
+    'Na': 1,  # Narrow
+    'W': 2,   # Wide
+}
+
+
+def get_line_width(text):
+    text = unicodedata.normalize('NFC', text)
+    return sum(char_width.get(unicodedata.east_asian_width(c), 1) for c in text)
+
+
+# XXX unify with _escaped func below
+def ansi_print(text, esc, file=None, newline=True, flush=False):
+    if file is None:
+        file = sys.stderr
+    text = text.rstrip()
+    if esc and not isinstance(esc, tuple):
+        esc = (esc,)
+    if esc and sys.platform != "win32" and file.isatty():
+        text = (''.join(['\x1b[%sm' % cod for cod in esc])  +
+                text +
+                '\x1b[0m')     # ANSI color code "reset"
+    if newline:
+        text += '\n'
+
+    if esc and win32_and_ctypes and file.isatty():
+        if 1 in esc:
+            bold = True
+            esc = tuple([x for x in esc if x != 1])
+        else:
+            bold = False
+        esctable = {()   : FOREGROUND_WHITE,                 # normal
+                    (31,): FOREGROUND_RED,                   # red
+                    (32,): FOREGROUND_GREEN,                 # green
+                    (33,): FOREGROUND_GREEN|FOREGROUND_RED,  # yellow
+                    (34,): FOREGROUND_BLUE,                  # blue
+                    (35,): FOREGROUND_BLUE|FOREGROUND_RED,   # purple
+                    (36,): FOREGROUND_BLUE|FOREGROUND_GREEN, # cyan
+                    (37,): FOREGROUND_WHITE,                 # white
+                    (39,): FOREGROUND_WHITE,                 # reset
+                    }
+        attr = esctable.get(esc, FOREGROUND_WHITE)
+        if bold:
+            attr |= FOREGROUND_INTENSITY
+        STD_OUTPUT_HANDLE = -11
+        STD_ERROR_HANDLE = -12
+        if file is sys.stderr:
+            handle = GetStdHandle(STD_ERROR_HANDLE)
+        else:
+            handle = GetStdHandle(STD_OUTPUT_HANDLE)
+        oldcolors = GetConsoleInfo(handle).wAttributes
+        attr |= (oldcolors & 0x0f0)
+        SetConsoleTextAttribute(handle, attr)
+        while len(text) > 32768:
+            file.write(text[:32768])
+            text = text[32768:]
+        if text:
+            file.write(text)
+        SetConsoleTextAttribute(handle, oldcolors)
+    else:
+        file.write(text)
+
+    if flush:
+        file.flush()
+
+def should_do_markup(file):
+    if os.environ.get('PY_COLORS') == '1':
+        return True
+    if os.environ.get('PY_COLORS') == '0':
+        return False
+    return hasattr(file, 'isatty') and file.isatty() \
+           and os.environ.get('TERM') != 'dumb' \
+           and not (sys.platform.startswith('java') and os._name == 'nt')
+
+class TerminalWriter(object):
+    _esctable = dict(black=30, red=31, green=32, yellow=33,
+                     blue=34, purple=35, cyan=36, white=37,
+                     Black=40, Red=41, Green=42, Yellow=43,
+                     Blue=44, Purple=45, Cyan=46, White=47,
+                     bold=1, light=2, blink=5, invert=7)
+
+    # XXX deprecate stringio argument
+    def __init__(self, file=None, stringio=False, encoding=None):
+        if file is None:
+            if stringio:
+                self.stringio = file = py.io.TextIO()
+            else:
+                from sys import stdout as file
+        elif py.builtin.callable(file) and not (
+             hasattr(file, "write") and hasattr(file, "flush")):
+            file = WriteFile(file, encoding=encoding)
+        if hasattr(file, "isatty") and file.isatty() and colorama:
+            file = colorama.AnsiToWin32(file).stream
+        self.encoding = encoding or getattr(file, 'encoding', "utf-8")
+        self._file = file
+        self.hasmarkup = should_do_markup(file)
+        self._lastlen = 0
+        self._chars_on_current_line = 0
+        self._width_of_current_line = 0
+
+    @property
+    def fullwidth(self):
+        if hasattr(self, '_terminal_width'):
+            return self._terminal_width
+        return get_terminal_width()
+
+    @fullwidth.setter
+    def fullwidth(self, value):
+        self._terminal_width = value
+
+    @property
+    def chars_on_current_line(self):
+        """Return the number of characters written so far in the current line.
+
+        Please note that this count does not produce correct results after a reline() call,
+        see #164.
+
+        .. versionadded:: 1.5.0
+
+        :rtype: int
+        """
+        return self._chars_on_current_line
+
+    @property
+    def width_of_current_line(self):
+        """Return an estimate of the width so far in the current line.
+
+        .. versionadded:: 1.6.0
+
+        :rtype: int
+        """
+        return self._width_of_current_line
+
+    def _escaped(self, text, esc):
+        if esc and self.hasmarkup:
+            text = (''.join(['\x1b[%sm' % cod for cod in esc])  +
+                text +'\x1b[0m')
+        return text
+
+    def markup(self, text, **kw):
+        esc = []
+        for name in kw:
+            if name not in self._esctable:
+                raise ValueError("unknown markup: %r" %(name,))
+            if kw[name]:
+                esc.append(self._esctable[name])
+        return self._escaped(text, tuple(esc))
+
+    def sep(self, sepchar, title=None, fullwidth=None, **kw):
+        if fullwidth is None:
+            fullwidth = self.fullwidth
+        # the goal is to have the line be as long as possible
+        # under the condition that len(line) <= fullwidth
+        if sys.platform == "win32":
+            # if we print in the last column on windows we are on a
+            # new line but there is no way to verify/neutralize this
+            # (we may not know the exact line width)
+            # so let's be defensive to avoid empty lines in the output
+            fullwidth -= 1
+        if title is not None:
+            # we want 2 + 2*len(fill) + len(title) <= fullwidth
+            # i.e.    2 + 2*len(sepchar)*N + len(title) <= fullwidth
+            #         2*len(sepchar)*N <= fullwidth - len(title) - 2
+            #         N <= (fullwidth - len(title) - 2) // (2*len(sepchar))
+            N = max((fullwidth - len(title) - 2) // (2*len(sepchar)), 1)
+            fill = sepchar * N
+            line = "%s %s %s" % (fill, title, fill)
+        else:
+            # we want len(sepchar)*N <= fullwidth
+            # i.e.    N <= fullwidth // len(sepchar)
+            line = sepchar * (fullwidth // len(sepchar))
+        # in some situations there is room for an extra sepchar at the right,
+        # in particular if we consider that with a sepchar like "_ " the
+        # trailing space is not important at the end of the line
+        if len(line) + len(sepchar.rstrip()) <= fullwidth:
+            line += sepchar.rstrip()
+
+        self.line(line, **kw)
+
+    def write(self, msg, **kw):
+        if msg:
+            if not isinstance(msg, (bytes, text)):
+                msg = text(msg)
+
+            self._update_chars_on_current_line(msg)
+
+            if self.hasmarkup and kw:
+                markupmsg = self.markup(msg, **kw)
+            else:
+                markupmsg = msg
+            write_out(self._file, markupmsg)
+
+    def _update_chars_on_current_line(self, text_or_bytes):
+        newline = b'\n' if isinstance(text_or_bytes, bytes) else '\n'
+        current_line = text_or_bytes.rsplit(newline, 1)[-1]
+        if isinstance(current_line, bytes):
+            current_line = current_line.decode('utf-8', errors='replace')
+        if newline in text_or_bytes:
+            self._chars_on_current_line = len(current_line)
+            self._width_of_current_line = get_line_width(current_line)
+        else:
+            self._chars_on_current_line += len(current_line)
+            self._width_of_current_line += get_line_width(current_line)
+
+    def line(self, s='', **kw):
+        self.write(s, **kw)
+        self._checkfill(s)
+        self.write('\n')
+
+    def reline(self, line, **kw):
+        if not self.hasmarkup:
+            raise ValueError("cannot use rewrite-line without terminal")
+        self.write(line, **kw)
+        self._checkfill(line)
+        self.write('\r')
+        self._lastlen = len(line)
+
+    def _checkfill(self, line):
+        diff2last = self._lastlen - len(line)
+        if diff2last > 0:
+            self.write(" " * diff2last)
+
+class Win32ConsoleWriter(TerminalWriter):
+    def write(self, msg, **kw):
+        if msg:
+            if not isinstance(msg, (bytes, text)):
+                msg = text(msg)
+
+            self._update_chars_on_current_line(msg)
+
+            oldcolors = None
+            if self.hasmarkup and kw:
+                handle = GetStdHandle(STD_OUTPUT_HANDLE)
+                oldcolors = GetConsoleInfo(handle).wAttributes
+                default_bg = oldcolors & 0x00F0
+                attr = default_bg
+                if kw.pop('bold', False):
+                    attr |= FOREGROUND_INTENSITY
+
+                if kw.pop('red', False):
+                    attr |= FOREGROUND_RED
+                elif kw.pop('blue', False):
+                    attr |= FOREGROUND_BLUE
+                elif kw.pop('green', False):
+                    attr |= FOREGROUND_GREEN
+                elif kw.pop('yellow', False):
+                    attr |= FOREGROUND_GREEN|FOREGROUND_RED
+                else:
+                    attr |= oldcolors & 0x0007
+
+                SetConsoleTextAttribute(handle, attr)
+            write_out(self._file, msg)
+            if oldcolors:
+                SetConsoleTextAttribute(handle, oldcolors)
+
+class WriteFile(object):
+    def __init__(self, writemethod, encoding=None):
+        self.encoding = encoding
+        self._writemethod = writemethod
+
+    def write(self, data):
+        if self.encoding:
+            data = data.encode(self.encoding, "replace")
+        self._writemethod(data)
+
+    def flush(self):
+        return
+
+
+if win32_and_ctypes:
+    TerminalWriter = Win32ConsoleWriter
+    import ctypes
+    from ctypes import wintypes
+
+    # ctypes access to the Windows console
+    STD_OUTPUT_HANDLE = -11
+    STD_ERROR_HANDLE  = -12
+    FOREGROUND_BLACK     = 0x0000 # black text
+    FOREGROUND_BLUE      = 0x0001 # text color contains blue.
+    FOREGROUND_GREEN     = 0x0002 # text color contains green.
+    FOREGROUND_RED       = 0x0004 # text color contains red.
+    FOREGROUND_WHITE     = 0x0007
+    FOREGROUND_INTENSITY = 0x0008 # text color is intensified.
+    BACKGROUND_BLACK     = 0x0000 # background color black
+    BACKGROUND_BLUE      = 0x0010 # background color contains blue.
+    BACKGROUND_GREEN     = 0x0020 # background color contains green.
+    BACKGROUND_RED       = 0x0040 # background color contains red.
+    BACKGROUND_WHITE     = 0x0070
+    BACKGROUND_INTENSITY = 0x0080 # background color is intensified.
+
+    SHORT = ctypes.c_short
+    class COORD(ctypes.Structure):
+        _fields_ = [('X', SHORT),
+                    ('Y', SHORT)]
+    class SMALL_RECT(ctypes.Structure):
+        _fields_ = [('Left', SHORT),
+                    ('Top', SHORT),
+                    ('Right', SHORT),
+                    ('Bottom', SHORT)]
+    class CONSOLE_SCREEN_BUFFER_INFO(ctypes.Structure):
+        _fields_ = [('dwSize', COORD),
+                    ('dwCursorPosition', COORD),
+                    ('wAttributes', wintypes.WORD),
+                    ('srWindow', SMALL_RECT),
+                    ('dwMaximumWindowSize', COORD)]
+
+    _GetStdHandle = ctypes.windll.kernel32.GetStdHandle
+    _GetStdHandle.argtypes = [wintypes.DWORD]
+    _GetStdHandle.restype = wintypes.HANDLE
+    def GetStdHandle(kind):
+        return _GetStdHandle(kind)
+
+    SetConsoleTextAttribute = ctypes.windll.kernel32.SetConsoleTextAttribute
+    SetConsoleTextAttribute.argtypes = [wintypes.HANDLE, wintypes.WORD]
+    SetConsoleTextAttribute.restype = wintypes.BOOL
+
+    _GetConsoleScreenBufferInfo = \
+        ctypes.windll.kernel32.GetConsoleScreenBufferInfo
+    _GetConsoleScreenBufferInfo.argtypes = [wintypes.HANDLE,
+                                ctypes.POINTER(CONSOLE_SCREEN_BUFFER_INFO)]
+    _GetConsoleScreenBufferInfo.restype = wintypes.BOOL
+    def GetConsoleInfo(handle):
+        info = CONSOLE_SCREEN_BUFFER_INFO()
+        _GetConsoleScreenBufferInfo(handle, ctypes.byref(info))
+        return info
+
+    def _getdimensions():
+        handle = GetStdHandle(STD_OUTPUT_HANDLE)
+        info = GetConsoleInfo(handle)
+        # Substract one from the width, otherwise the cursor wraps
+        # and the ending \n causes an empty line to display.
+        return info.dwSize.Y, info.dwSize.X - 1
+
+def write_out(fil, msg):
+    # XXX sometimes "msg" is of type bytes, sometimes text which
+    # complicates the situation.  Should we try to enforce unicode?
+    try:
+        # on py27 and above writing out to sys.stdout with an encoding
+        # should usually work for unicode messages (if the encoding is
+        # capable of it)
+        fil.write(msg)
+    except UnicodeEncodeError:
+        # on py26 it might not work because stdout expects bytes
+        if fil.encoding:
+            try:
+                fil.write(msg.encode(fil.encoding))
+            except UnicodeEncodeError:
+                # it might still fail if the encoding is not capable
+                pass
+            else:
+                fil.flush()
+                return
+        # fallback: escape all unicode characters
+        msg = msg.encode("unicode-escape").decode("ascii")
+        fil.write(msg)
+    fil.flush()

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_log/__init__.py

@@ -0,0 +1,2 @@
+""" logging API ('producers' and 'consumers' connected via keywords) """
+

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_log/log.py

@@ -0,0 +1,206 @@
+"""
+basic logging functionality based on a producer/consumer scheme.
+
+XXX implement this API: (maybe put it into slogger.py?)
+
+        log = Logger(
+                    info=py.log.STDOUT,
+                    debug=py.log.STDOUT,
+                    command=None)
+        log.info("hello", "world")
+        log.command("hello", "world")
+
+        log = Logger(info=Logger(something=...),
+                     debug=py.log.STDOUT,
+                     command=None)
+"""
+import py
+import sys
+
+
+class Message(object):
+    def __init__(self, keywords, args):
+        self.keywords = keywords
+        self.args = args
+
+    def content(self):
+        return " ".join(map(str, self.args))
+
+    def prefix(self):
+        return "[%s] " % (":".join(self.keywords))
+
+    def __str__(self):
+        return self.prefix() + self.content()
+
+
+class Producer(object):
+    """ (deprecated) Log producer API which sends messages to be logged
+        to a 'consumer' object, which then prints them to stdout,
+        stderr, files, etc. Used extensively by PyPy-1.1.
+    """
+
+    Message = Message  # to allow later customization
+    keywords2consumer = {}
+
+    def __init__(self, keywords, keywordmapper=None, **kw):
+        if hasattr(keywords, 'split'):
+            keywords = tuple(keywords.split())
+        self._keywords = keywords
+        if keywordmapper is None:
+            keywordmapper = default_keywordmapper
+        self._keywordmapper = keywordmapper
+
+    def __repr__(self):
+        return "<py.log.Producer %s>" % ":".join(self._keywords)
+
+    def __getattr__(self, name):
+        if '_' in name:
+            raise AttributeError(name)
+        producer = self.__class__(self._keywords + (name,))
+        setattr(self, name, producer)
+        return producer
+
+    def __call__(self, *args):
+        """ write a message to the appropriate consumer(s) """
+        func = self._keywordmapper.getconsumer(self._keywords)
+        if func is not None:
+            func(self.Message(self._keywords, args))
+
+class KeywordMapper:
+    def __init__(self):
+        self.keywords2consumer = {}
+
+    def getstate(self):
+        return self.keywords2consumer.copy()
+
+    def setstate(self, state):
+        self.keywords2consumer.clear()
+        self.keywords2consumer.update(state)
+
+    def getconsumer(self, keywords):
+        """ return a consumer matching the given keywords.
+
+            tries to find the most suitable consumer by walking, starting from
+            the back, the list of keywords, the first consumer matching a
+            keyword is returned (falling back to py.log.default)
+        """
+        for i in range(len(keywords), 0, -1):
+            try:
+                return self.keywords2consumer[keywords[:i]]
+            except KeyError:
+                continue
+        return self.keywords2consumer.get('default', default_consumer)
+
+    def setconsumer(self, keywords, consumer):
+        """ set a consumer for a set of keywords. """
+        # normalize to tuples
+        if isinstance(keywords, str):
+            keywords = tuple(filter(None, keywords.split()))
+        elif hasattr(keywords, '_keywords'):
+            keywords = keywords._keywords
+        elif not isinstance(keywords, tuple):
+            raise TypeError("key %r is not a string or tuple" % (keywords,))
+        if consumer is not None and not py.builtin.callable(consumer):
+            if not hasattr(consumer, 'write'):
+                raise TypeError(
+                    "%r should be None, callable or file-like" % (consumer,))
+            consumer = File(consumer)
+        self.keywords2consumer[keywords] = consumer
+
+
+def default_consumer(msg):
+    """ the default consumer, prints the message to stdout (using 'print') """
+    sys.stderr.write(str(msg)+"\n")
+
+default_keywordmapper = KeywordMapper()
+
+
+def setconsumer(keywords, consumer):
+    default_keywordmapper.setconsumer(keywords, consumer)
+
+
+def setstate(state):
+    default_keywordmapper.setstate(state)
+
+
+def getstate():
+    return default_keywordmapper.getstate()
+
+#
+# Consumers
+#
+
+
+class File(object):
+    """ log consumer wrapping a file(-like) object """
+    def __init__(self, f):
+        assert hasattr(f, 'write')
+        # assert isinstance(f, file) or not hasattr(f, 'open')
+        self._file = f
+
+    def __call__(self, msg):
+        """ write a message to the log """
+        self._file.write(str(msg) + "\n")
+        if hasattr(self._file, 'flush'):
+            self._file.flush()
+
+
+class Path(object):
+    """ log consumer that opens and writes to a Path """
+    def __init__(self, filename, append=False,
+                 delayed_create=False, buffering=False):
+        self._append = append
+        self._filename = str(filename)
+        self._buffering = buffering
+        if not delayed_create:
+            self._openfile()
+
+    def _openfile(self):
+        mode = self._append and 'a' or 'w'
+        f = open(self._filename, mode)
+        self._file = f
+
+    def __call__(self, msg):
+        """ write a message to the log """
+        if not hasattr(self, "_file"):
+            self._openfile()
+        self._file.write(str(msg) + "\n")
+        if not self._buffering:
+            self._file.flush()
+
+
+def STDOUT(msg):
+    """ consumer that writes to sys.stdout """
+    sys.stdout.write(str(msg)+"\n")
+
+
+def STDERR(msg):
+    """ consumer that writes to sys.stderr """
+    sys.stderr.write(str(msg)+"\n")
+
+
+class Syslog:
+    """ consumer that writes to the syslog daemon """
+
+    def __init__(self, priority=None):
+        if priority is None:
+            priority = self.LOG_INFO
+        self.priority = priority
+
+    def __call__(self, msg):
+        """ write a message to the log """
+        import syslog
+        syslog.syslog(self.priority, str(msg))
+
+
+try:
+    import syslog
+except ImportError:
+    pass
+else:
+    for _prio in "EMERG ALERT CRIT ERR WARNING NOTICE INFO DEBUG".split():
+        _prio = "LOG_" + _prio
+        try:
+            setattr(Syslog, _prio, getattr(syslog, _prio))
+        except AttributeError:
+            pass

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_log/warning.py

@@ -0,0 +1,79 @@
+import py, sys
+
+class DeprecationWarning(DeprecationWarning):
+    def __init__(self, msg, path, lineno):
+        self.msg = msg
+        self.path = path
+        self.lineno = lineno
+    def __repr__(self):
+        return "%s:%d: %s" %(self.path, self.lineno+1, self.msg)
+    def __str__(self):
+        return self.msg
+
+def _apiwarn(startversion, msg, stacklevel=2, function=None):
+    # below is mostly COPIED from python2.4/warnings.py's def warn()
+    # Get context information
+    if isinstance(stacklevel, str):
+        frame = sys._getframe(1)
+        level = 1
+        found = frame.f_code.co_filename.find(stacklevel) != -1
+        while frame:
+            co = frame.f_code
+            if co.co_filename.find(stacklevel) == -1:
+                if found:
+                    stacklevel = level
+                    break
+            else:
+                found = True
+            level += 1
+            frame = frame.f_back
+        else:
+            stacklevel = 1
+    msg = "%s (since version %s)" %(msg, startversion)
+    warn(msg, stacklevel=stacklevel+1, function=function)
+
+
+def warn(msg, stacklevel=1, function=None):
+    if function is not None:
+        import inspect
+        filename = inspect.getfile(function)
+        lineno = py.code.getrawcode(function).co_firstlineno
+    else:
+        try:
+            caller = sys._getframe(stacklevel)
+        except ValueError:
+            globals = sys.__dict__
+            lineno = 1
+        else:
+            globals = caller.f_globals
+            lineno = caller.f_lineno
+        if '__name__' in globals:
+            module = globals['__name__']
+        else:
+            module = "<string>"
+        filename = globals.get('__file__')
+    if filename:
+        fnl = filename.lower()
+        if fnl.endswith(".pyc") or fnl.endswith(".pyo"):
+            filename = filename[:-1]
+        elif fnl.endswith("$py.class"):
+            filename = filename.replace('$py.class', '.py')
+    else:
+        if module == "__main__":
+            try:
+                filename = sys.argv[0]
+            except AttributeError:
+                # embedded interpreters don't have sys.argv, see bug #839151
+                filename = '__main__'
+        if not filename:
+            filename = module
+    path = py.path.local(filename)
+    warning = DeprecationWarning(msg, path, lineno)
+    import warnings
+    warnings.warn_explicit(warning, category=Warning,
+        filename=str(warning.path),
+        lineno=warning.lineno,
+        registry=warnings.__dict__.setdefault(
+            "__warningsregistry__", {})
+    )
+

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pycparser/ply/__init__.py

@@ -0,0 +1,5 @@
+# PLY package
+# Author: David Beazley (dave@dabeaz.com)
+
+__version__ = '3.9'
+__all__ = ['lex','yacc']

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pycparser/ply/cpp.py

@@ -0,0 +1,905 @@
+# -----------------------------------------------------------------------------
+# cpp.py
+#
+# Author:  David Beazley (http://www.dabeaz.com)
+# Copyright (C) 2017
+# All rights reserved
+#
+# This module implements an ANSI-C style lexical preprocessor for PLY.
+# -----------------------------------------------------------------------------
+import sys
+
+# Some Python 3 compatibility shims
+if sys.version_info.major < 3:
+    STRING_TYPES = (str, unicode)
+else:
+    STRING_TYPES = str
+    xrange = range
+
+# -----------------------------------------------------------------------------
+# Default preprocessor lexer definitions.   These tokens are enough to get
+# a basic preprocessor working.   Other modules may import these if they want
+# -----------------------------------------------------------------------------
+
+tokens = (
+   'CPP_ID','CPP_INTEGER', 'CPP_FLOAT', 'CPP_STRING', 'CPP_CHAR', 'CPP_WS', 'CPP_COMMENT1', 'CPP_COMMENT2', 'CPP_POUND','CPP_DPOUND'
+)
+
+literals = "+-*/%|&~^<>=!?()[]{}.,;:\\\'\""
+
+# Whitespace
+def t_CPP_WS(t):
+    r'\s+'
+    t.lexer.lineno += t.value.count("\n")
+    return t
+
+t_CPP_POUND = r'\#'
+t_CPP_DPOUND = r'\#\#'
+
+# Identifier
+t_CPP_ID = r'[A-Za-z_][\w_]*'
+
+# Integer literal
+def CPP_INTEGER(t):
+    r'(((((0x)|(0X))[0-9a-fA-F]+)|(\d+))([uU][lL]|[lL][uU]|[uU]|[lL])?)'
+    return t
+
+t_CPP_INTEGER = CPP_INTEGER
+
+# Floating literal
+t_CPP_FLOAT = r'((\d+)(\.\d+)(e(\+|-)?(\d+))? | (\d+)e(\+|-)?(\d+))([lL]|[fF])?'
+
+# String literal
+def t_CPP_STRING(t):
+    r'\"([^\\\n]|(\\(.|\n)))*?\"'
+    t.lexer.lineno += t.value.count("\n")
+    return t
+
+# Character constant 'c' or L'c'
+def t_CPP_CHAR(t):
+    r'(L)?\'([^\\\n]|(\\(.|\n)))*?\''
+    t.lexer.lineno += t.value.count("\n")
+    return t
+
+# Comment
+def t_CPP_COMMENT1(t):
+    r'(/\*(.|\n)*?\*/)'
+    ncr = t.value.count("\n")
+    t.lexer.lineno += ncr
+    # replace with one space or a number of '\n'
+    t.type = 'CPP_WS'; t.value = '\n' * ncr if ncr else ' '
+    return t
+
+# Line comment
+def t_CPP_COMMENT2(t):
+    r'(//.*?(\n|$))'
+    # replace with '/n'
+    t.type = 'CPP_WS'; t.value = '\n'
+    return t
+
+def t_error(t):
+    t.type = t.value[0]
+    t.value = t.value[0]
+    t.lexer.skip(1)
+    return t
+
+import re
+import copy
+import time
+import os.path
+
+# -----------------------------------------------------------------------------
+# trigraph()
+#
+# Given an input string, this function replaces all trigraph sequences.
+# The following mapping is used:
+#
+#     ??=    #
+#     ??/    \
+#     ??'    ^
+#     ??(    [
+#     ??)    ]
+#     ??!    |
+#     ??<    {
+#     ??>    }
+#     ??-    ~
+# -----------------------------------------------------------------------------
+
+_trigraph_pat = re.compile(r'''\?\?[=/\'\(\)\!<>\-]''')
+_trigraph_rep = {
+    '=':'#',
+    '/':'\\',
+    "'":'^',
+    '(':'[',
+    ')':']',
+    '!':'|',
+    '<':'{',
+    '>':'}',
+    '-':'~'
+}
+
+def trigraph(input):
+    return _trigraph_pat.sub(lambda g: _trigraph_rep[g.group()[-1]],input)
+
+# ------------------------------------------------------------------
+# Macro object
+#
+# This object holds information about preprocessor macros
+#
+#    .name      - Macro name (string)
+#    .value     - Macro value (a list of tokens)
+#    .arglist   - List of argument names
+#    .variadic  - Boolean indicating whether or not variadic macro
+#    .vararg    - Name of the variadic parameter
+#
+# When a macro is created, the macro replacement token sequence is
+# pre-scanned and used to create patch lists that are later used
+# during macro expansion
+# ------------------------------------------------------------------
+
+class Macro(object):
+    def __init__(self,name,value,arglist=None,variadic=False):
+        self.name = name
+        self.value = value
+        self.arglist = arglist
+        self.variadic = variadic
+        if variadic:
+            self.vararg = arglist[-1]
+        self.source = None
+
+# ------------------------------------------------------------------
+# Preprocessor object
+#
+# Object representing a preprocessor.  Contains macro definitions,
+# include directories, and other information
+# ------------------------------------------------------------------
+
+class Preprocessor(object):
+    def __init__(self,lexer=None):
+        if lexer is None:
+            lexer = lex.lexer
+        self.lexer = lexer
+        self.macros = { }
+        self.path = []
+        self.temp_path = []
+
+        # Probe the lexer for selected tokens
+        self.lexprobe()
+
+        tm = time.localtime()
+        self.define("__DATE__ \"%s\"" % time.strftime("%b %d %Y",tm))
+        self.define("__TIME__ \"%s\"" % time.strftime("%H:%M:%S",tm))
+        self.parser = None
+
+    # -----------------------------------------------------------------------------
+    # tokenize()
+    #
+    # Utility function. Given a string of text, tokenize into a list of tokens
+    # -----------------------------------------------------------------------------
+
+    def tokenize(self,text):
+        tokens = []
+        self.lexer.input(text)
+        while True:
+            tok = self.lexer.token()
+            if not tok: break
+            tokens.append(tok)
+        return tokens
+
+    # ---------------------------------------------------------------------
+    # error()
+    #
+    # Report a preprocessor error/warning of some kind
+    # ----------------------------------------------------------------------
+
+    def error(self,file,line,msg):
+        print("%s:%d %s" % (file,line,msg))
+
+    # ----------------------------------------------------------------------
+    # lexprobe()
+    #
+    # This method probes the preprocessor lexer object to discover
+    # the token types of symbols that are important to the preprocessor.
+    # If this works right, the preprocessor will simply "work"
+    # with any suitable lexer regardless of how tokens have been named.
+    # ----------------------------------------------------------------------
+
+    def lexprobe(self):
+
+        # Determine the token type for identifiers
+        self.lexer.input("identifier")
+        tok = self.lexer.token()
+        if not tok or tok.value != "identifier":
+            print("Couldn't determine identifier type")
+        else:
+            self.t_ID = tok.type
+
+        # Determine the token type for integers
+        self.lexer.input("12345")
+        tok = self.lexer.token()
+        if not tok or int(tok.value) != 12345:
+            print("Couldn't determine integer type")
+        else:
+            self.t_INTEGER = tok.type
+            self.t_INTEGER_TYPE = type(tok.value)
+
+        # Determine the token type for strings enclosed in double quotes
+        self.lexer.input("\"filename\"")
+        tok = self.lexer.token()
+        if not tok or tok.value != "\"filename\"":
+            print("Couldn't determine string type")
+        else:
+            self.t_STRING = tok.type
+
+        # Determine the token type for whitespace--if any
+        self.lexer.input("  ")
+        tok = self.lexer.token()
+        if not tok or tok.value != "  ":
+            self.t_SPACE = None
+        else:
+            self.t_SPACE = tok.type
+
+        # Determine the token type for newlines
+        self.lexer.input("\n")
+        tok = self.lexer.token()
+        if not tok or tok.value != "\n":
+            self.t_NEWLINE = None
+            print("Couldn't determine token for newlines")
+        else:
+            self.t_NEWLINE = tok.type
+
+        self.t_WS = (self.t_SPACE, self.t_NEWLINE)
+
+        # Check for other characters used by the preprocessor
+        chars = [ '<','>','#','##','\\','(',')',',','.']
+        for c in chars:
+            self.lexer.input(c)
+            tok = self.lexer.token()
+            if not tok or tok.value != c:
+                print("Unable to lex '%s' required for preprocessor" % c)
+
+    # ----------------------------------------------------------------------
+    # add_path()
+    #
+    # Adds a search path to the preprocessor.
+    # ----------------------------------------------------------------------
+
+    def add_path(self,path):
+        self.path.append(path)
+
+    # ----------------------------------------------------------------------
+    # group_lines()
+    #
+    # Given an input string, this function splits it into lines.  Trailing whitespace
+    # is removed.   Any line ending with \ is grouped with the next line.  This
+    # function forms the lowest level of the preprocessor---grouping into text into
+    # a line-by-line format.
+    # ----------------------------------------------------------------------
+
+    def group_lines(self,input):
+        lex = self.lexer.clone()
+        lines = [x.rstrip() for x in input.splitlines()]
+        for i in xrange(len(lines)):
+            j = i+1
+            while lines[i].endswith('\\') and (j < len(lines)):
+                lines[i] = lines[i][:-1]+lines[j]
+                lines[j] = ""
+                j += 1
+
+        input = "\n".join(lines)
+        lex.input(input)
+        lex.lineno = 1
+
+        current_line = []
+        while True:
+            tok = lex.token()
+            if not tok:
+                break
+            current_line.append(tok)
+            if tok.type in self.t_WS and '\n' in tok.value:
+                yield current_line
+                current_line = []
+
+        if current_line:
+            yield current_line
+
+    # ----------------------------------------------------------------------
+    # tokenstrip()
+    #
+    # Remove leading/trailing whitespace tokens from a token list
+    # ----------------------------------------------------------------------
+
+    def tokenstrip(self,tokens):
+        i = 0
+        while i < len(tokens) and tokens[i].type in self.t_WS:
+            i += 1
+        del tokens[:i]
+        i = len(tokens)-1
+        while i >= 0 and tokens[i].type in self.t_WS:
+            i -= 1
+        del tokens[i+1:]
+        return tokens
+
+
+    # ----------------------------------------------------------------------
+    # collect_args()
+    #
+    # Collects comma separated arguments from a list of tokens.   The arguments
+    # must be enclosed in parenthesis.  Returns a tuple (tokencount,args,positions)
+    # where tokencount is the number of tokens consumed, args is a list of arguments,
+    # and positions is a list of integers containing the starting index of each
+    # argument.  Each argument is represented by a list of tokens.
+    #
+    # When collecting arguments, leading and trailing whitespace is removed
+    # from each argument.
+    #
+    # This function properly handles nested parenthesis and commas---these do not
+    # define new arguments.
+    # ----------------------------------------------------------------------
+
+    def collect_args(self,tokenlist):
+        args = []
+        positions = []
+        current_arg = []
+        nesting = 1
+        tokenlen = len(tokenlist)
+
+        # Search for the opening '('.
+        i = 0
+        while (i < tokenlen) and (tokenlist[i].type in self.t_WS):
+            i += 1
+
+        if (i < tokenlen) and (tokenlist[i].value == '('):
+            positions.append(i+1)
+        else:
+            self.error(self.source,tokenlist[0].lineno,"Missing '(' in macro arguments")
+            return 0, [], []
+
+        i += 1
+
+        while i < tokenlen:
+            t = tokenlist[i]
+            if t.value == '(':
+                current_arg.append(t)
+                nesting += 1
+            elif t.value == ')':
+                nesting -= 1
+                if nesting == 0:
+                    if current_arg:
+                        args.append(self.tokenstrip(current_arg))
+                        positions.append(i)
+                    return i+1,args,positions
+                current_arg.append(t)
+            elif t.value == ',' and nesting == 1:
+                args.append(self.tokenstrip(current_arg))
+                positions.append(i+1)
+                current_arg = []
+            else:
+                current_arg.append(t)
+            i += 1
+
+        # Missing end argument
+        self.error(self.source,tokenlist[-1].lineno,"Missing ')' in macro arguments")
+        return 0, [],[]
+
+    # ----------------------------------------------------------------------
+    # macro_prescan()
+    #
+    # Examine the macro value (token sequence) and identify patch points
+    # This is used to speed up macro expansion later on---we'll know
+    # right away where to apply patches to the value to form the expansion
+    # ----------------------------------------------------------------------
+
+    def macro_prescan(self,macro):
+        macro.patch     = []             # Standard macro arguments
+        macro.str_patch = []             # String conversion expansion
+        macro.var_comma_patch = []       # Variadic macro comma patch
+        i = 0
+        while i < len(macro.value):
+            if macro.value[i].type == self.t_ID and macro.value[i].value in macro.arglist:
+                argnum = macro.arglist.index(macro.value[i].value)
+                # Conversion of argument to a string
+                if i > 0 and macro.value[i-1].value == '#':
+                    macro.value[i] = copy.copy(macro.value[i])
+                    macro.value[i].type = self.t_STRING
+                    del macro.value[i-1]
+                    macro.str_patch.append((argnum,i-1))
+                    continue
+                # Concatenation
+                elif (i > 0 and macro.value[i-1].value == '##'):
+                    macro.patch.append(('c',argnum,i-1))
+                    del macro.value[i-1]
+                    continue
+                elif ((i+1) < len(macro.value) and macro.value[i+1].value == '##'):
+                    macro.patch.append(('c',argnum,i))
+                    i += 1
+                    continue
+                # Standard expansion
+                else:
+                    macro.patch.append(('e',argnum,i))
+            elif macro.value[i].value == '##':
+                if macro.variadic and (i > 0) and (macro.value[i-1].value == ',') and \
+                        ((i+1) < len(macro.value)) and (macro.value[i+1].type == self.t_ID) and \
+                        (macro.value[i+1].value == macro.vararg):
+                    macro.var_comma_patch.append(i-1)
+            i += 1
+        macro.patch.sort(key=lambda x: x[2],reverse=True)
+
+    # ----------------------------------------------------------------------
+    # macro_expand_args()
+    #
+    # Given a Macro and list of arguments (each a token list), this method
+    # returns an expanded version of a macro.  The return value is a token sequence
+    # representing the replacement macro tokens
+    # ----------------------------------------------------------------------
+
+    def macro_expand_args(self,macro,args):
+        # Make a copy of the macro token sequence
+        rep = [copy.copy(_x) for _x in macro.value]
+
+        # Make string expansion patches.  These do not alter the length of the replacement sequence
+
+        str_expansion = {}
+        for argnum, i in macro.str_patch:
+            if argnum not in str_expansion:
+                str_expansion[argnum] = ('"%s"' % "".join([x.value for x in args[argnum]])).replace("\\","\\\\")
+            rep[i] = copy.copy(rep[i])
+            rep[i].value = str_expansion[argnum]
+
+        # Make the variadic macro comma patch.  If the variadic macro argument is empty, we get rid
+        comma_patch = False
+        if macro.variadic and not args[-1]:
+            for i in macro.var_comma_patch:
+                rep[i] = None
+                comma_patch = True
+
+        # Make all other patches.   The order of these matters.  It is assumed that the patch list
+        # has been sorted in reverse order of patch location since replacements will cause the
+        # size of the replacement sequence to expand from the patch point.
+
+        expanded = { }
+        for ptype, argnum, i in macro.patch:
+            # Concatenation.   Argument is left unexpanded
+            if ptype == 'c':
+                rep[i:i+1] = args[argnum]
+            # Normal expansion.  Argument is macro expanded first
+            elif ptype == 'e':
+                if argnum not in expanded:
+                    expanded[argnum] = self.expand_macros(args[argnum])
+                rep[i:i+1] = expanded[argnum]
+
+        # Get rid of removed comma if necessary
+        if comma_patch:
+            rep = [_i for _i in rep if _i]
+
+        return rep
+
+
+    # ----------------------------------------------------------------------
+    # expand_macros()
+    #
+    # Given a list of tokens, this function performs macro expansion.
+    # The expanded argument is a dictionary that contains macros already
+    # expanded.  This is used to prevent infinite recursion.
+    # ----------------------------------------------------------------------
+
+    def expand_macros(self,tokens,expanded=None):
+        if expanded is None:
+            expanded = {}
+        i = 0
+        while i < len(tokens):
+            t = tokens[i]
+            if t.type == self.t_ID:
+                if t.value in self.macros and t.value not in expanded:
+                    # Yes, we found a macro match
+                    expanded[t.value] = True
+
+                    m = self.macros[t.value]
+                    if not m.arglist:
+                        # A simple macro
+                        ex = self.expand_macros([copy.copy(_x) for _x in m.value],expanded)
+                        for e in ex:
+                            e.lineno = t.lineno
+                        tokens[i:i+1] = ex
+                        i += len(ex)
+                    else:
+                        # A macro with arguments
+                        j = i + 1
+                        while j < len(tokens) and tokens[j].type in self.t_WS:
+                            j += 1
+                        if tokens[j].value == '(':
+                            tokcount,args,positions = self.collect_args(tokens[j:])
+                            if not m.variadic and len(args) !=  len(m.arglist):
+                                self.error(self.source,t.lineno,"Macro %s requires %d arguments" % (t.value,len(m.arglist)))
+                                i = j + tokcount
+                            elif m.variadic and len(args) < len(m.arglist)-1:
+                                if len(m.arglist) > 2:
+                                    self.error(self.source,t.lineno,"Macro %s must have at least %d arguments" % (t.value, len(m.arglist)-1))
+                                else:
+                                    self.error(self.source,t.lineno,"Macro %s must have at least %d argument" % (t.value, len(m.arglist)-1))
+                                i = j + tokcount
+                            else:
+                                if m.variadic:
+                                    if len(args) == len(m.arglist)-1:
+                                        args.append([])
+                                    else:
+                                        args[len(m.arglist)-1] = tokens[j+positions[len(m.arglist)-1]:j+tokcount-1]
+                                        del args[len(m.arglist):]
+
+                                # Get macro replacement text
+                                rep = self.macro_expand_args(m,args)
+                                rep = self.expand_macros(rep,expanded)
+                                for r in rep:
+                                    r.lineno = t.lineno
+                                tokens[i:j+tokcount] = rep
+                                i += len(rep)
+                    del expanded[t.value]
+                    continue
+                elif t.value == '__LINE__':
+                    t.type = self.t_INTEGER
+                    t.value = self.t_INTEGER_TYPE(t.lineno)
+
+            i += 1
+        return tokens
+
+    # ----------------------------------------------------------------------
+    # evalexpr()
+    #
+    # Evaluate an expression token sequence for the purposes of evaluating
+    # integral expressions.
+    # ----------------------------------------------------------------------
+
+    def evalexpr(self,tokens):
+        # tokens = tokenize(line)
+        # Search for defined macros
+        i = 0
+        while i < len(tokens):
+            if tokens[i].type == self.t_ID and tokens[i].value == 'defined':
+                j = i + 1
+                needparen = False
+                result = "0L"
+                while j < len(tokens):
+                    if tokens[j].type in self.t_WS:
+                        j += 1
+                        continue
+                    elif tokens[j].type == self.t_ID:
+                        if tokens[j].value in self.macros:
+                            result = "1L"
+                        else:
+                            result = "0L"
+                        if not needparen: break
+                    elif tokens[j].value == '(':
+                        needparen = True
+                    elif tokens[j].value == ')':
+                        break
+                    else:
+                        self.error(self.source,tokens[i].lineno,"Malformed defined()")
+                    j += 1
+                tokens[i].type = self.t_INTEGER
+                tokens[i].value = self.t_INTEGER_TYPE(result)
+                del tokens[i+1:j+1]
+            i += 1
+        tokens = self.expand_macros(tokens)
+        for i,t in enumerate(tokens):
+            if t.type == self.t_ID:
+                tokens[i] = copy.copy(t)
+                tokens[i].type = self.t_INTEGER
+                tokens[i].value = self.t_INTEGER_TYPE("0L")
+            elif t.type == self.t_INTEGER:
+                tokens[i] = copy.copy(t)
+                # Strip off any trailing suffixes
+                tokens[i].value = str(tokens[i].value)
+                while tokens[i].value[-1] not in "0123456789abcdefABCDEF":
+                    tokens[i].value = tokens[i].value[:-1]
+
+        expr = "".join([str(x.value) for x in tokens])
+        expr = expr.replace("&&"," and ")
+        expr = expr.replace("||"," or ")
+        expr = expr.replace("!"," not ")
+        try:
+            result = eval(expr)
+        except Exception:
+            self.error(self.source,tokens[0].lineno,"Couldn't evaluate expression")
+            result = 0
+        return result
+
+    # ----------------------------------------------------------------------
+    # parsegen()
+    #
+    # Parse an input string/
+    # ----------------------------------------------------------------------
+    def parsegen(self,input,source=None):
+
+        # Replace trigraph sequences
+        t = trigraph(input)
+        lines = self.group_lines(t)
+
+        if not source:
+            source = ""
+
+        self.define("__FILE__ \"%s\"" % source)
+
+        self.source = source
+        chunk = []
+        enable = True
+        iftrigger = False
+        ifstack = []
+
+        for x in lines:
+            for i,tok in enumerate(x):
+                if tok.type not in self.t_WS: break
+            if tok.value == '#':
+                # Preprocessor directive
+
+                # insert necessary whitespace instead of eaten tokens
+                for tok in x:
+                    if tok.type in self.t_WS and '\n' in tok.value:
+                        chunk.append(tok)
+
+                dirtokens = self.tokenstrip(x[i+1:])
+                if dirtokens:
+                    name = dirtokens[0].value
+                    args = self.tokenstrip(dirtokens[1:])
+                else:
+                    name = ""
+                    args = []
+
+                if name == 'define':
+                    if enable:
+                        for tok in self.expand_macros(chunk):
+                            yield tok
+                        chunk = []
+                        self.define(args)
+                elif name == 'include':
+                    if enable:
+                        for tok in self.expand_macros(chunk):
+                            yield tok
+                        chunk = []
+                        oldfile = self.macros['__FILE__']
+                        for tok in self.include(args):
+                            yield tok
+                        self.macros['__FILE__'] = oldfile
+                        self.source = source
+                elif name == 'undef':
+                    if enable:
+                        for tok in self.expand_macros(chunk):
+                            yield tok
+                        chunk = []
+                        self.undef(args)
+                elif name == 'ifdef':
+                    ifstack.append((enable,iftrigger))
+                    if enable:
+                        if not args[0].value in self.macros:
+                            enable = False
+                            iftrigger = False
+                        else:
+                            iftrigger = True
+                elif name == 'ifndef':
+                    ifstack.append((enable,iftrigger))
+                    if enable:
+                        if args[0].value in self.macros:
+                            enable = False
+                            iftrigger = False
+                        else:
+                            iftrigger = True
+                elif name == 'if':
+                    ifstack.append((enable,iftrigger))
+                    if enable:
+                        result = self.evalexpr(args)
+                        if not result:
+                            enable = False
+                            iftrigger = False
+                        else:
+                            iftrigger = True
+                elif name == 'elif':
+                    if ifstack:
+                        if ifstack[-1][0]:     # We only pay attention if outer "if" allows this
+                            if enable:         # If already true, we flip enable False
+                                enable = False
+                            elif not iftrigger:   # If False, but not triggered yet, we'll check expression
+                                result = self.evalexpr(args)
+                                if result:
+                                    enable  = True
+                                    iftrigger = True
+                    else:
+                        self.error(self.source,dirtokens[0].lineno,"Misplaced #elif")
+
+                elif name == 'else':
+                    if ifstack:
+                        if ifstack[-1][0]:
+                            if enable:
+                                enable = False
+                            elif not iftrigger:
+                                enable = True
+                                iftrigger = True
+                    else:
+                        self.error(self.source,dirtokens[0].lineno,"Misplaced #else")
+
+                elif name == 'endif':
+                    if ifstack:
+                        enable,iftrigger = ifstack.pop()
+                    else:
+                        self.error(self.source,dirtokens[0].lineno,"Misplaced #endif")
+                else:
+                    # Unknown preprocessor directive
+                    pass
+
+            else:
+                # Normal text
+                if enable:
+                    chunk.extend(x)
+
+        for tok in self.expand_macros(chunk):
+            yield tok
+        chunk = []
+
+    # ----------------------------------------------------------------------
+    # include()
+    #
+    # Implementation of file-inclusion
+    # ----------------------------------------------------------------------
+
+    def include(self,tokens):
+        # Try to extract the filename and then process an include file
+        if not tokens:
+            return
+        if tokens:
+            if tokens[0].value != '<' and tokens[0].type != self.t_STRING:
+                tokens = self.expand_macros(tokens)
+
+            if tokens[0].value == '<':
+                # Include <...>
+                i = 1
+                while i < len(tokens):
+                    if tokens[i].value == '>':
+                        break
+                    i += 1
+                else:
+                    print("Malformed #include <...>")
+                    return
+                filename = "".join([x.value for x in tokens[1:i]])
+                path = self.path + [""] + self.temp_path
+            elif tokens[0].type == self.t_STRING:
+                filename = tokens[0].value[1:-1]
+                path = self.temp_path + [""] + self.path
+            else:
+                print("Malformed #include statement")
+                return
+        for p in path:
+            iname = os.path.join(p,filename)
+            try:
+                data = open(iname,"r").read()
+                dname = os.path.dirname(iname)
+                if dname:
+                    self.temp_path.insert(0,dname)
+                for tok in self.parsegen(data,filename):
+                    yield tok
+                if dname:
+                    del self.temp_path[0]
+                break
+            except IOError:
+                pass
+        else:
+            print("Couldn't find '%s'" % filename)
+
+    # ----------------------------------------------------------------------
+    # define()
+    #
+    # Define a new macro
+    # ----------------------------------------------------------------------
+
+    def define(self,tokens):
+        if isinstance(tokens,STRING_TYPES):
+            tokens = self.tokenize(tokens)
+
+        linetok = tokens
+        try:
+            name = linetok[0]
+            if len(linetok) > 1:
+                mtype = linetok[1]
+            else:
+                mtype = None
+            if not mtype:
+                m = Macro(name.value,[])
+                self.macros[name.value] = m
+            elif mtype.type in self.t_WS:
+                # A normal macro
+                m = Macro(name.value,self.tokenstrip(linetok[2:]))
+                self.macros[name.value] = m
+            elif mtype.value == '(':
+                # A macro with arguments
+                tokcount, args, positions = self.collect_args(linetok[1:])
+                variadic = False
+                for a in args:
+                    if variadic:
+                        print("No more arguments may follow a variadic argument")
+                        break
+                    astr = "".join([str(_i.value) for _i in a])
+                    if astr == "...":
+                        variadic = True
+                        a[0].type = self.t_ID
+                        a[0].value = '__VA_ARGS__'
+                        variadic = True
+                        del a[1:]
+                        continue
+                    elif astr[-3:] == "..." and a[0].type == self.t_ID:
+                        variadic = True
+                        del a[1:]
+                        # If, for some reason, "." is part of the identifier, strip off the name for the purposes
+                        # of macro expansion
+                        if a[0].value[-3:] == '...':
+                            a[0].value = a[0].value[:-3]
+                        continue
+                    if len(a) > 1 or a[0].type != self.t_ID:
+                        print("Invalid macro argument")
+                        break
+                else:
+                    mvalue = self.tokenstrip(linetok[1+tokcount:])
+                    i = 0
+                    while i < len(mvalue):
+                        if i+1 < len(mvalue):
+                            if mvalue[i].type in self.t_WS and mvalue[i+1].value == '##':
+                                del mvalue[i]
+                                continue
+                            elif mvalue[i].value == '##' and mvalue[i+1].type in self.t_WS:
+                                del mvalue[i+1]
+                        i += 1
+                    m = Macro(name.value,mvalue,[x[0].value for x in args],variadic)
+                    self.macro_prescan(m)
+                    self.macros[name.value] = m
+            else:
+                print("Bad macro definition")
+        except LookupError:
+            print("Bad macro definition")
+
+    # ----------------------------------------------------------------------
+    # undef()
+    #
+    # Undefine a macro
+    # ----------------------------------------------------------------------
+
+    def undef(self,tokens):
+        id = tokens[0].value
+        try:
+            del self.macros[id]
+        except LookupError:
+            pass
+
+    # ----------------------------------------------------------------------
+    # parse()
+    #
+    # Parse input text.
+    # ----------------------------------------------------------------------
+    def parse(self,input,source=None,ignore={}):
+        self.ignore = ignore
+        self.parser = self.parsegen(input,source)
+
+    # ----------------------------------------------------------------------
+    # token()
+    #
+    # Method to return individual tokens
+    # ----------------------------------------------------------------------
+    def token(self):
+        try:
+            while True:
+                tok = next(self.parser)
+                if tok.type not in self.ignore: return tok
+        except StopIteration:
+            self.parser = None
+            return None
+
+if __name__ == '__main__':
+    import ply.lex as lex
+    lexer = lex.lex()
+
+    # Run a preprocessor
+    import sys
+    f = open(sys.argv[1])
+    input = f.read()
+
+    p = Preprocessor(lexer)
+    p.parse(input,sys.argv[1])
+    while True:
+        tok = p.token()
+        if not tok: break
+        print(p.source, tok)

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pycparser/ply/ctokens.py

@@ -0,0 +1,133 @@
+# ----------------------------------------------------------------------
+# ctokens.py
+#
+# Token specifications for symbols in ANSI C and C++.  This file is
+# meant to be used as a library in other tokenizers.
+# ----------------------------------------------------------------------
+
+# Reserved words
+
+tokens = [
+    # Literals (identifier, integer constant, float constant, string constant, char const)
+    'ID', 'TYPEID', 'INTEGER', 'FLOAT', 'STRING', 'CHARACTER',
+
+    # Operators (+,-,*,/,%,|,&,~,^,<<,>>, ||, &&, !, <, <=, >, >=, ==, !=)
+    'PLUS', 'MINUS', 'TIMES', 'DIVIDE', 'MODULO',
+    'OR', 'AND', 'NOT', 'XOR', 'LSHIFT', 'RSHIFT',
+    'LOR', 'LAND', 'LNOT',
+    'LT', 'LE', 'GT', 'GE', 'EQ', 'NE',
+    
+    # Assignment (=, *=, /=, %=, +=, -=, <<=, >>=, &=, ^=, |=)
+    'EQUALS', 'TIMESEQUAL', 'DIVEQUAL', 'MODEQUAL', 'PLUSEQUAL', 'MINUSEQUAL',
+    'LSHIFTEQUAL','RSHIFTEQUAL', 'ANDEQUAL', 'XOREQUAL', 'OREQUAL',
+
+    # Increment/decrement (++,--)
+    'INCREMENT', 'DECREMENT',
+
+    # Structure dereference (->)
+    'ARROW',
+
+    # Ternary operator (?)
+    'TERNARY',
+    
+    # Delimeters ( ) [ ] { } , . ; :
+    'LPAREN', 'RPAREN',
+    'LBRACKET', 'RBRACKET',
+    'LBRACE', 'RBRACE',
+    'COMMA', 'PERIOD', 'SEMI', 'COLON',
+
+    # Ellipsis (...)
+    'ELLIPSIS',
+]
+    
+# Operators
+t_PLUS             = r'\+'
+t_MINUS            = r'-'
+t_TIMES            = r'\*'
+t_DIVIDE           = r'/'
+t_MODULO           = r'%'
+t_OR               = r'\|'
+t_AND              = r'&'
+t_NOT              = r'~'
+t_XOR              = r'\^'
+t_LSHIFT           = r'<<'
+t_RSHIFT           = r'>>'
+t_LOR              = r'\|\|'
+t_LAND             = r'&&'
+t_LNOT             = r'!'
+t_LT               = r'<'
+t_GT               = r'>'
+t_LE               = r'<='
+t_GE               = r'>='
+t_EQ               = r'=='
+t_NE               = r'!='
+
+# Assignment operators
+
+t_EQUALS           = r'='
+t_TIMESEQUAL       = r'\*='
+t_DIVEQUAL         = r'/='
+t_MODEQUAL         = r'%='
+t_PLUSEQUAL        = r'\+='
+t_MINUSEQUAL       = r'-='
+t_LSHIFTEQUAL      = r'<<='
+t_RSHIFTEQUAL      = r'>>='
+t_ANDEQUAL         = r'&='
+t_OREQUAL          = r'\|='
+t_XOREQUAL         = r'\^='
+
+# Increment/decrement
+t_INCREMENT        = r'\+\+'
+t_DECREMENT        = r'--'
+
+# ->
+t_ARROW            = r'->'
+
+# ?
+t_TERNARY          = r'\?'
+
+# Delimeters
+t_LPAREN           = r'\('
+t_RPAREN           = r'\)'
+t_LBRACKET         = r'\['
+t_RBRACKET         = r'\]'
+t_LBRACE           = r'\{'
+t_RBRACE           = r'\}'
+t_COMMA            = r','
+t_PERIOD           = r'\.'
+t_SEMI             = r';'
+t_COLON            = r':'
+t_ELLIPSIS         = r'\.\.\.'
+
+# Identifiers
+t_ID = r'[A-Za-z_][A-Za-z0-9_]*'
+
+# Integer literal
+t_INTEGER = r'\d+([uU]|[lL]|[uU][lL]|[lL][uU])?'
+
+# Floating literal
+t_FLOAT = r'((\d+)(\.\d+)(e(\+|-)?(\d+))? | (\d+)e(\+|-)?(\d+))([lL]|[fF])?'
+
+# String literal
+t_STRING = r'\"([^\\\n]|(\\.))*?\"'
+
+# Character constant 'c' or L'c'
+t_CHARACTER = r'(L)?\'([^\\\n]|(\\.))*?\''
+
+# Comment (C-Style)
+def t_COMMENT(t):
+    r'/\*(.|\n)*?\*/'
+    t.lexer.lineno += t.value.count('\n')
+    return t
+
+# Comment (C++-Style)
+def t_CPPCOMMENT(t):
+    r'//.*\n'
+    t.lexer.lineno += 1
+    return t
+
+
+    
+
+
+

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pycparser/ply/lex.py

@@ -0,0 +1,1099 @@
+# -----------------------------------------------------------------------------
+# ply: lex.py
+#
+# Copyright (C) 2001-2017
+# David M. Beazley (Dabeaz LLC)
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the David Beazley or Dabeaz LLC may be used to
+#   endorse or promote products derived from this software without
+#  specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+
+__version__    = '3.10'
+__tabversion__ = '3.10'
+
+import re
+import sys
+import types
+import copy
+import os
+import inspect
+
+# This tuple contains known string types
+try:
+    # Python 2.6
+    StringTypes = (types.StringType, types.UnicodeType)
+except AttributeError:
+    # Python 3.0
+    StringTypes = (str, bytes)
+
+# This regular expression is used to match valid token names
+_is_identifier = re.compile(r'^[a-zA-Z0-9_]+$')
+
+# Exception thrown when invalid token encountered and no default error
+# handler is defined.
+class LexError(Exception):
+    def __init__(self, message, s):
+        self.args = (message,)
+        self.text = s
+
+
+# Token class.  This class is used to represent the tokens produced.
+class LexToken(object):
+    def __str__(self):
+        return 'LexToken(%s,%r,%d,%d)' % (self.type, self.value, self.lineno, self.lexpos)
+
+    def __repr__(self):
+        return str(self)
+
+
+# This object is a stand-in for a logging object created by the
+# logging module.
+
+class PlyLogger(object):
+    def __init__(self, f):
+        self.f = f
+
+    def critical(self, msg, *args, **kwargs):
+        self.f.write((msg % args) + '\n')
+
+    def warning(self, msg, *args, **kwargs):
+        self.f.write('WARNING: ' + (msg % args) + '\n')
+
+    def error(self, msg, *args, **kwargs):
+        self.f.write('ERROR: ' + (msg % args) + '\n')
+
+    info = critical
+    debug = critical
+
+
+# Null logger is used when no output is generated. Does nothing.
+class NullLogger(object):
+    def __getattribute__(self, name):
+        return self
+
+    def __call__(self, *args, **kwargs):
+        return self
+
+
+# -----------------------------------------------------------------------------
+#                        === Lexing Engine ===
+#
+# The following Lexer class implements the lexer runtime.   There are only
+# a few public methods and attributes:
+#
+#    input()          -  Store a new string in the lexer
+#    token()          -  Get the next token
+#    clone()          -  Clone the lexer
+#
+#    lineno           -  Current line number
+#    lexpos           -  Current position in the input string
+# -----------------------------------------------------------------------------
+
+class Lexer:
+    def __init__(self):
+        self.lexre = None             # Master regular expression. This is a list of
+                                      # tuples (re, findex) where re is a compiled
+                                      # regular expression and findex is a list
+                                      # mapping regex group numbers to rules
+        self.lexretext = None         # Current regular expression strings
+        self.lexstatere = {}          # Dictionary mapping lexer states to master regexs
+        self.lexstateretext = {}      # Dictionary mapping lexer states to regex strings
+        self.lexstaterenames = {}     # Dictionary mapping lexer states to symbol names
+        self.lexstate = 'INITIAL'     # Current lexer state
+        self.lexstatestack = []       # Stack of lexer states
+        self.lexstateinfo = None      # State information
+        self.lexstateignore = {}      # Dictionary of ignored characters for each state
+        self.lexstateerrorf = {}      # Dictionary of error functions for each state
+        self.lexstateeoff = {}        # Dictionary of eof functions for each state
+        self.lexreflags = 0           # Optional re compile flags
+        self.lexdata = None           # Actual input data (as a string)
+        self.lexpos = 0               # Current position in input text
+        self.lexlen = 0               # Length of the input text
+        self.lexerrorf = None         # Error rule (if any)
+        self.lexeoff = None           # EOF rule (if any)
+        self.lextokens = None         # List of valid tokens
+        self.lexignore = ''           # Ignored characters
+        self.lexliterals = ''         # Literal characters that can be passed through
+        self.lexmodule = None         # Module
+        self.lineno = 1               # Current line number
+        self.lexoptimize = False      # Optimized mode
+
+    def clone(self, object=None):
+        c = copy.copy(self)
+
+        # If the object parameter has been supplied, it means we are attaching the
+        # lexer to a new object.  In this case, we have to rebind all methods in
+        # the lexstatere and lexstateerrorf tables.
+
+        if object:
+            newtab = {}
+            for key, ritem in self.lexstatere.items():
+                newre = []
+                for cre, findex in ritem:
+                    newfindex = []
+                    for f in findex:
+                        if not f or not f[0]:
+                            newfindex.append(f)
+                            continue
+                        newfindex.append((getattr(object, f[0].__name__), f[1]))
+                newre.append((cre, newfindex))
+                newtab[key] = newre
+            c.lexstatere = newtab
+            c.lexstateerrorf = {}
+            for key, ef in self.lexstateerrorf.items():
+                c.lexstateerrorf[key] = getattr(object, ef.__name__)
+            c.lexmodule = object
+        return c
+
+    # ------------------------------------------------------------
+    # writetab() - Write lexer information to a table file
+    # ------------------------------------------------------------
+    def writetab(self, lextab, outputdir=''):
+        if isinstance(lextab, types.ModuleType):
+            raise IOError("Won't overwrite existing lextab module")
+        basetabmodule = lextab.split('.')[-1]
+        filename = os.path.join(outputdir, basetabmodule) + '.py'
+        with open(filename, 'w') as tf:
+            tf.write('# %s.py. This file automatically created by PLY (version %s). Don\'t edit!\n' % (basetabmodule, __version__))
+            tf.write('_tabversion   = %s\n' % repr(__tabversion__))
+            tf.write('_lextokens    = set(%s)\n' % repr(tuple(self.lextokens)))
+            tf.write('_lexreflags   = %s\n' % repr(self.lexreflags))
+            tf.write('_lexliterals  = %s\n' % repr(self.lexliterals))
+            tf.write('_lexstateinfo = %s\n' % repr(self.lexstateinfo))
+
+            # Rewrite the lexstatere table, replacing function objects with function names
+            tabre = {}
+            for statename, lre in self.lexstatere.items():
+                titem = []
+                for (pat, func), retext, renames in zip(lre, self.lexstateretext[statename], self.lexstaterenames[statename]):
+                    titem.append((retext, _funcs_to_names(func, renames)))
+                tabre[statename] = titem
+
+            tf.write('_lexstatere   = %s\n' % repr(tabre))
+            tf.write('_lexstateignore = %s\n' % repr(self.lexstateignore))
+
+            taberr = {}
+            for statename, ef in self.lexstateerrorf.items():
+                taberr[statename] = ef.__name__ if ef else None
+            tf.write('_lexstateerrorf = %s\n' % repr(taberr))
+
+            tabeof = {}
+            for statename, ef in self.lexstateeoff.items():
+                tabeof[statename] = ef.__name__ if ef else None
+            tf.write('_lexstateeoff = %s\n' % repr(tabeof))
+
+    # ------------------------------------------------------------
+    # readtab() - Read lexer information from a tab file
+    # ------------------------------------------------------------
+    def readtab(self, tabfile, fdict):
+        if isinstance(tabfile, types.ModuleType):
+            lextab = tabfile
+        else:
+            exec('import %s' % tabfile)
+            lextab = sys.modules[tabfile]
+
+        if getattr(lextab, '_tabversion', '0.0') != __tabversion__:
+            raise ImportError('Inconsistent PLY version')
+
+        self.lextokens      = lextab._lextokens
+        self.lexreflags     = lextab._lexreflags
+        self.lexliterals    = lextab._lexliterals
+        self.lextokens_all  = self.lextokens | set(self.lexliterals)
+        self.lexstateinfo   = lextab._lexstateinfo
+        self.lexstateignore = lextab._lexstateignore
+        self.lexstatere     = {}
+        self.lexstateretext = {}
+        for statename, lre in lextab._lexstatere.items():
+            titem = []
+            txtitem = []
+            for pat, func_name in lre:
+                titem.append((re.compile(pat, lextab._lexreflags), _names_to_funcs(func_name, fdict)))
+
+            self.lexstatere[statename] = titem
+            self.lexstateretext[statename] = txtitem
+
+        self.lexstateerrorf = {}
+        for statename, ef in lextab._lexstateerrorf.items():
+            self.lexstateerrorf[statename] = fdict[ef]
+
+        self.lexstateeoff = {}
+        for statename, ef in lextab._lexstateeoff.items():
+            self.lexstateeoff[statename] = fdict[ef]
+
+        self.begin('INITIAL')
+
+    # ------------------------------------------------------------
+    # input() - Push a new string into the lexer
+    # ------------------------------------------------------------
+    def input(self, s):
+        # Pull off the first character to see if s looks like a string
+        c = s[:1]
+        if not isinstance(c, StringTypes):
+            raise ValueError('Expected a string')
+        self.lexdata = s
+        self.lexpos = 0
+        self.lexlen = len(s)
+
+    # ------------------------------------------------------------
+    # begin() - Changes the lexing state
+    # ------------------------------------------------------------
+    def begin(self, state):
+        if state not in self.lexstatere:
+            raise ValueError('Undefined state')
+        self.lexre = self.lexstatere[state]
+        self.lexretext = self.lexstateretext[state]
+        self.lexignore = self.lexstateignore.get(state, '')
+        self.lexerrorf = self.lexstateerrorf.get(state, None)
+        self.lexeoff = self.lexstateeoff.get(state, None)
+        self.lexstate = state
+
+    # ------------------------------------------------------------
+    # push_state() - Changes the lexing state and saves old on stack
+    # ------------------------------------------------------------
+    def push_state(self, state):
+        self.lexstatestack.append(self.lexstate)
+        self.begin(state)
+
+    # ------------------------------------------------------------
+    # pop_state() - Restores the previous state
+    # ------------------------------------------------------------
+    def pop_state(self):
+        self.begin(self.lexstatestack.pop())
+
+    # ------------------------------------------------------------
+    # current_state() - Returns the current lexing state
+    # ------------------------------------------------------------
+    def current_state(self):
+        return self.lexstate
+
+    # ------------------------------------------------------------
+    # skip() - Skip ahead n characters
+    # ------------------------------------------------------------
+    def skip(self, n):
+        self.lexpos += n
+
+    # ------------------------------------------------------------
+    # opttoken() - Return the next token from the Lexer
+    #
+    # Note: This function has been carefully implemented to be as fast
+    # as possible.  Don't make changes unless you really know what
+    # you are doing
+    # ------------------------------------------------------------
+    def token(self):
+        # Make local copies of frequently referenced attributes
+        lexpos    = self.lexpos
+        lexlen    = self.lexlen
+        lexignore = self.lexignore
+        lexdata   = self.lexdata
+
+        while lexpos < lexlen:
+            # This code provides some short-circuit code for whitespace, tabs, and other ignored characters
+            if lexdata[lexpos] in lexignore:
+                lexpos += 1
+                continue
+
+            # Look for a regular expression match
+            for lexre, lexindexfunc in self.lexre:
+                m = lexre.match(lexdata, lexpos)
+                if not m:
+                    continue
+
+                # Create a token for return
+                tok = LexToken()
+                tok.value = m.group()
+                tok.lineno = self.lineno
+                tok.lexpos = lexpos
+
+                i = m.lastindex
+                func, tok.type = lexindexfunc[i]
+
+                if not func:
+                    # If no token type was set, it's an ignored token
+                    if tok.type:
+                        self.lexpos = m.end()
+                        return tok
+                    else:
+                        lexpos = m.end()
+                        break
+
+                lexpos = m.end()
+
+                # If token is processed by a function, call it
+
+                tok.lexer = self      # Set additional attributes useful in token rules
+                self.lexmatch = m
+                self.lexpos = lexpos
+
+                newtok = func(tok)
+
+                # Every function must return a token, if nothing, we just move to next token
+                if not newtok:
+                    lexpos    = self.lexpos         # This is here in case user has updated lexpos.
+                    lexignore = self.lexignore      # This is here in case there was a state change
+                    break
+
+                # Verify type of the token.  If not in the token map, raise an error
+                if not self.lexoptimize:
+                    if newtok.type not in self.lextokens_all:
+                        raise LexError("%s:%d: Rule '%s' returned an unknown token type '%s'" % (
+                            func.__code__.co_filename, func.__code__.co_firstlineno,
+                            func.__name__, newtok.type), lexdata[lexpos:])
+
+                return newtok
+            else:
+                # No match, see if in literals
+                if lexdata[lexpos] in self.lexliterals:
+                    tok = LexToken()
+                    tok.value = lexdata[lexpos]
+                    tok.lineno = self.lineno
+                    tok.type = tok.value
+                    tok.lexpos = lexpos
+                    self.lexpos = lexpos + 1
+                    return tok
+
+                # No match. Call t_error() if defined.
+                if self.lexerrorf:
+                    tok = LexToken()
+                    tok.value = self.lexdata[lexpos:]
+                    tok.lineno = self.lineno
+                    tok.type = 'error'
+                    tok.lexer = self
+                    tok.lexpos = lexpos
+                    self.lexpos = lexpos
+                    newtok = self.lexerrorf(tok)
+                    if lexpos == self.lexpos:
+                        # Error method didn't change text position at all. This is an error.
+                        raise LexError("Scanning error. Illegal character '%s'" % (lexdata[lexpos]), lexdata[lexpos:])
+                    lexpos = self.lexpos
+                    if not newtok:
+                        continue
+                    return newtok
+
+                self.lexpos = lexpos
+                raise LexError("Illegal character '%s' at index %d" % (lexdata[lexpos], lexpos), lexdata[lexpos:])
+
+        if self.lexeoff:
+            tok = LexToken()
+            tok.type = 'eof'
+            tok.value = ''
+            tok.lineno = self.lineno
+            tok.lexpos = lexpos
+            tok.lexer = self
+            self.lexpos = lexpos
+            newtok = self.lexeoff(tok)
+            return newtok
+
+        self.lexpos = lexpos + 1
+        if self.lexdata is None:
+            raise RuntimeError('No input string given with input()')
+        return None
+
+    # Iterator interface
+    def __iter__(self):
+        return self
+
+    def next(self):
+        t = self.token()
+        if t is None:
+            raise StopIteration
+        return t
+
+    __next__ = next
+
+# -----------------------------------------------------------------------------
+#                           ==== Lex Builder ===
+#
+# The functions and classes below are used to collect lexing information
+# and build a Lexer object from it.
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# _get_regex(func)
+#
+# Returns the regular expression assigned to a function either as a doc string
+# or as a .regex attribute attached by the @TOKEN decorator.
+# -----------------------------------------------------------------------------
+def _get_regex(func):
+    return getattr(func, 'regex', func.__doc__)
+
+# -----------------------------------------------------------------------------
+# get_caller_module_dict()
+#
+# This function returns a dictionary containing all of the symbols defined within
+# a caller further down the call stack.  This is used to get the environment
+# associated with the yacc() call if none was provided.
+# -----------------------------------------------------------------------------
+def get_caller_module_dict(levels):
+    f = sys._getframe(levels)
+    ldict = f.f_globals.copy()
+    if f.f_globals != f.f_locals:
+        ldict.update(f.f_locals)
+    return ldict
+
+# -----------------------------------------------------------------------------
+# _funcs_to_names()
+#
+# Given a list of regular expression functions, this converts it to a list
+# suitable for output to a table file
+# -----------------------------------------------------------------------------
+def _funcs_to_names(funclist, namelist):
+    result = []
+    for f, name in zip(funclist, namelist):
+        if f and f[0]:
+            result.append((name, f[1]))
+        else:
+            result.append(f)
+    return result
+
+# -----------------------------------------------------------------------------
+# _names_to_funcs()
+#
+# Given a list of regular expression function names, this converts it back to
+# functions.
+# -----------------------------------------------------------------------------
+def _names_to_funcs(namelist, fdict):
+    result = []
+    for n in namelist:
+        if n and n[0]:
+            result.append((fdict[n[0]], n[1]))
+        else:
+            result.append(n)
+    return result
+
+# -----------------------------------------------------------------------------
+# _form_master_re()
+#
+# This function takes a list of all of the regex components and attempts to
+# form the master regular expression.  Given limitations in the Python re
+# module, it may be necessary to break the master regex into separate expressions.
+# -----------------------------------------------------------------------------
+def _form_master_re(relist, reflags, ldict, toknames):
+    if not relist:
+        return []
+    regex = '|'.join(relist)
+    try:
+        lexre = re.compile(regex, reflags)
+
+        # Build the index to function map for the matching engine
+        lexindexfunc = [None] * (max(lexre.groupindex.values()) + 1)
+        lexindexnames = lexindexfunc[:]
+
+        for f, i in lexre.groupindex.items():
+            handle = ldict.get(f, None)
+            if type(handle) in (types.FunctionType, types.MethodType):
+                lexindexfunc[i] = (handle, toknames[f])
+                lexindexnames[i] = f
+            elif handle is not None:
+                lexindexnames[i] = f
+                if f.find('ignore_') > 0:
+                    lexindexfunc[i] = (None, None)
+                else:
+                    lexindexfunc[i] = (None, toknames[f])
+
+        return [(lexre, lexindexfunc)], [regex], [lexindexnames]
+    except Exception:
+        m = int(len(relist)/2)
+        if m == 0:
+            m = 1
+        llist, lre, lnames = _form_master_re(relist[:m], reflags, ldict, toknames)
+        rlist, rre, rnames = _form_master_re(relist[m:], reflags, ldict, toknames)
+        return (llist+rlist), (lre+rre), (lnames+rnames)
+
+# -----------------------------------------------------------------------------
+# def _statetoken(s,names)
+#
+# Given a declaration name s of the form "t_" and a dictionary whose keys are
+# state names, this function returns a tuple (states,tokenname) where states
+# is a tuple of state names and tokenname is the name of the token.  For example,
+# calling this with s = "t_foo_bar_SPAM" might return (('foo','bar'),'SPAM')
+# -----------------------------------------------------------------------------
+def _statetoken(s, names):
+    nonstate = 1
+    parts = s.split('_')
+    for i, part in enumerate(parts[1:], 1):
+        if part not in names and part != 'ANY':
+            break
+
+    if i > 1:
+        states = tuple(parts[1:i])
+    else:
+        states = ('INITIAL',)
+
+    if 'ANY' in states:
+        states = tuple(names)
+
+    tokenname = '_'.join(parts[i:])
+    return (states, tokenname)
+
+
+# -----------------------------------------------------------------------------
+# LexerReflect()
+#
+# This class represents information needed to build a lexer as extracted from a
+# user's input file.
+# -----------------------------------------------------------------------------
+class LexerReflect(object):
+    def __init__(self, ldict, log=None, reflags=0):
+        self.ldict      = ldict
+        self.error_func = None
+        self.tokens     = []
+        self.reflags    = reflags
+        self.stateinfo  = {'INITIAL': 'inclusive'}
+        self.modules    = set()
+        self.error      = False
+        self.log        = PlyLogger(sys.stderr) if log is None else log
+
+    # Get all of the basic information
+    def get_all(self):
+        self.get_tokens()
+        self.get_literals()
+        self.get_states()
+        self.get_rules()
+
+    # Validate all of the information
+    def validate_all(self):
+        self.validate_tokens()
+        self.validate_literals()
+        self.validate_rules()
+        return self.error
+
+    # Get the tokens map
+    def get_tokens(self):
+        tokens = self.ldict.get('tokens', None)
+        if not tokens:
+            self.log.error('No token list is defined')
+            self.error = True
+            return
+
+        if not isinstance(tokens, (list, tuple)):
+            self.log.error('tokens must be a list or tuple')
+            self.error = True
+            return
+
+        if not tokens:
+            self.log.error('tokens is empty')
+            self.error = True
+            return
+
+        self.tokens = tokens
+
+    # Validate the tokens
+    def validate_tokens(self):
+        terminals = {}
+        for n in self.tokens:
+            if not _is_identifier.match(n):
+                self.log.error("Bad token name '%s'", n)
+                self.error = True
+            if n in terminals:
+                self.log.warning("Token '%s' multiply defined", n)
+            terminals[n] = 1
+
+    # Get the literals specifier
+    def get_literals(self):
+        self.literals = self.ldict.get('literals', '')
+        if not self.literals:
+            self.literals = ''
+
+    # Validate literals
+    def validate_literals(self):
+        try:
+            for c in self.literals:
+                if not isinstance(c, StringTypes) or len(c) > 1:
+                    self.log.error('Invalid literal %s. Must be a single character', repr(c))
+                    self.error = True
+
+        except TypeError:
+            self.log.error('Invalid literals specification. literals must be a sequence of characters')
+            self.error = True
+
+    def get_states(self):
+        self.states = self.ldict.get('states', None)
+        # Build statemap
+        if self.states:
+            if not isinstance(self.states, (tuple, list)):
+                self.log.error('states must be defined as a tuple or list')
+                self.error = True
+            else:
+                for s in self.states:
+                    if not isinstance(s, tuple) or len(s) != 2:
+                        self.log.error("Invalid state specifier %s. Must be a tuple (statename,'exclusive|inclusive')", repr(s))
+                        self.error = True
+                        continue
+                    name, statetype = s
+                    if not isinstance(name, StringTypes):
+                        self.log.error('State name %s must be a string', repr(name))
+                        self.error = True
+                        continue
+                    if not (statetype == 'inclusive' or statetype == 'exclusive'):
+                        self.log.error("State type for state %s must be 'inclusive' or 'exclusive'", name)
+                        self.error = True
+                        continue
+                    if name in self.stateinfo:
+                        self.log.error("State '%s' already defined", name)
+                        self.error = True
+                        continue
+                    self.stateinfo[name] = statetype
+
+    # Get all of the symbols with a t_ prefix and sort them into various
+    # categories (functions, strings, error functions, and ignore characters)
+
+    def get_rules(self):
+        tsymbols = [f for f in self.ldict if f[:2] == 't_']
+
+        # Now build up a list of functions and a list of strings
+        self.toknames = {}        # Mapping of symbols to token names
+        self.funcsym  = {}        # Symbols defined as functions
+        self.strsym   = {}        # Symbols defined as strings
+        self.ignore   = {}        # Ignore strings by state
+        self.errorf   = {}        # Error functions by state
+        self.eoff     = {}        # EOF functions by state
+
+        for s in self.stateinfo:
+            self.funcsym[s] = []
+            self.strsym[s] = []
+
+        if len(tsymbols) == 0:
+            self.log.error('No rules of the form t_rulename are defined')
+            self.error = True
+            return
+
+        for f in tsymbols:
+            t = self.ldict[f]
+            states, tokname = _statetoken(f, self.stateinfo)
+            self.toknames[f] = tokname
+
+            if hasattr(t, '__call__'):
+                if tokname == 'error':
+                    for s in states:
+                        self.errorf[s] = t
+                elif tokname == 'eof':
+                    for s in states:
+                        self.eoff[s] = t
+                elif tokname == 'ignore':
+                    line = t.__code__.co_firstlineno
+                    file = t.__code__.co_filename
+                    self.log.error("%s:%d: Rule '%s' must be defined as a string", file, line, t.__name__)
+                    self.error = True
+                else:
+                    for s in states:
+                        self.funcsym[s].append((f, t))
+            elif isinstance(t, StringTypes):
+                if tokname == 'ignore':
+                    for s in states:
+                        self.ignore[s] = t
+                    if '\\' in t:
+                        self.log.warning("%s contains a literal backslash '\\'", f)
+
+                elif tokname == 'error':
+                    self.log.error("Rule '%s' must be defined as a function", f)
+                    self.error = True
+                else:
+                    for s in states:
+                        self.strsym[s].append((f, t))
+            else:
+                self.log.error('%s not defined as a function or string', f)
+                self.error = True
+
+        # Sort the functions by line number
+        for f in self.funcsym.values():
+            f.sort(key=lambda x: x[1].__code__.co_firstlineno)
+
+        # Sort the strings by regular expression length
+        for s in self.strsym.values():
+            s.sort(key=lambda x: len(x[1]), reverse=True)
+
+    # Validate all of the t_rules collected
+    def validate_rules(self):
+        for state in self.stateinfo:
+            # Validate all rules defined by functions
+
+            for fname, f in self.funcsym[state]:
+                line = f.__code__.co_firstlineno
+                file = f.__code__.co_filename
+                module = inspect.getmodule(f)
+                self.modules.add(module)
+
+                tokname = self.toknames[fname]
+                if isinstance(f, types.MethodType):
+                    reqargs = 2
+                else:
+                    reqargs = 1
+                nargs = f.__code__.co_argcount
+                if nargs > reqargs:
+                    self.log.error("%s:%d: Rule '%s' has too many arguments", file, line, f.__name__)
+                    self.error = True
+                    continue
+
+                if nargs < reqargs:
+                    self.log.error("%s:%d: Rule '%s' requires an argument", file, line, f.__name__)
+                    self.error = True
+                    continue
+
+                if not _get_regex(f):
+                    self.log.error("%s:%d: No regular expression defined for rule '%s'", file, line, f.__name__)
+                    self.error = True
+                    continue
+
+                try:
+                    c = re.compile('(?P<%s>%s)' % (fname, _get_regex(f)), self.reflags)
+                    if c.match(''):
+                        self.log.error("%s:%d: Regular expression for rule '%s' matches empty string", file, line, f.__name__)
+                        self.error = True
+                except re.error as e:
+                    self.log.error("%s:%d: Invalid regular expression for rule '%s'. %s", file, line, f.__name__, e)
+                    if '#' in _get_regex(f):
+                        self.log.error("%s:%d. Make sure '#' in rule '%s' is escaped with '\\#'", file, line, f.__name__)
+                    self.error = True
+
+            # Validate all rules defined by strings
+            for name, r in self.strsym[state]:
+                tokname = self.toknames[name]
+                if tokname == 'error':
+                    self.log.error("Rule '%s' must be defined as a function", name)
+                    self.error = True
+                    continue
+
+                if tokname not in self.tokens and tokname.find('ignore_') < 0:
+                    self.log.error("Rule '%s' defined for an unspecified token %s", name, tokname)
+                    self.error = True
+                    continue
+
+                try:
+                    c = re.compile('(?P<%s>%s)' % (name, r), self.reflags)
+                    if (c.match('')):
+                        self.log.error("Regular expression for rule '%s' matches empty string", name)
+                        self.error = True
+                except re.error as e:
+                    self.log.error("Invalid regular expression for rule '%s'. %s", name, e)
+                    if '#' in r:
+                        self.log.error("Make sure '#' in rule '%s' is escaped with '\\#'", name)
+                    self.error = True
+
+            if not self.funcsym[state] and not self.strsym[state]:
+                self.log.error("No rules defined for state '%s'", state)
+                self.error = True
+
+            # Validate the error function
+            efunc = self.errorf.get(state, None)
+            if efunc:
+                f = efunc
+                line = f.__code__.co_firstlineno
+                file = f.__code__.co_filename
+                module = inspect.getmodule(f)
+                self.modules.add(module)
+
+                if isinstance(f, types.MethodType):
+                    reqargs = 2
+                else:
+                    reqargs = 1
+                nargs = f.__code__.co_argcount
+                if nargs > reqargs:
+                    self.log.error("%s:%d: Rule '%s' has too many arguments", file, line, f.__name__)
+                    self.error = True
+
+                if nargs < reqargs:
+                    self.log.error("%s:%d: Rule '%s' requires an argument", file, line, f.__name__)
+                    self.error = True
+
+        for module in self.modules:
+            self.validate_module(module)
+
+    # -----------------------------------------------------------------------------
+    # validate_module()
+    #
+    # This checks to see if there are duplicated t_rulename() functions or strings
+    # in the parser input file.  This is done using a simple regular expression
+    # match on each line in the source code of the given module.
+    # -----------------------------------------------------------------------------
+
+    def validate_module(self, module):
+        try:
+            lines, linen = inspect.getsourcelines(module)
+        except IOError:
+            return
+
+        fre = re.compile(r'\s*def\s+(t_[a-zA-Z_0-9]*)\(')
+        sre = re.compile(r'\s*(t_[a-zA-Z_0-9]*)\s*=')
+
+        counthash = {}
+        linen += 1
+        for line in lines:
+            m = fre.match(line)
+            if not m:
+                m = sre.match(line)
+            if m:
+                name = m.group(1)
+                prev = counthash.get(name)
+                if not prev:
+                    counthash[name] = linen
+                else:
+                    filename = inspect.getsourcefile(module)
+                    self.log.error('%s:%d: Rule %s redefined. Previously defined on line %d', filename, linen, name, prev)
+                    self.error = True
+            linen += 1
+
+# -----------------------------------------------------------------------------
+# lex(module)
+#
+# Build all of the regular expression rules from definitions in the supplied module
+# -----------------------------------------------------------------------------
+def lex(module=None, object=None, debug=False, optimize=False, lextab='lextab',
+        reflags=int(re.VERBOSE), nowarn=False, outputdir=None, debuglog=None, errorlog=None):
+
+    if lextab is None:
+        lextab = 'lextab'
+
+    global lexer
+
+    ldict = None
+    stateinfo  = {'INITIAL': 'inclusive'}
+    lexobj = Lexer()
+    lexobj.lexoptimize = optimize
+    global token, input
+
+    if errorlog is None:
+        errorlog = PlyLogger(sys.stderr)
+
+    if debug:
+        if debuglog is None:
+            debuglog = PlyLogger(sys.stderr)
+
+    # Get the module dictionary used for the lexer
+    if object:
+        module = object
+
+    # Get the module dictionary used for the parser
+    if module:
+        _items = [(k, getattr(module, k)) for k in dir(module)]
+        ldict = dict(_items)
+        # If no __file__ attribute is available, try to obtain it from the __module__ instead
+        if '__file__' not in ldict:
+            ldict['__file__'] = sys.modules[ldict['__module__']].__file__
+    else:
+        ldict = get_caller_module_dict(2)
+
+    # Determine if the module is package of a package or not.
+    # If so, fix the tabmodule setting so that tables load correctly
+    pkg = ldict.get('__package__')
+    if pkg and isinstance(lextab, str):
+        if '.' not in lextab:
+            lextab = pkg + '.' + lextab
+
+    # Collect parser information from the dictionary
+    linfo = LexerReflect(ldict, log=errorlog, reflags=reflags)
+    linfo.get_all()
+    if not optimize:
+        if linfo.validate_all():
+            raise SyntaxError("Can't build lexer")
+
+    if optimize and lextab:
+        try:
+            lexobj.readtab(lextab, ldict)
+            token = lexobj.token
+            input = lexobj.input
+            lexer = lexobj
+            return lexobj
+
+        except ImportError:
+            pass
+
+    # Dump some basic debugging information
+    if debug:
+        debuglog.info('lex: tokens   = %r', linfo.tokens)
+        debuglog.info('lex: literals = %r', linfo.literals)
+        debuglog.info('lex: states   = %r', linfo.stateinfo)
+
+    # Build a dictionary of valid token names
+    lexobj.lextokens = set()
+    for n in linfo.tokens:
+        lexobj.lextokens.add(n)
+
+    # Get literals specification
+    if isinstance(linfo.literals, (list, tuple)):
+        lexobj.lexliterals = type(linfo.literals[0])().join(linfo.literals)
+    else:
+        lexobj.lexliterals = linfo.literals
+
+    lexobj.lextokens_all = lexobj.lextokens | set(lexobj.lexliterals)
+
+    # Get the stateinfo dictionary
+    stateinfo = linfo.stateinfo
+
+    regexs = {}
+    # Build the master regular expressions
+    for state in stateinfo:
+        regex_list = []
+
+        # Add rules defined by functions first
+        for fname, f in linfo.funcsym[state]:
+            line = f.__code__.co_firstlineno
+            file = f.__code__.co_filename
+            regex_list.append('(?P<%s>%s)' % (fname, _get_regex(f)))
+            if debug:
+                debuglog.info("lex: Adding rule %s -> '%s' (state '%s')", fname, _get_regex(f), state)
+
+        # Now add all of the simple rules
+        for name, r in linfo.strsym[state]:
+            regex_list.append('(?P<%s>%s)' % (name, r))
+            if debug:
+                debuglog.info("lex: Adding rule %s -> '%s' (state '%s')", name, r, state)
+
+        regexs[state] = regex_list
+
+    # Build the master regular expressions
+
+    if debug:
+        debuglog.info('lex: ==== MASTER REGEXS FOLLOW ====')
+
+    for state in regexs:
+        lexre, re_text, re_names = _form_master_re(regexs[state], reflags, ldict, linfo.toknames)
+        lexobj.lexstatere[state] = lexre
+        lexobj.lexstateretext[state] = re_text
+        lexobj.lexstaterenames[state] = re_names
+        if debug:
+            for i, text in enumerate(re_text):
+                debuglog.info("lex: state '%s' : regex[%d] = '%s'", state, i, text)
+
+    # For inclusive states, we need to add the regular expressions from the INITIAL state
+    for state, stype in stateinfo.items():
+        if state != 'INITIAL' and stype == 'inclusive':
+            lexobj.lexstatere[state].extend(lexobj.lexstatere['INITIAL'])
+            lexobj.lexstateretext[state].extend(lexobj.lexstateretext['INITIAL'])
+            lexobj.lexstaterenames[state].extend(lexobj.lexstaterenames['INITIAL'])
+
+    lexobj.lexstateinfo = stateinfo
+    lexobj.lexre = lexobj.lexstatere['INITIAL']
+    lexobj.lexretext = lexobj.lexstateretext['INITIAL']
+    lexobj.lexreflags = reflags
+
+    # Set up ignore variables
+    lexobj.lexstateignore = linfo.ignore
+    lexobj.lexignore = lexobj.lexstateignore.get('INITIAL', '')
+
+    # Set up error functions
+    lexobj.lexstateerrorf = linfo.errorf
+    lexobj.lexerrorf = linfo.errorf.get('INITIAL', None)
+    if not lexobj.lexerrorf:
+        errorlog.warning('No t_error rule is defined')
+
+    # Set up eof functions
+    lexobj.lexstateeoff = linfo.eoff
+    lexobj.lexeoff = linfo.eoff.get('INITIAL', None)
+
+    # Check state information for ignore and error rules
+    for s, stype in stateinfo.items():
+        if stype == 'exclusive':
+            if s not in linfo.errorf:
+                errorlog.warning("No error rule is defined for exclusive state '%s'", s)
+            if s not in linfo.ignore and lexobj.lexignore:
+                errorlog.warning("No ignore rule is defined for exclusive state '%s'", s)
+        elif stype == 'inclusive':
+            if s not in linfo.errorf:
+                linfo.errorf[s] = linfo.errorf.get('INITIAL', None)
+            if s not in linfo.ignore:
+                linfo.ignore[s] = linfo.ignore.get('INITIAL', '')
+
+    # Create global versions of the token() and input() functions
+    token = lexobj.token
+    input = lexobj.input
+    lexer = lexobj
+
+    # If in optimize mode, we write the lextab
+    if lextab and optimize:
+        if outputdir is None:
+            # If no output directory is set, the location of the output files
+            # is determined according to the following rules:
+            #     - If lextab specifies a package, files go into that package directory
+            #     - Otherwise, files go in the same directory as the specifying module
+            if isinstance(lextab, types.ModuleType):
+                srcfile = lextab.__file__
+            else:
+                if '.' not in lextab:
+                    srcfile = ldict['__file__']
+                else:
+                    parts = lextab.split('.')
+                    pkgname = '.'.join(parts[:-1])
+                    exec('import %s' % pkgname)
+                    srcfile = getattr(sys.modules[pkgname], '__file__', '')
+            outputdir = os.path.dirname(srcfile)
+        try:
+            lexobj.writetab(lextab, outputdir)
+        except IOError as e:
+            errorlog.warning("Couldn't write lextab module %r. %s" % (lextab, e))
+
+    return lexobj
+
+# -----------------------------------------------------------------------------
+# runmain()
+#
+# This runs the lexer as a main program
+# -----------------------------------------------------------------------------
+
+def runmain(lexer=None, data=None):
+    if not data:
+        try:
+            filename = sys.argv[1]
+            f = open(filename)
+            data = f.read()
+            f.close()
+        except IndexError:
+            sys.stdout.write('Reading from standard input (type EOF to end):\n')
+            data = sys.stdin.read()
+
+    if lexer:
+        _input = lexer.input
+    else:
+        _input = input
+    _input(data)
+    if lexer:
+        _token = lexer.token
+    else:
+        _token = token
+
+    while True:
+        tok = _token()
+        if not tok:
+            break
+        sys.stdout.write('(%s,%r,%d,%d)\n' % (tok.type, tok.value, tok.lineno, tok.lexpos))
+
+# -----------------------------------------------------------------------------
+# @TOKEN(regex)
+#
+# This decorator function can be used to set the regex expression on a function
+# when its docstring might need to be set in an alternative way
+# -----------------------------------------------------------------------------
+
+def TOKEN(r):
+    def set_regex(f):
+        if hasattr(r, '__call__'):
+            f.regex = _get_regex(r)
+        else:
+            f.regex = r
+        return f
+    return set_regex
+
+# Alternative spelling of the TOKEN decorator
+Token = TOKEN

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pycparser/ply/ygen.py

@@ -0,0 +1,74 @@
+# ply: ygen.py
+#
+# This is a support program that auto-generates different versions of the YACC parsing
+# function with different features removed for the purposes of performance.
+#
+# Users should edit the method LParser.parsedebug() in yacc.py.   The source code 
+# for that method is then used to create the other methods.   See the comments in
+# yacc.py for further details.
+
+import os.path
+import shutil
+
+def get_source_range(lines, tag):
+    srclines = enumerate(lines)
+    start_tag = '#--! %s-start' % tag
+    end_tag = '#--! %s-end' % tag
+
+    for start_index, line in srclines:
+        if line.strip().startswith(start_tag):
+            break
+
+    for end_index, line in srclines:
+        if line.strip().endswith(end_tag):
+            break
+
+    return (start_index + 1, end_index)
+
+def filter_section(lines, tag):
+    filtered_lines = []
+    include = True
+    tag_text = '#--! %s' % tag
+    for line in lines:
+        if line.strip().startswith(tag_text):
+            include = not include
+        elif include:
+            filtered_lines.append(line)
+    return filtered_lines
+
+def main():
+    dirname = os.path.dirname(__file__)
+    shutil.copy2(os.path.join(dirname, 'yacc.py'), os.path.join(dirname, 'yacc.py.bak'))
+    with open(os.path.join(dirname, 'yacc.py'), 'r') as f:
+        lines = f.readlines()
+
+    parse_start, parse_end = get_source_range(lines, 'parsedebug')
+    parseopt_start, parseopt_end = get_source_range(lines, 'parseopt')
+    parseopt_notrack_start, parseopt_notrack_end = get_source_range(lines, 'parseopt-notrack')
+
+    # Get the original source
+    orig_lines = lines[parse_start:parse_end]
+
+    # Filter the DEBUG sections out
+    parseopt_lines = filter_section(orig_lines, 'DEBUG')
+
+    # Filter the TRACKING sections out
+    parseopt_notrack_lines = filter_section(parseopt_lines, 'TRACKING')
+
+    # Replace the parser source sections with updated versions
+    lines[parseopt_notrack_start:parseopt_notrack_end] = parseopt_notrack_lines
+    lines[parseopt_start:parseopt_end] = parseopt_lines
+
+    lines = [line.rstrip()+'\n' for line in lines]
+    with open(os.path.join(dirname, 'yacc.py'), 'w') as f:
+        f.writelines(lines)
+
+    print('Updated yacc.py')
+
+if __name__ == '__main__':
+    main()
+
+
+
+
+