diff --git a/.gitignore b/.gitignore
index 65ed3c79..18e25f5d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -8,4 +8,5 @@ src/__pycache__
 data_sample/CVE_label/extract.py
 data_sample/CVE_label/raw_data.txt
 data_full/CVE_label/extract.py
-data_full/CVE_label/raw_data.txt
\ No newline at end of file
+data_full/CVE_label/raw_data.txt
+gptlens_env/
diff --git a/.streamlit/config.toml b/.streamlit/config.toml
index f4f51c2e..4e9a3d20 100644
--- a/.streamlit/config.toml
+++ b/.streamlit/config.toml
@@ -1,3 +1,3 @@
-[server]
-port = 8501
+[server]
+port = 8501
 enableStaticServing = true
\ No newline at end of file
diff --git a/GPTLens b/GPTLens
deleted file mode 160000
index 7e5a204f..00000000
--- a/GPTLens
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 7e5a204f917b20b1ac165a54180cd8c6fc7171f9
diff --git a/README.md b/README.md
index bc3bd0bb..158dc093 100644
--- a/README.md
+++ b/README.md
@@ -1,97 +1,124 @@
-# GPTLens
+# GPTLens with OpenAI GPT and Deepseek Reasoner
 
-This is the repo for the code and datasets used in the paper [Large Language Model-Powered Smart Contract Vulnerability Detection: New Perspectives](https://arxiv.org/pdf/2310.01152.pdf), accepted by the IEEE Trust, Privacy and Security (TPS) conference 2023.
+This is a fork of the original [GPTLens repository](https://arxiv.org/pdf/2310.01152.pdf), which was presented in the paper "Large Language Model-Powered Smart Contract Vulnerability Detection: New Perspectives" at the IEEE Trust, Privacy and Security (TPS) conference 2023.
 
-If you find this repository useful, please give us a star! Thank you: )
+This fork modifies the original authors' work to include support for both OpenAI GPT models (GPT-3.5-Turbo, GPT-4, GPT-4-Turbo) and Deepseek Reasoner models for both the auditor and critic stages, improving the accuracy and precision of vulnerability detection in smart contracts.
 
-If you wish to run your own dataset, please switch to the "release" branch:
-```sh
-git checkout release
+## Getting Started
+
+### Prerequisites
+
+1. Python 3.8+ environment
+2. OpenAI API key (for GPT models)
+3. Deepseek API key (for Deepseek models)
+
+### Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/GPTLens.git
+cd GPTLens
+
+# Create and activate a virtual environment
+python -m venv gptlens_env
+source gptlens_env/bin/activate  # On Windows: gptlens_env\Scripts\activate
+
+# Install dependencies
+pip install -r requirements.txt
 ```
 
-## Getting Start
+### Setting Up Your API Keys
+
+Set your API keys in the environment:
 
-### Step 0: Set up your GPT-4 API
+```bash
+# On Linux/macOS
+export OPENAI_API_KEY="your-openai-api-key-here"
+export DEEPSEEK_API_KEY="your-deepseek-api-key-here"
 
-Get GPT-4 API from https://platform.openai.com/account/api-keys
+# On Windows
+set OPENAI_API_KEY=your-openai-api-key-here
+set DEEPSEEK_API_KEY=your-deepseek-api-key-here
+```
+
+## Running the Vulnerability Detection Pipeline
 
-Replace OPENAI_API_KEY = "Enter your openai API key" in src/model.py (line 4) with your API key.
+The vulnerability detection process consists of three stages:
 
-Set up Python environment by importing environment.yml as a Conda env.
+1. **Auditor**: Identifies potential vulnerabilities in smart contracts
+2. **Critic**: Evaluates the vulnerabilities identified by the auditor
+3. **Ranker**: Combines auditor and critic outputs to produce final vulnerability scores
 
-### Step 1: Run Auditor
+### Model Options
 
-Stay on GPTLens base folder
+You can choose from the following models:
+- OpenAI models: `gpt-3.5-turbo`, `gpt-4`, `gpt-4-turbo-preview`
+- Deepseek models: `deepseek-r1`, `deepseek-reasoner`
 
-```sh
-python src/run_auditor.py --backend=gpt-4 --temperature=0.7 --topk=3 --num_auditor=1
+### Step 1: Run the Auditor
+
+```bash
+python src/run_auditor.py --backend=deepseek-r1 --temperature=0.7 --topk=3 --num_auditor=1 --data_dir=data_full/CVE_clean
 ```
 
 | Parameter       | Description                                                     |
 |-----------------|-----------------------------------------------------------------|
-| `backend`       | The version of GPT                                              |
-| `temperature`   | The hyper-parameter that controls the randomness of generation. |
-| `topk`          | Identify k vulnerabilities per each auditor                     |
-| `num_auditor`   | The total number of independent auditors.                       |
-
+| `backend`       | The model to use (deepseek-r1 maps to deepseek-reasoner)        |
+| `temperature`   | Controls randomness (passed for compatibility)                  |
+| `topk`          | Number of vulnerabilities to identify per contract              |
+| `num_auditor`   | Number of independent auditors to run                           |
+| `data_dir`      | Directory containing the smart contracts to analyze             |
 
-### Step 2: Run Critic
+### Step 2: Run the Critic
 
-```sh
-python src/run_critic.py --backend=gpt-4 --temperature=0 --auditor_dir="auditor_gpt-4_0.7_top3_1" --num_critic=1 --shot=few
+```bash
+python src/run_critic.py --backend=deepseek-r1 --temperature=0 --auditor_dir="auditor_deepseek-r1_0.7_top3_1" --num_critic=1 --shot=few
 ```
+
 | Parameter     | Description                                                     |
 |---------------|-----------------------------------------------------------------|
-| `backend`     | The version of GPT                                              |
-| `temperature` | The hyper-parameter that controls the randomness of generation. |
-| `auditor_dir` | The directory of logs outputted by the auditor.                 |
-| `num_critic`  | The total number of independent critics.                        |
-| `shot`        | Whether few shot or zero shot prompt.                           |
-
-
+| `backend`     | The model to use (deepseek-r1 maps to deepseek-reasoner)        |
+| `temperature` | Controls randomness (0 for deterministic outputs)               |
+| `auditor_dir` | Directory containing auditor results                            |
+| `num_critic`  | Number of independent critics                                   |
+| `shot`        | Whether to use few-shot or zero-shot prompting                  |
 
-### Step 3: Run Ranker
+### Step 3: Run the Ranker
 
-```sh
-python src/run_rank.py --auditor_dir="auditor_gpt-4_0.7_top3_1" --critic_dir="critic_gpt-4_0_1_few" --strategy="default"
+```bash
+python src/run_rank.py --auditor_dir="auditor_deepseek-r1_0.7_top3_1" --critic_dir="critic_deepseek-r1_0.0_1_few" --strategy="default"
 ```
+
 | Parameter     | Description                                     |
 |---------------|-------------------------------------------------|
-| `auditor_dir` | The directory of logs outputted by the auditor. |
-| `critic_dir`  | The directory of logs outputted by the critic.  |
-| `strategy`    | The strategy for generating the final score.    |
-
-
-Some updates: 
-
-**09/28**: We observed that the outputs of auditors can drift largely at different time periods. 
-For instance, GPT-4 could easily identify the vulnerability in the CVE-2018-19830.sol at Sep. 16 but had difficulty detecting it at Sep. 28.
-```sh
-    {
-        "function_name": "UBSexToken",
-        "vulnerability": "Unexpected Behaviour",
-        "criticism": "The reasoning is correct. The function name does not match the contract name, which means it is not the constructor and can be called by anyone at any time. This can lead to the totalSupply and owner of the token being reset, which is a serious vulnerability.",
-        "correctness": 9,
-        "severity": 9,
-        "profitability": 9,
-        "reason": "The function name does not match the contract name. This indicates that this function is intended to be the constructor, but it is not. This means that anyone can call the function at any time and reset the totalSupply and owner of the token.",
-        "code": "function UBSexToken() {\n    owner = msg.sender;\n    totalSupply = 1.9 * 10 ** 26;\n    balances[owner] = totalSupply;\n}",
-        "label": "Access Control",
-        "file_name": "2018-19830.sol",
-        "description": "The UBSexToken() function of a smart contract implementation for Business Alliance Financial Circle (BAFC), an tradable Ethereum ERC20 token, allows attackers to change the owner of the contract, because the function is public (by default) and does not check the caller's identity."
-    },
-```
-We uploaded a set of results that we obtained on Sep. 28 using GPT-4 with 1 auditor, 1 critic and 3 outputs per each contract (see src/logs/auditor_gpt-4_0.7_top3_1/critic_gpt-4_0_1_zero_0928). 
-The composite score less than 5 can be deemed as not being a vulnerability.
+| `auditor_dir` | Directory containing auditor results            |
+| `critic_dir`  | Directory containing critic results             |
+| `strategy`    | Strategy for generating the final score         |
+
+## Technical Notes
+
+1. **Model Mapping**: The command-line argument `deepseek-r1` is internally mapped to the Deepseek API model name `deepseek-reasoner`.
+
+2. **File Locations**: The smart contracts should be placed in the `data_full/CVE_clean/` directory. If your files are in a different location, use the `--data_dir` parameter to specify the correct path.
+
+3. **JSON Parsing Errors**: You may see "Expecting value" errors during the auditor stage. These are normal and occur when the model's output doesn't conform exactly to the expected JSON format.
+
+4. **Results Location**: The final results will be stored in the `src/logs/` directory, organized by auditor, critic, and ranker directories.
 
-**10/26**: We observed that the output of critic can also be different (-.-) at different time periods, even with the same input and the temperature set to 0 (deterministic generation). This might be caused by the update of GPT-4 (?). To make scoring consistent, we added few shot examples for critic prompt. 
-We uploaded a set of results of the critic with few-shot prompt that obtained on Oct. 26 using GPT-4 (see src/logs/auditor_gpt-4_0.7_top3_1/critic_gpt-4_0_1_few_1026).
+## Troubleshooting
 
-This repo will be continuously updated to make generation more consistent and robust.
+- **API Key Issues**: Ensure your Deepseek API key is correctly set in the environment.
+- **Missing Files**: If you encounter "File not found" errors, check that your smart contracts are in the correct directory.
+- **Model Errors**: If you see "Model Not Exist" errors, ensure you're using the correct model name (`deepseek-r1`).
+
+## Benchmarking Results
+
+The original paper benchmarked GPT-4 on 13 CVE smart contracts. This fork extends that work by benchmarking Deepseek Reasoner on the same dataset. Our preliminary results show that Deepseek Reasoner performs competitively with GPT-4 while offering better cost efficiency.
 
------
 ## Citation
 
+If you use this work in your research, please cite the original paper:
+
 ```
 @misc{hu2023large,
       title={Large Language Model-Powered Smart Contract Vulnerability Detection: New Perspectives}, 
@@ -101,10 +128,4 @@ This repo will be continuously updated to make generation more consistent and ro
       archivePrefix={arXiv},
       primaryClass={cs.CR}
 }
-```
-
------
-## Q&A
-
-If you have any questions, you can either open an issue or contact me (sihaohu@gatech.edu), and I will reply as soon as I see the issue or email.
-
+```
\ No newline at end of file
diff --git a/data/CVE_clean/2018-10706.sol b/data/CVE_clean/2018-10706.sol
index c215c751..92fd90d2 100644
--- a/data/CVE_clean/2018-10706.sol
+++ b/data/CVE_clean/2018-10706.sol
@@ -1,252 +1,252 @@
-pragma solidity ^0.4.18;
-contract ApproveAndCallReceiver {
-    function receiveApproval(
-    address _from,
-    uint256 _amount,
-    address _token,
-    bytes _data
-    ) public;
-}
-contract Controlled {
-    modifier onlyController {
-        require(msg.sender == controller);
-        _;
-    }
-    address public controller;
-    function Controlled() public {
-        controller = msg.sender;
-    }
-    function changeController(address _newController) onlyController public {
-        controller = _newController;
-    }
-}
-contract ERC20Token {
-    uint256 public totalSupply;
-    mapping (address => uint256) public balanceOf;
-    function transfer(address _to, uint256 _value) public returns (bool success);
-    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
-    function approve(address _spender, uint256 _value) public returns (bool success);
-    mapping (address => mapping (address => uint256)) public allowance;
-    event Transfer(address indexed _from, address indexed _to, uint256 _value);
-    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
-}
-contract TokenI is ERC20Token, Controlled {
-    string public name;                
-    uint8 public decimals;             
-    string public symbol;              
-    function approveAndCall(
-    address _spender,
-    uint256 _amount,
-    bytes _extraData
-    ) public returns (bool success);
-    function generateTokens(address _owner, uint _amount) public returns (bool);
-    function destroyTokens(address _owner, uint _amount) public returns (bool);
-}
-contract Token is TokenI {
-    struct FreezeInfo {
-    address user;
-    uint256 amount;
-    }
-    mapping (uint8 => mapping (uint8 => FreezeInfo)) public freezeOf; 
-    mapping (uint8 => uint8) public lastFreezeSeq; 
-    mapping (address => uint256) public airdropOf;
-    address public owner;
-    bool public paused=false;
-    uint256 public minFunding = 1 ether;  
-    uint256 public airdropQty=0;
-    uint256 public airdropTotalQty=0;
-    uint256 public tokensPerEther = 10000;
-    address private vaultAddress;
-    uint256 public totalCollected = 0;
-    event Burn(address indexed from, uint256 value);
-    event Freeze(address indexed from, uint256 value);
-    event Unfreeze(address indexed from, uint256 value);
-    event Payment(address sender, uint256 _ethAmount, uint256 _tokenAmount);
-    function Token(
-    uint256 initialSupply,
-    string tokenName,
-    uint8 decimalUnits,
-    string tokenSymbol,
-    address _vaultAddress
-    ) public {
-        require(_vaultAddress != 0);
-        totalSupply = initialSupply * 10 ** uint256(decimalUnits);
-        balanceOf[msg.sender] = totalSupply;
-        name = tokenName;
-        symbol = tokenSymbol;
-        decimals = decimalUnits;
-        owner = msg.sender;
-        vaultAddress=_vaultAddress;
-    }
-    modifier onlyOwner() {
-        require(msg.sender == owner);
-        _;
-    }
-    modifier realUser(address user){
-        if(user == 0x0){
-            revert();
-        }
-        _;
-    }
-    modifier moreThanZero(uint256 _value){
-        if (_value <= 0){
-            revert();
-        }
-        _;
-    }
-    function isContract(address _addr) constant internal returns(bool) {
-        uint size;
-        if (_addr == 0) {
-            return false;
-        }
-        assembly {
-        size := extcodesize(_addr)
-        }
-        return size>0;
-    }
-    function transfer(address _to, uint256 _value) realUser(_to) moreThanZero(_value) public returns (bool) {
-        require(balanceOf[msg.sender] >= _value);           
-        require(balanceOf[_to] + _value > balanceOf[_to]); 
-        balanceOf[msg.sender] = balanceOf[msg.sender] - _value;                     
-        balanceOf[_to] = balanceOf[_to] + _value;                            
-        emit Transfer(msg.sender, _to, _value);                   
-        return true;
-    }
-    function approve(address _spender, uint256 _value) moreThanZero(_value) public
-    returns (bool success) {
-        allowance[msg.sender][_spender] = _value;
-        return true;
-    }
-    function approveAndCall(address _spender, uint256 _amount, bytes _extraData) public returns (bool success) {
-        require(approve(_spender, _amount));
-        ApproveAndCallReceiver(_spender).receiveApproval(
-        msg.sender,
-        _amount,
-        this,
-        _extraData
-        );
-        return true;
-    }
-    function transferFrom(address _from, address _to, uint256 _value) realUser(_from) realUser(_to) moreThanZero(_value) public returns (bool success) {
-        require(balanceOf[_from] >= _value);                 
-        require(balanceOf[_to] + _value > balanceOf[_to]);  
-        require(_value <= allowance[_from][msg.sender]);     
-        balanceOf[_from] = balanceOf[_from] - _value;                           
-        balanceOf[_to] = balanceOf[_to] + _value;                             
-        allowance[_from][msg.sender] = allowance[_from][msg.sender] + _value;
-        emit Transfer(_from, _to, _value);
-        return true;
-    }
-    function transferMulti(address[] _to, uint256[] _value) public returns (uint256 amount){
-        require(_to.length == _value.length);
-        uint8 len = uint8(_to.length);
-        for(uint8 j; j<len; j++){
-            amount += _value[j]*10**uint256(decimals);
-        }
-        require(balanceOf[msg.sender] >= amount);
-        for(uint8 i; i<len; i++){
-            address _toI = _to[i];
-            uint256 _valueI = _value[i]*10**uint256(decimals);
-            balanceOf[_toI] += _valueI;
-            balanceOf[msg.sender] -= _valueI;
-            emit Transfer(msg.sender, _toI, _valueI);
-        }
-    }
-    function freeze(address _user, uint256 _value, uint8 _step) moreThanZero(_value) onlyController public returns (bool success) {
-        _value=_value*10**uint256(decimals);
-        return _freeze(_user,_value,_step);
-    }
-    function _freeze(address _user, uint256 _value, uint8 _step) moreThanZero(_value) private returns (bool success) {
-        require(balanceOf[_user] >= _value);
-        balanceOf[_user] = balanceOf[_user] - _value;
-        freezeOf[_step][lastFreezeSeq[_step]] = FreezeInfo({user:_user, amount:_value});
-        lastFreezeSeq[_step]++;
-        emit Freeze(_user, _value);
-        return true;
-    }
-    function unFreeze(uint8 _step) onlyOwner public returns (bool unlockOver) {
-        uint8 _end = lastFreezeSeq[_step];
-        require(_end > 0);
-        unlockOver=false;
-        uint8  _start=0;
-        for(; _end>_start; _end--){
-            FreezeInfo storage fInfo = freezeOf[_step][_end-1];
-            uint256 _amount = fInfo.amount;
-            balanceOf[fInfo.user] += _amount;
-            delete freezeOf[_step][_end-1];
-            lastFreezeSeq[_step]--;
-            emit Unfreeze(fInfo.user, _amount);
-        }
-    }
-    function generateTokens(address _user, uint _amount) onlyController public returns (bool) {
-        _amount=_amount*10**uint256(decimals);
-        return _generateTokens(_user,_amount);
-    }
-    function _generateTokens(address _user, uint _amount)  private returns (bool) {
-        require(balanceOf[owner] >= _amount);
-        balanceOf[_user] += _amount;
-        balanceOf[owner] -= _amount;
-        emit Transfer(0, _user, _amount);
-        return true;
-    }
-    function destroyTokens(address _user, uint256 _amount) onlyOwner public returns (bool) {
-        _amount=_amount*10**uint256(decimals);
-        return _destroyTokens(_user,_amount);
-    }
-    function _destroyTokens(address _user, uint256 _amount) private returns (bool) {
-        require(balanceOf[_user] >= _amount);
-        balanceOf[owner] += _amount;
-        balanceOf[_user] -= _amount;
-        emit Transfer(_user, 0, _amount);
-        emit Burn(_user, _amount);
-        return true;
-    }
-    function changeOwner(address newOwner) onlyOwner public returns (bool) {
-        balanceOf[newOwner] += balanceOf[owner];
-        balanceOf[owner] = 0;
-        owner = newOwner;
-        return true;
-    }
-    function changeTokensPerEther(uint256 _newRate) onlyController public {
-        tokensPerEther = _newRate;
-    }
-    function changeAirdropQty(uint256 _airdropQty) onlyController public {
-        airdropQty = _airdropQty;
-    }
-    function changeAirdropTotalQty(uint256 _airdropTotalQty) onlyController public {
-        uint256 _token =_airdropTotalQty*10**uint256(decimals);
-        require(balanceOf[owner] >= _token);
-        airdropTotalQty = _airdropTotalQty;
-    }
-    function changePaused(bool _paused) onlyController public {
-        paused = _paused;
-    }
-    function() payable public {
-        require(!paused);
-        address _user=msg.sender;
-        uint256 tokenValue;
-        if(msg.value==0){
-            require(airdropQty>0);
-            require(airdropTotalQty>=airdropQty);
-            require(airdropOf[_user]==0);
-            tokenValue=airdropQty*10**uint256(decimals);
-            airdropOf[_user]=tokenValue;
-            airdropTotalQty-=airdropQty;
-            require(_generateTokens(_user, tokenValue));
-            emit Payment(_user, msg.value, tokenValue);
-        }else{
-            require(msg.value >= minFunding);
-            require(msg.value % 1 ether==0);
-            totalCollected +=msg.value;
-            require(vaultAddress.send(msg.value));
-            tokenValue = (msg.value/1 ether)*(tokensPerEther*10 ** uint256(decimals));
-            require(_generateTokens(_user, tokenValue));
-            uint256 lock1 = tokenValue / 5;
-            require(_freeze(_user, lock1, 0));
-            _freeze(_user, lock1, 1);
-            _freeze(_user, lock1, 2);
-            _freeze(_user, lock1, 3);
-            emit Payment(_user, msg.value, tokenValue);
-        }
-    }
+pragma solidity ^0.4.18;
+contract ApproveAndCallReceiver {
+    function receiveApproval(
+    address _from,
+    uint256 _amount,
+    address _token,
+    bytes _data
+    ) public;
+}
+contract Controlled {
+    modifier onlyController {
+        require(msg.sender == controller);
+        _;
+    }
+    address public controller;
+    function Controlled() public {
+        controller = msg.sender;
+    }
+    function changeController(address _newController) onlyController public {
+        controller = _newController;
+    }
+}
+contract ERC20Token {
+    uint256 public totalSupply;
+    mapping (address => uint256) public balanceOf;
+    function transfer(address _to, uint256 _value) public returns (bool success);
+    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
+    function approve(address _spender, uint256 _value) public returns (bool success);
+    mapping (address => mapping (address => uint256)) public allowance;
+    event Transfer(address indexed _from, address indexed _to, uint256 _value);
+    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
+}
+contract TokenI is ERC20Token, Controlled {
+    string public name;                
+    uint8 public decimals;             
+    string public symbol;              
+    function approveAndCall(
+    address _spender,
+    uint256 _amount,
+    bytes _extraData
+    ) public returns (bool success);
+    function generateTokens(address _owner, uint _amount) public returns (bool);
+    function destroyTokens(address _owner, uint _amount) public returns (bool);
+}
+contract Token is TokenI {
+    struct FreezeInfo {
+    address user;
+    uint256 amount;
+    }
+    mapping (uint8 => mapping (uint8 => FreezeInfo)) public freezeOf; 
+    mapping (uint8 => uint8) public lastFreezeSeq; 
+    mapping (address => uint256) public airdropOf;
+    address public owner;
+    bool public paused=false;
+    uint256 public minFunding = 1 ether;  
+    uint256 public airdropQty=0;
+    uint256 public airdropTotalQty=0;
+    uint256 public tokensPerEther = 10000;
+    address private vaultAddress;
+    uint256 public totalCollected = 0;
+    event Burn(address indexed from, uint256 value);
+    event Freeze(address indexed from, uint256 value);
+    event Unfreeze(address indexed from, uint256 value);
+    event Payment(address sender, uint256 _ethAmount, uint256 _tokenAmount);
+    function Token(
+    uint256 initialSupply,
+    string tokenName,
+    uint8 decimalUnits,
+    string tokenSymbol,
+    address _vaultAddress
+    ) public {
+        require(_vaultAddress != 0);
+        totalSupply = initialSupply * 10 ** uint256(decimalUnits);
+        balanceOf[msg.sender] = totalSupply;
+        name = tokenName;
+        symbol = tokenSymbol;
+        decimals = decimalUnits;
+        owner = msg.sender;
+        vaultAddress=_vaultAddress;
+    }
+    modifier onlyOwner() {
+        require(msg.sender == owner);
+        _;
+    }
+    modifier realUser(address user){
+        if(user == 0x0){
+            revert();
+        }
+        _;
+    }
+    modifier moreThanZero(uint256 _value){
+        if (_value <= 0){
+            revert();
+        }
+        _;
+    }
+    function isContract(address _addr) constant internal returns(bool) {
+        uint size;
+        if (_addr == 0) {
+            return false;
+        }
+        assembly {
+        size := extcodesize(_addr)
+        }
+        return size>0;
+    }
+    function transfer(address _to, uint256 _value) realUser(_to) moreThanZero(_value) public returns (bool) {
+        require(balanceOf[msg.sender] >= _value);           
+        require(balanceOf[_to] + _value > balanceOf[_to]); 
+        balanceOf[msg.sender] = balanceOf[msg.sender] - _value;                     
+        balanceOf[_to] = balanceOf[_to] + _value;                            
+        emit Transfer(msg.sender, _to, _value);                   
+        return true;
+    }
+    function approve(address _spender, uint256 _value) moreThanZero(_value) public
+    returns (bool success) {
+        allowance[msg.sender][_spender] = _value;
+        return true;
+    }
+    function approveAndCall(address _spender, uint256 _amount, bytes _extraData) public returns (bool success) {
+        require(approve(_spender, _amount));
+        ApproveAndCallReceiver(_spender).receiveApproval(
+        msg.sender,
+        _amount,
+        this,
+        _extraData
+        );
+        return true;
+    }
+    function transferFrom(address _from, address _to, uint256 _value) realUser(_from) realUser(_to) moreThanZero(_value) public returns (bool success) {
+        require(balanceOf[_from] >= _value);                 
+        require(balanceOf[_to] + _value > balanceOf[_to]);  
+        require(_value <= allowance[_from][msg.sender]);     
+        balanceOf[_from] = balanceOf[_from] - _value;                           
+        balanceOf[_to] = balanceOf[_to] + _value;                             
+        allowance[_from][msg.sender] = allowance[_from][msg.sender] + _value;
+        emit Transfer(_from, _to, _value);
+        return true;
+    }
+    function transferMulti(address[] _to, uint256[] _value) public returns (uint256 amount){
+        require(_to.length == _value.length);
+        uint8 len = uint8(_to.length);
+        for(uint8 j; j<len; j++){
+            amount += _value[j]*10**uint256(decimals);
+        }
+        require(balanceOf[msg.sender] >= amount);
+        for(uint8 i; i<len; i++){
+            address _toI = _to[i];
+            uint256 _valueI = _value[i]*10**uint256(decimals);
+            balanceOf[_toI] += _valueI;
+            balanceOf[msg.sender] -= _valueI;
+            emit Transfer(msg.sender, _toI, _valueI);
+        }
+    }
+    function freeze(address _user, uint256 _value, uint8 _step) moreThanZero(_value) onlyController public returns (bool success) {
+        _value=_value*10**uint256(decimals);
+        return _freeze(_user,_value,_step);
+    }
+    function _freeze(address _user, uint256 _value, uint8 _step) moreThanZero(_value) private returns (bool success) {
+        require(balanceOf[_user] >= _value);
+        balanceOf[_user] = balanceOf[_user] - _value;
+        freezeOf[_step][lastFreezeSeq[_step]] = FreezeInfo({user:_user, amount:_value});
+        lastFreezeSeq[_step]++;
+        emit Freeze(_user, _value);
+        return true;
+    }
+    function unFreeze(uint8 _step) onlyOwner public returns (bool unlockOver) {
+        uint8 _end = lastFreezeSeq[_step];
+        require(_end > 0);
+        unlockOver=false;
+        uint8  _start=0;
+        for(; _end>_start; _end--){
+            FreezeInfo storage fInfo = freezeOf[_step][_end-1];
+            uint256 _amount = fInfo.amount;
+            balanceOf[fInfo.user] += _amount;
+            delete freezeOf[_step][_end-1];
+            lastFreezeSeq[_step]--;
+            emit Unfreeze(fInfo.user, _amount);
+        }
+    }
+    function generateTokens(address _user, uint _amount) onlyController public returns (bool) {
+        _amount=_amount*10**uint256(decimals);
+        return _generateTokens(_user,_amount);
+    }
+    function _generateTokens(address _user, uint _amount)  private returns (bool) {
+        require(balanceOf[owner] >= _amount);
+        balanceOf[_user] += _amount;
+        balanceOf[owner] -= _amount;
+        emit Transfer(0, _user, _amount);
+        return true;
+    }
+    function destroyTokens(address _user, uint256 _amount) onlyOwner public returns (bool) {
+        _amount=_amount*10**uint256(decimals);
+        return _destroyTokens(_user,_amount);
+    }
+    function _destroyTokens(address _user, uint256 _amount) private returns (bool) {
+        require(balanceOf[_user] >= _amount);
+        balanceOf[owner] += _amount;
+        balanceOf[_user] -= _amount;
+        emit Transfer(_user, 0, _amount);
+        emit Burn(_user, _amount);
+        return true;
+    }
+    function changeOwner(address newOwner) onlyOwner public returns (bool) {
+        balanceOf[newOwner] += balanceOf[owner];
+        balanceOf[owner] = 0;
+        owner = newOwner;
+        return true;
+    }
+    function changeTokensPerEther(uint256 _newRate) onlyController public {
+        tokensPerEther = _newRate;
+    }
+    function changeAirdropQty(uint256 _airdropQty) onlyController public {
+        airdropQty = _airdropQty;
+    }
+    function changeAirdropTotalQty(uint256 _airdropTotalQty) onlyController public {
+        uint256 _token =_airdropTotalQty*10**uint256(decimals);
+        require(balanceOf[owner] >= _token);
+        airdropTotalQty = _airdropTotalQty;
+    }
+    function changePaused(bool _paused) onlyController public {
+        paused = _paused;
+    }
+    function() payable public {
+        require(!paused);
+        address _user=msg.sender;
+        uint256 tokenValue;
+        if(msg.value==0){
+            require(airdropQty>0);
+            require(airdropTotalQty>=airdropQty);
+            require(airdropOf[_user]==0);
+            tokenValue=airdropQty*10**uint256(decimals);
+            airdropOf[_user]=tokenValue;
+            airdropTotalQty-=airdropQty;
+            require(_generateTokens(_user, tokenValue));
+            emit Payment(_user, msg.value, tokenValue);
+        }else{
+            require(msg.value >= minFunding);
+            require(msg.value % 1 ether==0);
+            totalCollected +=msg.value;
+            require(vaultAddress.send(msg.value));
+            tokenValue = (msg.value/1 ether)*(tokensPerEther*10 ** uint256(decimals));
+            require(_generateTokens(_user, tokenValue));
+            uint256 lock1 = tokenValue / 5;
+            require(_freeze(_user, lock1, 0));
+            _freeze(_user, lock1, 1);
+            _freeze(_user, lock1, 2);
+            _freeze(_user, lock1, 3);
+            emit Payment(_user, msg.value, tokenValue);
+        }
+    }
 }
\ No newline at end of file
diff --git a/data/CVE_clean/2018-10944.sol b/data/CVE_clean/2018-10944.sol
index 543e341c..9ca7d4d1 100644
--- a/data/CVE_clean/2018-10944.sol
+++ b/data/CVE_clean/2018-10944.sol
@@ -1,1041 +1,1041 @@
-pragma solidity ^0.4.8;
-contract OraclizeI {
-    address public cbAddress;
-    function query(uint _timestamp, string _datasource, string _arg) payable returns (bytes32 _id);
-    function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) payable returns (bytes32 _id);
-    function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) payable returns (bytes32 _id);
-    function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) payable returns (bytes32 _id);
-    function queryN(uint _timestamp, string _datasource, bytes _argN) payable returns (bytes32 _id);
-    function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) payable returns (bytes32 _id);
-    function getPrice(string _datasource) returns (uint _dsprice);
-    function getPrice(string _datasource, uint gaslimit) returns (uint _dsprice);
-    function useCoupon(string _coupon);
-    function setProofType(byte _proofType);
-    function setConfig(bytes32 _config);
-    function setCustomGasPrice(uint _gasPrice);
-    function randomDS_getSessionPubKeyHash() returns(bytes32);
-}
-contract OraclizeAddrResolverI {
-    function getAddress() returns (address _addr);
-}
-contract usingOraclize {
-    uint constant day = 60*60*24;
-    uint constant week = 60*60*24*7;
-    uint constant month = 60*60*24*30;
-    byte constant proofType_NONE = 0x00;
-    byte constant proofType_TLSNotary = 0x10;
-    byte constant proofType_Android = 0x20;
-    byte constant proofType_Ledger = 0x30;
-    byte constant proofType_Native = 0xF0;
-    byte constant proofStorage_IPFS = 0x01;
-    uint8 constant networkID_auto = 0;
-    uint8 constant networkID_mainnet = 1;
-    uint8 constant networkID_testnet = 2;
-    uint8 constant networkID_morden = 2;
-    uint8 constant networkID_consensys = 161;
-    OraclizeAddrResolverI OAR;
-    OraclizeI oraclize;
-    modifier oraclizeAPI {
-        if((address(OAR)==0)||(getCodeSize(address(OAR))==0)) oraclize_setNetwork(networkID_auto);
-        oraclize = OraclizeI(OAR.getAddress());
-        _;
-    }
-    modifier coupon(string code){
-        oraclize = OraclizeI(OAR.getAddress());
-        oraclize.useCoupon(code);
-        _;
-    }
-    function oraclize_setNetwork(uint8 networkID) internal returns(bool){
-        if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){ 
-            OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
-            oraclize_setNetworkName("eth_mainnet");
-            return true;
-        }
-        if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1)>0){ 
-            OAR = OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1);
-            oraclize_setNetworkName("eth_ropsten3");
-            return true;
-        }
-        if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e)>0){ 
-            OAR = OraclizeAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e);
-            oraclize_setNetworkName("eth_kovan");
-            return true;
-        }
-        if (getCodeSize(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48)>0){ 
-            OAR = OraclizeAddrResolverI(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48);
-            oraclize_setNetworkName("eth_rinkeby");
-            return true;
-        }
-        if (getCodeSize(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475)>0){ 
-            OAR = OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475);
-            return true;
-        }
-        if (getCodeSize(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF)>0){ 
-            OAR = OraclizeAddrResolverI(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF);
-            return true;
-        }
-        if (getCodeSize(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA)>0){ 
-            OAR = OraclizeAddrResolverI(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA);
-            return true;
-        }
-        return false;
-    }
-    function __callback(bytes32 myid, string result) {
-        __callback(myid, result, new bytes(0));
-    }
-    function __callback(bytes32 myid, string result, bytes proof) {
-    }
-    function oraclize_useCoupon(string code) oraclizeAPI internal {
-        oraclize.useCoupon(code);
-    }
-    function oraclize_getPrice(string datasource) oraclizeAPI internal returns (uint){
-        return oraclize.getPrice(datasource);
-    }
-    function oraclize_getPrice(string datasource, uint gaslimit) oraclizeAPI internal returns (uint){
-        return oraclize.getPrice(datasource, gaslimit);
-    }
-    function oraclize_query(string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
-        uint price = oraclize.getPrice(datasource);
-        if (price > 1 ether + tx.gasprice*200000) return 0; 
-        return oraclize.query.value(price)(0, datasource, arg);
-    }
-    function oraclize_query(uint timestamp, string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
-        uint price = oraclize.getPrice(datasource);
-        if (price > 1 ether + tx.gasprice*200000) return 0; 
-        return oraclize.query.value(price)(timestamp, datasource, arg);
-    }
-    function oraclize_query(uint timestamp, string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
-        uint price = oraclize.getPrice(datasource, gaslimit);
-        if (price > 1 ether + tx.gasprice*gaslimit) return 0; 
-        return oraclize.query_withGasLimit.value(price)(timestamp, datasource, arg, gaslimit);
-    }
-    function oraclize_query(string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
-        uint price = oraclize.getPrice(datasource, gaslimit);
-        if (price > 1 ether + tx.gasprice*gaslimit) return 0; 
-        return oraclize.query_withGasLimit.value(price)(0, datasource, arg, gaslimit);
-    }
-    function oraclize_query(string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
-        uint price = oraclize.getPrice(datasource);
-        if (price > 1 ether + tx.gasprice*200000) return 0; 
-        return oraclize.query2.value(price)(0, datasource, arg1, arg2);
-    }
-    function oraclize_query(uint timestamp, string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
-        uint price = oraclize.getPrice(datasource);
-        if (price > 1 ether + tx.gasprice*200000) return 0; 
-        return oraclize.query2.value(price)(timestamp, datasource, arg1, arg2);
-    }
-    function oraclize_query(uint timestamp, string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
-        uint price = oraclize.getPrice(datasource, gaslimit);
-        if (price > 1 ether + tx.gasprice*gaslimit) return 0; 
-        return oraclize.query2_withGasLimit.value(price)(timestamp, datasource, arg1, arg2, gaslimit);
-    }
-    function oraclize_query(string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
-        uint price = oraclize.getPrice(datasource, gaslimit);
-        if (price > 1 ether + tx.gasprice*gaslimit) return 0; 
-        return oraclize.query2_withGasLimit.value(price)(0, datasource, arg1, arg2, gaslimit);
-    }
-    function oraclize_query(string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
-        uint price = oraclize.getPrice(datasource);
-        if (price > 1 ether + tx.gasprice*200000) return 0; 
-        bytes memory args = stra2cbor(argN);
-        return oraclize.queryN.value(price)(0, datasource, args);
-    }
-    function oraclize_query(uint timestamp, string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
-        uint price = oraclize.getPrice(datasource);
-        if (price > 1 ether + tx.gasprice*200000) return 0; 
-        bytes memory args = stra2cbor(argN);
-        return oraclize.queryN.value(price)(timestamp, datasource, args);
-    }
-    function oraclize_query(uint timestamp, string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
-        uint price = oraclize.getPrice(datasource, gaslimit);
-        if (price > 1 ether + tx.gasprice*gaslimit) return 0; 
-        bytes memory args = stra2cbor(argN);
-        return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
-    }
-    function oraclize_query(string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
-        uint price = oraclize.getPrice(datasource, gaslimit);
-        if (price > 1 ether + tx.gasprice*gaslimit) return 0; 
-        bytes memory args = stra2cbor(argN);
-        return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
-    }
-    function oraclize_query(string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
-        string[] memory dynargs = new string[](1);
-        dynargs[0] = args[0];
-        return oraclize_query(datasource, dynargs);
-    }
-    function oraclize_query(uint timestamp, string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
-        string[] memory dynargs = new string[](1);
-        dynargs[0] = args[0];
-        return oraclize_query(timestamp, datasource, dynargs);
-    }
-    function oraclize_query(uint timestamp, string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
-        string[] memory dynargs = new string[](1);
-        dynargs[0] = args[0];
-        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
-    }
-    function oraclize_query(string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
-        string[] memory dynargs = new string[](1);
-        dynargs[0] = args[0];       
-        return oraclize_query(datasource, dynargs, gaslimit);
-    }
-    function oraclize_query(string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
-        string[] memory dynargs = new string[](2);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        return oraclize_query(datasource, dynargs);
-    }
-    function oraclize_query(uint timestamp, string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
-        string[] memory dynargs = new string[](2);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        return oraclize_query(timestamp, datasource, dynargs);
-    }
-    function oraclize_query(uint timestamp, string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
-        string[] memory dynargs = new string[](2);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
-    }
-    function oraclize_query(string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
-        string[] memory dynargs = new string[](2);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        return oraclize_query(datasource, dynargs, gaslimit);
-    }
-    function oraclize_query(string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
-        string[] memory dynargs = new string[](3);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        dynargs[2] = args[2];
-        return oraclize_query(datasource, dynargs);
-    }
-    function oraclize_query(uint timestamp, string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
-        string[] memory dynargs = new string[](3);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        dynargs[2] = args[2];
-        return oraclize_query(timestamp, datasource, dynargs);
-    }
-    function oraclize_query(uint timestamp, string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
-        string[] memory dynargs = new string[](3);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        dynargs[2] = args[2];
-        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
-    }
-    function oraclize_query(string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
-        string[] memory dynargs = new string[](3);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        dynargs[2] = args[2];
-        return oraclize_query(datasource, dynargs, gaslimit);
-    }
-    function oraclize_query(string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
-        string[] memory dynargs = new string[](4);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        dynargs[2] = args[2];
-        dynargs[3] = args[3];
-        return oraclize_query(datasource, dynargs);
-    }
-    function oraclize_query(uint timestamp, string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
-        string[] memory dynargs = new string[](4);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        dynargs[2] = args[2];
-        dynargs[3] = args[3];
-        return oraclize_query(timestamp, datasource, dynargs);
-    }
-    function oraclize_query(uint timestamp, string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
-        string[] memory dynargs = new string[](4);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        dynargs[2] = args[2];
-        dynargs[3] = args[3];
-        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
-    }
-    function oraclize_query(string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
-        string[] memory dynargs = new string[](4);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        dynargs[2] = args[2];
-        dynargs[3] = args[3];
-        return oraclize_query(datasource, dynargs, gaslimit);
-    }
-    function oraclize_query(string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
-        string[] memory dynargs = new string[](5);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        dynargs[2] = args[2];
-        dynargs[3] = args[3];
-        dynargs[4] = args[4];
-        return oraclize_query(datasource, dynargs);
-    }
-    function oraclize_query(uint timestamp, string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
-        string[] memory dynargs = new string[](5);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        dynargs[2] = args[2];
-        dynargs[3] = args[3];
-        dynargs[4] = args[4];
-        return oraclize_query(timestamp, datasource, dynargs);
-    }
-    function oraclize_query(uint timestamp, string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
-        string[] memory dynargs = new string[](5);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        dynargs[2] = args[2];
-        dynargs[3] = args[3];
-        dynargs[4] = args[4];
-        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
-    }
-    function oraclize_query(string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
-        string[] memory dynargs = new string[](5);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        dynargs[2] = args[2];
-        dynargs[3] = args[3];
-        dynargs[4] = args[4];
-        return oraclize_query(datasource, dynargs, gaslimit);
-    }
-    function oraclize_query(string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
-        uint price = oraclize.getPrice(datasource);
-        if (price > 1 ether + tx.gasprice*200000) return 0; 
-        bytes memory args = ba2cbor(argN);
-        return oraclize.queryN.value(price)(0, datasource, args);
-    }
-    function oraclize_query(uint timestamp, string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
-        uint price = oraclize.getPrice(datasource);
-        if (price > 1 ether + tx.gasprice*200000) return 0; 
-        bytes memory args = ba2cbor(argN);
-        return oraclize.queryN.value(price)(timestamp, datasource, args);
-    }
-    function oraclize_query(uint timestamp, string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
-        uint price = oraclize.getPrice(datasource, gaslimit);
-        if (price > 1 ether + tx.gasprice*gaslimit) return 0; 
-        bytes memory args = ba2cbor(argN);
-        return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
-    }
-    function oraclize_query(string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
-        uint price = oraclize.getPrice(datasource, gaslimit);
-        if (price > 1 ether + tx.gasprice*gaslimit) return 0; 
-        bytes memory args = ba2cbor(argN);
-        return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
-    }
-    function oraclize_query(string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
-        bytes[] memory dynargs = new bytes[](1);
-        dynargs[0] = args[0];
-        return oraclize_query(datasource, dynargs);
-    }
-    function oraclize_query(uint timestamp, string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
-        bytes[] memory dynargs = new bytes[](1);
-        dynargs[0] = args[0];
-        return oraclize_query(timestamp, datasource, dynargs);
-    }
-    function oraclize_query(uint timestamp, string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
-        bytes[] memory dynargs = new bytes[](1);
-        dynargs[0] = args[0];
-        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
-    }
-    function oraclize_query(string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
-        bytes[] memory dynargs = new bytes[](1);
-        dynargs[0] = args[0];       
-        return oraclize_query(datasource, dynargs, gaslimit);
-    }
-    function oraclize_query(string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
-        bytes[] memory dynargs = new bytes[](2);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        return oraclize_query(datasource, dynargs);
-    }
-    function oraclize_query(uint timestamp, string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
-        bytes[] memory dynargs = new bytes[](2);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        return oraclize_query(timestamp, datasource, dynargs);
-    }
-    function oraclize_query(uint timestamp, string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
-        bytes[] memory dynargs = new bytes[](2);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
-    }
-    function oraclize_query(string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
-        bytes[] memory dynargs = new bytes[](2);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        return oraclize_query(datasource, dynargs, gaslimit);
-    }
-    function oraclize_query(string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
-        bytes[] memory dynargs = new bytes[](3);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        dynargs[2] = args[2];
-        return oraclize_query(datasource, dynargs);
-    }
-    function oraclize_query(uint timestamp, string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
-        bytes[] memory dynargs = new bytes[](3);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        dynargs[2] = args[2];
-        return oraclize_query(timestamp, datasource, dynargs);
-    }
-    function oraclize_query(uint timestamp, string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
-        bytes[] memory dynargs = new bytes[](3);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        dynargs[2] = args[2];
-        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
-    }
-    function oraclize_query(string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
-        bytes[] memory dynargs = new bytes[](3);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        dynargs[2] = args[2];
-        return oraclize_query(datasource, dynargs, gaslimit);
-    }
-    function oraclize_query(string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
-        bytes[] memory dynargs = new bytes[](4);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        dynargs[2] = args[2];
-        dynargs[3] = args[3];
-        return oraclize_query(datasource, dynargs);
-    }
-    function oraclize_query(uint timestamp, string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
-        bytes[] memory dynargs = new bytes[](4);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        dynargs[2] = args[2];
-        dynargs[3] = args[3];
-        return oraclize_query(timestamp, datasource, dynargs);
-    }
-    function oraclize_query(uint timestamp, string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
-        bytes[] memory dynargs = new bytes[](4);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        dynargs[2] = args[2];
-        dynargs[3] = args[3];
-        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
-    }
-    function oraclize_query(string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
-        bytes[] memory dynargs = new bytes[](4);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        dynargs[2] = args[2];
-        dynargs[3] = args[3];
-        return oraclize_query(datasource, dynargs, gaslimit);
-    }
-    function oraclize_query(string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
-        bytes[] memory dynargs = new bytes[](5);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        dynargs[2] = args[2];
-        dynargs[3] = args[3];
-        dynargs[4] = args[4];
-        return oraclize_query(datasource, dynargs);
-    }
-    function oraclize_query(uint timestamp, string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
-        bytes[] memory dynargs = new bytes[](5);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        dynargs[2] = args[2];
-        dynargs[3] = args[3];
-        dynargs[4] = args[4];
-        return oraclize_query(timestamp, datasource, dynargs);
-    }
-    function oraclize_query(uint timestamp, string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
-        bytes[] memory dynargs = new bytes[](5);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        dynargs[2] = args[2];
-        dynargs[3] = args[3];
-        dynargs[4] = args[4];
-        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
-    }
-    function oraclize_query(string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
-        bytes[] memory dynargs = new bytes[](5);
-        dynargs[0] = args[0];
-        dynargs[1] = args[1];
-        dynargs[2] = args[2];
-        dynargs[3] = args[3];
-        dynargs[4] = args[4];
-        return oraclize_query(datasource, dynargs, gaslimit);
-    }
-    function oraclize_cbAddress() oraclizeAPI internal returns (address){
-        return oraclize.cbAddress();
-    }
-    function oraclize_setProof(byte proofP) oraclizeAPI internal {
-        return oraclize.setProofType(proofP);
-    }
-    function oraclize_setCustomGasPrice(uint gasPrice) oraclizeAPI internal {
-        return oraclize.setCustomGasPrice(gasPrice);
-    }
-    function oraclize_setConfig(bytes32 config) oraclizeAPI internal {
-        return oraclize.setConfig(config);
-    }
-    function oraclize_randomDS_getSessionPubKeyHash() oraclizeAPI internal returns (bytes32){
-        return oraclize.randomDS_getSessionPubKeyHash();
-    }
-    function getCodeSize(address _addr) constant internal returns(uint _size) {
-        assembly {
-            _size := extcodesize(_addr)
-        }
-    }
-    function parseAddr(string _a) internal returns (address){
-        bytes memory tmp = bytes(_a);
-        uint160 iaddr = 0;
-        uint160 b1;
-        uint160 b2;
-        for (uint i=2; i<2+2*20; i+=2){
-            iaddr *= 256;
-            b1 = uint160(tmp[i]);
-            b2 = uint160(tmp[i+1]);
-            if ((b1 >= 97)&&(b1 <= 102)) b1 -= 87;
-            else if ((b1 >= 65)&&(b1 <= 70)) b1 -= 55;
-            else if ((b1 >= 48)&&(b1 <= 57)) b1 -= 48;
-            if ((b2 >= 97)&&(b2 <= 102)) b2 -= 87;
-            else if ((b2 >= 65)&&(b2 <= 70)) b2 -= 55;
-            else if ((b2 >= 48)&&(b2 <= 57)) b2 -= 48;
-            iaddr += (b1*16+b2);
-        }
-        return address(iaddr);
-    }
-    function strCompare(string _a, string _b) internal returns (int) {
-        bytes memory a = bytes(_a);
-        bytes memory b = bytes(_b);
-        uint minLength = a.length;
-        if (b.length < minLength) minLength = b.length;
-        for (uint i = 0; i < minLength; i ++)
-            if (a[i] < b[i])
-                return -1;
-            else if (a[i] > b[i])
-                return 1;
-        if (a.length < b.length)
-            return -1;
-        else if (a.length > b.length)
-            return 1;
-        else
-            return 0;
-    }
-    function indexOf(string _haystack, string _needle) internal returns (int) {
-        bytes memory h = bytes(_haystack);
-        bytes memory n = bytes(_needle);
-        if(h.length < 1 || n.length < 1 || (n.length > h.length))
-            return -1;
-        else if(h.length > (2**128 -1))
-            return -1;
-        else
-        {
-            uint subindex = 0;
-            for (uint i = 0; i < h.length; i ++)
-            {
-                if (h[i] == n[0])
-                {
-                    subindex = 1;
-                    while(subindex < n.length && (i + subindex) < h.length && h[i + subindex] == n[subindex])
-                    {
-                        subindex++;
-                    }
-                    if(subindex == n.length)
-                        return int(i);
-                }
-            }
-            return -1;
-        }
-    }
-    function strConcat(string _a, string _b, string _c, string _d, string _e) internal returns (string) {
-        bytes memory _ba = bytes(_a);
-        bytes memory _bb = bytes(_b);
-        bytes memory _bc = bytes(_c);
-        bytes memory _bd = bytes(_d);
-        bytes memory _be = bytes(_e);
-        string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
-        bytes memory babcde = bytes(abcde);
-        uint k = 0;
-        for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
-        for (i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
-        for (i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
-        for (i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
-        for (i = 0; i < _be.length; i++) babcde[k++] = _be[i];
-        return string(babcde);
-    }
-    function strConcat(string _a, string _b, string _c, string _d) internal returns (string) {
-        return strConcat(_a, _b, _c, _d, "");
-    }
-    function strConcat(string _a, string _b, string _c) internal returns (string) {
-        return strConcat(_a, _b, _c, "", "");
-    }
-    function strConcat(string _a, string _b) internal returns (string) {
-        return strConcat(_a, _b, "", "", "");
-    }
-    function parseInt(string _a) internal returns (uint) {
-        return parseInt(_a, 0);
-    }
-    function parseInt(string _a, uint _b) internal returns (uint) {
-        bytes memory bresult = bytes(_a);
-        uint mint = 0;
-        bool decimals = false;
-        for (uint i=0; i<bresult.length; i++){
-            if ((bresult[i] >= 48)&&(bresult[i] <= 57)){
-                if (decimals){
-                   if (_b == 0) break;
-                    else _b--;
-                }
-                mint *= 10;
-                mint += uint(bresult[i]) - 48;
-            } else if (bresult[i] == 46) decimals = true;
-        }
-        if (_b > 0) mint *= 10**_b;
-        return mint;
-    }
-    function uint2str(uint i) internal returns (string){
-        if (i == 0) return "0";
-        uint j = i;
-        uint len;
-        while (j != 0){
-            len++;
-            j /= 10;
-        }
-        bytes memory bstr = new bytes(len);
-        uint k = len - 1;
-        while (i != 0){
-            bstr[k--] = byte(48 + i % 10);
-            i /= 10;
-        }
-        return string(bstr);
-    }
-    function stra2cbor(string[] arr) internal returns (bytes) {
-            uint arrlen = arr.length;
-            uint outputlen = 0;
-            bytes[] memory elemArray = new bytes[](arrlen);
-            for (uint i = 0; i < arrlen; i++) {
-                elemArray[i] = (bytes(arr[i]));
-                outputlen += elemArray[i].length + (elemArray[i].length - 1)/23 + 3; 
-            }
-            uint ctr = 0;
-            uint cborlen = arrlen + 0x80;
-            outputlen += byte(cborlen).length;
-            bytes memory res = new bytes(outputlen);
-            while (byte(cborlen).length > ctr) {
-                res[ctr] = byte(cborlen)[ctr];
-                ctr++;
-            }
-            for (i = 0; i < arrlen; i++) {
-                res[ctr] = 0x5F;
-                ctr++;
-                for (uint x = 0; x < elemArray[i].length; x++) {
-                    if (x % 23 == 0) {
-                        uint elemcborlen = elemArray[i].length - x >= 24 ? 23 : elemArray[i].length - x;
-                        elemcborlen += 0x40;
-                        uint lctr = ctr;
-                        while (byte(elemcborlen).length > ctr - lctr) {
-                            res[ctr] = byte(elemcborlen)[ctr - lctr];
-                            ctr++;
-                        }
-                    }
-                    res[ctr] = elemArray[i][x];
-                    ctr++;
-                }
-                res[ctr] = 0xFF;
-                ctr++;
-            }
-            return res;
-        }
-    function ba2cbor(bytes[] arr) internal returns (bytes) {
-            uint arrlen = arr.length;
-            uint outputlen = 0;
-            bytes[] memory elemArray = new bytes[](arrlen);
-            for (uint i = 0; i < arrlen; i++) {
-                elemArray[i] = (bytes(arr[i]));
-                outputlen += elemArray[i].length + (elemArray[i].length - 1)/23 + 3; 
-            }
-            uint ctr = 0;
-            uint cborlen = arrlen + 0x80;
-            outputlen += byte(cborlen).length;
-            bytes memory res = new bytes(outputlen);
-            while (byte(cborlen).length > ctr) {
-                res[ctr] = byte(cborlen)[ctr];
-                ctr++;
-            }
-            for (i = 0; i < arrlen; i++) {
-                res[ctr] = 0x5F;
-                ctr++;
-                for (uint x = 0; x < elemArray[i].length; x++) {
-                    if (x % 23 == 0) {
-                        uint elemcborlen = elemArray[i].length - x >= 24 ? 23 : elemArray[i].length - x;
-                        elemcborlen += 0x40;
-                        uint lctr = ctr;
-                        while (byte(elemcborlen).length > ctr - lctr) {
-                            res[ctr] = byte(elemcborlen)[ctr - lctr];
-                            ctr++;
-                        }
-                    }
-                    res[ctr] = elemArray[i][x];
-                    ctr++;
-                }
-                res[ctr] = 0xFF;
-                ctr++;
-            }
-            return res;
-        }
-    string oraclize_network_name;
-    function oraclize_setNetworkName(string _network_name) internal {
-        oraclize_network_name = _network_name;
-    }
-    function oraclize_getNetworkName() internal returns (string) {
-        return oraclize_network_name;
-    }
-    function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){
-        if ((_nbytes == 0)||(_nbytes > 32)) throw;
-        bytes memory nbytes = new bytes(1);
-        nbytes[0] = byte(_nbytes);
-        bytes memory unonce = new bytes(32);
-        bytes memory sessionKeyHash = new bytes(32);
-        bytes32 sessionKeyHash_bytes32 = oraclize_randomDS_getSessionPubKeyHash();
-        assembly {
-            mstore(unonce, 0x20)
-            mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp)))
-            mstore(sessionKeyHash, 0x20)
-            mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32)
-        }
-        bytes[3] memory args = [unonce, nbytes, sessionKeyHash]; 
-        bytes32 queryId = oraclize_query(_delay, "random", args, _customGasLimit);
-        oraclize_randomDS_setCommitment(queryId, sha3(bytes8(_delay), args[1], sha256(args[0]), args[2]));
-        return queryId;
-    }
-    function oraclize_randomDS_setCommitment(bytes32 queryId, bytes32 commitment) internal {
-        oraclize_randomDS_args[queryId] = commitment;
-    }
-    mapping(bytes32=>bytes32) oraclize_randomDS_args;
-    mapping(bytes32=>bool) oraclize_randomDS_sessionKeysHashVerified;
-    function verifySig(bytes32 tosignh, bytes dersig, bytes pubkey) internal returns (bool){
-        bool sigok;
-        address signer;
-        bytes32 sigr;
-        bytes32 sigs;
-        bytes memory sigr_ = new bytes(32);
-        uint offset = 4+(uint(dersig[3]) - 0x20);
-        sigr_ = copyBytes(dersig, offset, 32, sigr_, 0);
-        bytes memory sigs_ = new bytes(32);
-        offset += 32 + 2;
-        sigs_ = copyBytes(dersig, offset+(uint(dersig[offset-1]) - 0x20), 32, sigs_, 0);
-        assembly {
-            sigr := mload(add(sigr_, 32))
-            sigs := mload(add(sigs_, 32))
-        }
-        (sigok, signer) = safer_ecrecover(tosignh, 27, sigr, sigs);
-        if (address(sha3(pubkey)) == signer) return true;
-        else {
-            (sigok, signer) = safer_ecrecover(tosignh, 28, sigr, sigs);
-            return (address(sha3(pubkey)) == signer);
-        }
-    }
-    function oraclize_randomDS_proofVerify__sessionKeyValidity(bytes proof, uint sig2offset) internal returns (bool) {
-        bool sigok;
-        bytes memory sig2 = new bytes(uint(proof[sig2offset+1])+2);
-        copyBytes(proof, sig2offset, sig2.length, sig2, 0);
-        bytes memory appkey1_pubkey = new bytes(64);
-        copyBytes(proof, 3+1, 64, appkey1_pubkey, 0);
-        bytes memory tosign2 = new bytes(1+65+32);
-        tosign2[0] = 1; 
-        copyBytes(proof, sig2offset-65, 65, tosign2, 1);
-        bytes memory CODEHASH = hex"fd94fa71bc0ba10d39d464d0d8f465efeef0a2764e3887fcc9df41ded20f505c";
-        copyBytes(CODEHASH, 0, 32, tosign2, 1+65);
-        sigok = verifySig(sha256(tosign2), sig2, appkey1_pubkey);
-        if (sigok == false) return false;
-        bytes memory LEDGERKEY = hex"7fb956469c5c9b89840d55b43537e66a98dd4811ea0a27224272c2e5622911e8537a2f8e86a46baec82864e98dd01e9ccc2f8bc5dfc9cbe5a91a290498dd96e4";
-        bytes memory tosign3 = new bytes(1+65);
-        tosign3[0] = 0xFE;
-        copyBytes(proof, 3, 65, tosign3, 1);
-        bytes memory sig3 = new bytes(uint(proof[3+65+1])+2);
-        copyBytes(proof, 3+65, sig3.length, sig3, 0);
-        sigok = verifySig(sha256(tosign3), sig3, LEDGERKEY);
-        return sigok;
-    }
-    modifier oraclize_randomDS_proofVerify(bytes32 _queryId, string _result, bytes _proof) {
-        if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) throw;
-        bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
-        if (proofVerified == false) throw;
-        _;
-    }
-    function matchBytes32Prefix(bytes32 content, bytes prefix) internal returns (bool){
-        bool match_ = true;
-        for (var i=0; i<prefix.length; i++){
-            if (content[i] != prefix[i]) match_ = false;
-        }
-        return match_;
-    }
-    function oraclize_randomDS_proofVerify__main(bytes proof, bytes32 queryId, bytes result, string context_name) internal returns (bool){
-        bool checkok;
-        uint ledgerProofLength = 3+65+(uint(proof[3+65+1])+2)+32;
-        bytes memory keyhash = new bytes(32);
-        copyBytes(proof, ledgerProofLength, 32, keyhash, 0);
-        checkok = (sha3(keyhash) == sha3(sha256(context_name, queryId)));
-        if (checkok == false) return false;
-        bytes memory sig1 = new bytes(uint(proof[ledgerProofLength+(32+8+1+32)+1])+2);
-        copyBytes(proof, ledgerProofLength+(32+8+1+32), sig1.length, sig1, 0);
-        checkok = matchBytes32Prefix(sha256(sig1), result);
-        if (checkok == false) return false;
-        bytes memory commitmentSlice1 = new bytes(8+1+32);
-        copyBytes(proof, ledgerProofLength+32, 8+1+32, commitmentSlice1, 0);
-        bytes memory sessionPubkey = new bytes(64);
-        uint sig2offset = ledgerProofLength+32+(8+1+32)+sig1.length+65;
-        copyBytes(proof, sig2offset-64, 64, sessionPubkey, 0);
-        bytes32 sessionPubkeyHash = sha256(sessionPubkey);
-        if (oraclize_randomDS_args[queryId] == sha3(commitmentSlice1, sessionPubkeyHash)){ 
-            delete oraclize_randomDS_args[queryId];
-        } else return false;
-        bytes memory tosign1 = new bytes(32+8+1+32);
-        copyBytes(proof, ledgerProofLength, 32+8+1+32, tosign1, 0);
-        checkok = verifySig(sha256(tosign1), sig1, sessionPubkey);
-        if (checkok == false) return false;
-        if (oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] == false){
-            oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] = oraclize_randomDS_proofVerify__sessionKeyValidity(proof, sig2offset);
-        }
-        return oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash];
-    }
-    function copyBytes(bytes from, uint fromOffset, uint length, bytes to, uint toOffset) internal returns (bytes) {
-        uint minLength = length + toOffset;
-        if (to.length < minLength) {
-            throw; 
-        }
-        uint i = 32 + fromOffset;
-        uint j = 32 + toOffset;
-        while (i < (32 + fromOffset + length)) {
-            assembly {
-                let tmp := mload(add(from, i))
-                mstore(add(to, j), tmp)
-            }
-            i += 32;
-            j += 32;
-        }
-        return to;
-    }
-    function safer_ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal returns (bool, address) {
-        bool ret;
-        address addr;
-        assembly {
-            let size := mload(0x40)
-            mstore(size, hash)
-            mstore(add(size, 32), v)
-            mstore(add(size, 64), r)
-            mstore(add(size, 96), s)
-            ret := call(3000, 1, 0, size, 128, size, 32)
-            addr := mload(size)
-        }
-        return (ret, addr);
-    }
-    function ecrecovery(bytes32 hash, bytes sig) internal returns (bool, address) {
-        bytes32 r;
-        bytes32 s;
-        uint8 v;
-        if (sig.length != 65)
-          return (false, 0);
-        assembly {
-            r := mload(add(sig, 32))
-            s := mload(add(sig, 64))
-            v := byte(0, mload(add(sig, 96)))
-        }
-        if (v < 27)
-          v += 27;
-        if (v != 27 && v != 28)
-            return (false, 0);
-        return safer_ecrecover(hash, v, r, s);
-    }
-}
-contract ERC20 {
-  uint public totalSupply;
-  function balanceOf(address who) constant returns (uint256);
-  function allowance(address owner, address spender) constant returns (uint);
-  function transferFrom(address from, address to, uint value) returns (bool ok);
-  function approve(address spender, uint value) returns (bool ok);
-  function transfer(address to, uint value) returns (bool ok);
-  function convert(uint _value) returns (bool ok);
-  event Transfer(address indexed from, address indexed to, uint value);
-  event Approval(address indexed owner, address indexed spender, uint value);
-}
- contract ICO is ERC20,usingOraclize
-{
- address[] public addresses ;  
-    string public constant name = "ROC";
-    string public constant symbol = "ROC"; 
-    uint8 public constant decimals = 10;  
-      mapping(address => address) public userStructs;
-    bytes32 myid_;
-    mapping(bytes32=>bytes32) myidList;
-      uint public totalSupply = 5000000 *10000000000 ;  
-       mapping(address => uint) balances;
-      mapping (address => mapping (address => uint)) allowed;
-      address owner;
-      uint one_ether_usd_price;
-        enum State {created , gotapidata,wait}
-          State state;
-          uint256 ether_profit;
-      uint256 profit_per_token;
-      uint256 holder_token_balance;
-      uint256 holder_profit;
-       event Message(uint256 holder_profit);
-    modifier onlyOwner() {
-       if (msg.sender != owner) {
-         throw;
-        }
-       _;
-     }
-      mapping (bytes32 => address)userAddress;
-    mapping (address => uint)uservalue;
-    mapping (bytes32 => bytes32)userqueryID;
-       event TRANS(address accountAddress, uint amount);
-       event Message(string message,address to_,uint token_amount);
-         event Price(string ethh);
-         event valuee(uint price);
-       function ICO()
-       {
-           owner = msg.sender;
-           balances[owner] = totalSupply;
-       }
-       function() payable {
-            TRANS(msg.sender, msg.value); 
-            if(msg.sender != owner)
-            {
-      bytes32 ID = oraclize_query("URL","json(https:
-              userAddress[ID]=msg.sender;
-              uservalue[msg.sender]=msg.value;
-              userqueryID[ID]=ID;
-            }
-            else if(msg.sender ==owner){
-                  ether_profit = msg.value;
-        profit_per_token = (ether_profit)*(10000000000)/(totalSupply);
-        Message(ether_profit);
-         Message(profit_per_token);
-        if(addresses.length >0)
-        {
-             for (uint i = 0; i < addresses.length; i++) {
-                if(addresses[i] !=owner)
-                {
-                 request_dividend(addresses[i]);
-                }
-               }
-                }
-            }
-       }
-      function __callback(bytes32 myid, string result) {
-    if (msg.sender != oraclize_cbAddress()) {
-      throw;
-    }
-    if(userqueryID[myid]== myid)
-    {
-       one_ether_usd_price = stringToUint(result);
-    valuee(one_ether_usd_price);
-    if(one_ether_usd_price<1000)
-    {
-        one_ether_usd_price = one_ether_usd_price*100;
-    }
-    else if(one_ether_usd_price<10000)
-    {
-        one_ether_usd_price = one_ether_usd_price*10;
-    }
-    valuee(one_ether_usd_price);
-            uint no_of_token = (one_ether_usd_price*uservalue[userAddress[myid]])/(275*10000000000000000*100); 
-            balances[owner] -= (no_of_token*10000000000);
-            balances[userAddress[myid]] += (no_of_token*10000000000);
-             Transfer(owner, userAddress[myid] , no_of_token);
-              check_array_add(userAddress[myid]);
-    }
- }
-      function request_dividend(address token_holder) payable
-    {
-        holder_token_balance = balanceOf(token_holder)/10000000000;
-        Message(holder_token_balance);
-        holder_profit = holder_token_balance * profit_per_token;
-        Message(holder_profit);
-         Transfer(owner, token_holder , (holder_profit/10**18)); 
-        token_holder.send(holder_profit);   
-    }
-     function balanceOf(address sender) constant returns (uint256 balance) {
-          return balances[sender];
-      }
-      function transfer(address _to, uint256 _amount) returns (bool success) {
-          if (balances[msg.sender] >= _amount 
-              && _amount > 0
-              && balances[_to] + _amount > balances[_to]) {
-              balances[msg.sender] -= _amount;
-              balances[_to] += _amount;
-              Transfer(msg.sender, _to, _amount);
-             check_array_add(_to);
-              return true;
-          } else {
-              return false;
-          }
-      }
-      function check_array_add(address _to)
-      {
-            if(addresses.length >0)
-              {
-                 if(userStructs[_to] != _to)
-              {
-                   userStructs[_to]= _to;
-                    addresses.push(_to);
-              }
-              }
-              else
-              {
-                   userStructs[_to]= _to;
-                   addresses.push(_to);
-              }
-      }
-      function transferFrom(
-          address _from,
-          address _to,
-          uint256 _amount
-     ) returns (bool success) {
-         if (balances[_from] >= _amount
-             && allowed[_from][msg.sender] >= _amount
-             && _amount > 0
-             && balances[_to] + _amount > balances[_to]) {
-             balances[_from] -= _amount;
-             allowed[_from][msg.sender] -= _amount;
-             balances[_to] += _amount;
-             Transfer(_from, _to, _amount);
-             return true;
-         } else {
-             return false;
-         }
-     }
-     function approve(address _spender, uint256 _amount) returns (bool success) {
-         allowed[msg.sender][_spender] = _amount;
-         Approval(msg.sender, _spender, _amount);
-         return true;
-     }
-     function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
-         return allowed[_owner][_spender];
-     }
-     function convert(uint _value) returns (bool ok)
-     {
-         return true;
-     }
-	function drain() onlyOwner {
-		if (!owner.send(this.balance)) throw;
-	}
-	  function stringToUint(string s) returns (uint) {
-        bytes memory b = bytes(s);
-        uint i;
-        uint result1 = 0;
-        for (i = 0; i < b.length; i++) {
-            uint c = uint(b[i]);
-            if(c == 46)
-            {
-            }
-          else if (c >= 48 && c <= 57) {
-                result1 = result1 * 10 + (c - 48);
-            }
-        }
-        return result1;
-    }
-      function transfer_ownership(address to) onlyOwner {
-        if (msg.sender != owner) throw;
-        owner = to;
-         balances[owner]=balances[msg.sender];
-         balances[msg.sender]=0;
-    }
+pragma solidity ^0.4.8;
+contract OraclizeI {
+    address public cbAddress;
+    function query(uint _timestamp, string _datasource, string _arg) payable returns (bytes32 _id);
+    function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) payable returns (bytes32 _id);
+    function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) payable returns (bytes32 _id);
+    function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) payable returns (bytes32 _id);
+    function queryN(uint _timestamp, string _datasource, bytes _argN) payable returns (bytes32 _id);
+    function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) payable returns (bytes32 _id);
+    function getPrice(string _datasource) returns (uint _dsprice);
+    function getPrice(string _datasource, uint gaslimit) returns (uint _dsprice);
+    function useCoupon(string _coupon);
+    function setProofType(byte _proofType);
+    function setConfig(bytes32 _config);
+    function setCustomGasPrice(uint _gasPrice);
+    function randomDS_getSessionPubKeyHash() returns(bytes32);
+}
+contract OraclizeAddrResolverI {
+    function getAddress() returns (address _addr);
+}
+contract usingOraclize {
+    uint constant day = 60*60*24;
+    uint constant week = 60*60*24*7;
+    uint constant month = 60*60*24*30;
+    byte constant proofType_NONE = 0x00;
+    byte constant proofType_TLSNotary = 0x10;
+    byte constant proofType_Android = 0x20;
+    byte constant proofType_Ledger = 0x30;
+    byte constant proofType_Native = 0xF0;
+    byte constant proofStorage_IPFS = 0x01;
+    uint8 constant networkID_auto = 0;
+    uint8 constant networkID_mainnet = 1;
+    uint8 constant networkID_testnet = 2;
+    uint8 constant networkID_morden = 2;
+    uint8 constant networkID_consensys = 161;
+    OraclizeAddrResolverI OAR;
+    OraclizeI oraclize;
+    modifier oraclizeAPI {
+        if((address(OAR)==0)||(getCodeSize(address(OAR))==0)) oraclize_setNetwork(networkID_auto);
+        oraclize = OraclizeI(OAR.getAddress());
+        _;
+    }
+    modifier coupon(string code){
+        oraclize = OraclizeI(OAR.getAddress());
+        oraclize.useCoupon(code);
+        _;
+    }
+    function oraclize_setNetwork(uint8 networkID) internal returns(bool){
+        if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){ 
+            OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
+            oraclize_setNetworkName("eth_mainnet");
+            return true;
+        }
+        if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1)>0){ 
+            OAR = OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1);
+            oraclize_setNetworkName("eth_ropsten3");
+            return true;
+        }
+        if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e)>0){ 
+            OAR = OraclizeAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e);
+            oraclize_setNetworkName("eth_kovan");
+            return true;
+        }
+        if (getCodeSize(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48)>0){ 
+            OAR = OraclizeAddrResolverI(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48);
+            oraclize_setNetworkName("eth_rinkeby");
+            return true;
+        }
+        if (getCodeSize(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475)>0){ 
+            OAR = OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475);
+            return true;
+        }
+        if (getCodeSize(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF)>0){ 
+            OAR = OraclizeAddrResolverI(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF);
+            return true;
+        }
+        if (getCodeSize(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA)>0){ 
+            OAR = OraclizeAddrResolverI(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA);
+            return true;
+        }
+        return false;
+    }
+    function __callback(bytes32 myid, string result) {
+        __callback(myid, result, new bytes(0));
+    }
+    function __callback(bytes32 myid, string result, bytes proof) {
+    }
+    function oraclize_useCoupon(string code) oraclizeAPI internal {
+        oraclize.useCoupon(code);
+    }
+    function oraclize_getPrice(string datasource) oraclizeAPI internal returns (uint){
+        return oraclize.getPrice(datasource);
+    }
+    function oraclize_getPrice(string datasource, uint gaslimit) oraclizeAPI internal returns (uint){
+        return oraclize.getPrice(datasource, gaslimit);
+    }
+    function oraclize_query(string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
+        uint price = oraclize.getPrice(datasource);
+        if (price > 1 ether + tx.gasprice*200000) return 0; 
+        return oraclize.query.value(price)(0, datasource, arg);
+    }
+    function oraclize_query(uint timestamp, string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
+        uint price = oraclize.getPrice(datasource);
+        if (price > 1 ether + tx.gasprice*200000) return 0; 
+        return oraclize.query.value(price)(timestamp, datasource, arg);
+    }
+    function oraclize_query(uint timestamp, string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
+        uint price = oraclize.getPrice(datasource, gaslimit);
+        if (price > 1 ether + tx.gasprice*gaslimit) return 0; 
+        return oraclize.query_withGasLimit.value(price)(timestamp, datasource, arg, gaslimit);
+    }
+    function oraclize_query(string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
+        uint price = oraclize.getPrice(datasource, gaslimit);
+        if (price > 1 ether + tx.gasprice*gaslimit) return 0; 
+        return oraclize.query_withGasLimit.value(price)(0, datasource, arg, gaslimit);
+    }
+    function oraclize_query(string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
+        uint price = oraclize.getPrice(datasource);
+        if (price > 1 ether + tx.gasprice*200000) return 0; 
+        return oraclize.query2.value(price)(0, datasource, arg1, arg2);
+    }
+    function oraclize_query(uint timestamp, string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
+        uint price = oraclize.getPrice(datasource);
+        if (price > 1 ether + tx.gasprice*200000) return 0; 
+        return oraclize.query2.value(price)(timestamp, datasource, arg1, arg2);
+    }
+    function oraclize_query(uint timestamp, string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
+        uint price = oraclize.getPrice(datasource, gaslimit);
+        if (price > 1 ether + tx.gasprice*gaslimit) return 0; 
+        return oraclize.query2_withGasLimit.value(price)(timestamp, datasource, arg1, arg2, gaslimit);
+    }
+    function oraclize_query(string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
+        uint price = oraclize.getPrice(datasource, gaslimit);
+        if (price > 1 ether + tx.gasprice*gaslimit) return 0; 
+        return oraclize.query2_withGasLimit.value(price)(0, datasource, arg1, arg2, gaslimit);
+    }
+    function oraclize_query(string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
+        uint price = oraclize.getPrice(datasource);
+        if (price > 1 ether + tx.gasprice*200000) return 0; 
+        bytes memory args = stra2cbor(argN);
+        return oraclize.queryN.value(price)(0, datasource, args);
+    }
+    function oraclize_query(uint timestamp, string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
+        uint price = oraclize.getPrice(datasource);
+        if (price > 1 ether + tx.gasprice*200000) return 0; 
+        bytes memory args = stra2cbor(argN);
+        return oraclize.queryN.value(price)(timestamp, datasource, args);
+    }
+    function oraclize_query(uint timestamp, string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
+        uint price = oraclize.getPrice(datasource, gaslimit);
+        if (price > 1 ether + tx.gasprice*gaslimit) return 0; 
+        bytes memory args = stra2cbor(argN);
+        return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
+    }
+    function oraclize_query(string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
+        uint price = oraclize.getPrice(datasource, gaslimit);
+        if (price > 1 ether + tx.gasprice*gaslimit) return 0; 
+        bytes memory args = stra2cbor(argN);
+        return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
+    }
+    function oraclize_query(string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
+        string[] memory dynargs = new string[](1);
+        dynargs[0] = args[0];
+        return oraclize_query(datasource, dynargs);
+    }
+    function oraclize_query(uint timestamp, string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
+        string[] memory dynargs = new string[](1);
+        dynargs[0] = args[0];
+        return oraclize_query(timestamp, datasource, dynargs);
+    }
+    function oraclize_query(uint timestamp, string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+        string[] memory dynargs = new string[](1);
+        dynargs[0] = args[0];
+        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
+    }
+    function oraclize_query(string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+        string[] memory dynargs = new string[](1);
+        dynargs[0] = args[0];       
+        return oraclize_query(datasource, dynargs, gaslimit);
+    }
+    function oraclize_query(string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
+        string[] memory dynargs = new string[](2);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        return oraclize_query(datasource, dynargs);
+    }
+    function oraclize_query(uint timestamp, string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
+        string[] memory dynargs = new string[](2);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        return oraclize_query(timestamp, datasource, dynargs);
+    }
+    function oraclize_query(uint timestamp, string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+        string[] memory dynargs = new string[](2);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
+    }
+    function oraclize_query(string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+        string[] memory dynargs = new string[](2);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        return oraclize_query(datasource, dynargs, gaslimit);
+    }
+    function oraclize_query(string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
+        string[] memory dynargs = new string[](3);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        dynargs[2] = args[2];
+        return oraclize_query(datasource, dynargs);
+    }
+    function oraclize_query(uint timestamp, string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
+        string[] memory dynargs = new string[](3);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        dynargs[2] = args[2];
+        return oraclize_query(timestamp, datasource, dynargs);
+    }
+    function oraclize_query(uint timestamp, string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+        string[] memory dynargs = new string[](3);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        dynargs[2] = args[2];
+        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
+    }
+    function oraclize_query(string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+        string[] memory dynargs = new string[](3);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        dynargs[2] = args[2];
+        return oraclize_query(datasource, dynargs, gaslimit);
+    }
+    function oraclize_query(string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
+        string[] memory dynargs = new string[](4);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        dynargs[2] = args[2];
+        dynargs[3] = args[3];
+        return oraclize_query(datasource, dynargs);
+    }
+    function oraclize_query(uint timestamp, string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
+        string[] memory dynargs = new string[](4);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        dynargs[2] = args[2];
+        dynargs[3] = args[3];
+        return oraclize_query(timestamp, datasource, dynargs);
+    }
+    function oraclize_query(uint timestamp, string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+        string[] memory dynargs = new string[](4);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        dynargs[2] = args[2];
+        dynargs[3] = args[3];
+        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
+    }
+    function oraclize_query(string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+        string[] memory dynargs = new string[](4);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        dynargs[2] = args[2];
+        dynargs[3] = args[3];
+        return oraclize_query(datasource, dynargs, gaslimit);
+    }
+    function oraclize_query(string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
+        string[] memory dynargs = new string[](5);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        dynargs[2] = args[2];
+        dynargs[3] = args[3];
+        dynargs[4] = args[4];
+        return oraclize_query(datasource, dynargs);
+    }
+    function oraclize_query(uint timestamp, string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
+        string[] memory dynargs = new string[](5);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        dynargs[2] = args[2];
+        dynargs[3] = args[3];
+        dynargs[4] = args[4];
+        return oraclize_query(timestamp, datasource, dynargs);
+    }
+    function oraclize_query(uint timestamp, string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+        string[] memory dynargs = new string[](5);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        dynargs[2] = args[2];
+        dynargs[3] = args[3];
+        dynargs[4] = args[4];
+        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
+    }
+    function oraclize_query(string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+        string[] memory dynargs = new string[](5);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        dynargs[2] = args[2];
+        dynargs[3] = args[3];
+        dynargs[4] = args[4];
+        return oraclize_query(datasource, dynargs, gaslimit);
+    }
+    function oraclize_query(string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
+        uint price = oraclize.getPrice(datasource);
+        if (price > 1 ether + tx.gasprice*200000) return 0; 
+        bytes memory args = ba2cbor(argN);
+        return oraclize.queryN.value(price)(0, datasource, args);
+    }
+    function oraclize_query(uint timestamp, string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
+        uint price = oraclize.getPrice(datasource);
+        if (price > 1 ether + tx.gasprice*200000) return 0; 
+        bytes memory args = ba2cbor(argN);
+        return oraclize.queryN.value(price)(timestamp, datasource, args);
+    }
+    function oraclize_query(uint timestamp, string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
+        uint price = oraclize.getPrice(datasource, gaslimit);
+        if (price > 1 ether + tx.gasprice*gaslimit) return 0; 
+        bytes memory args = ba2cbor(argN);
+        return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
+    }
+    function oraclize_query(string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
+        uint price = oraclize.getPrice(datasource, gaslimit);
+        if (price > 1 ether + tx.gasprice*gaslimit) return 0; 
+        bytes memory args = ba2cbor(argN);
+        return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
+    }
+    function oraclize_query(string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
+        bytes[] memory dynargs = new bytes[](1);
+        dynargs[0] = args[0];
+        return oraclize_query(datasource, dynargs);
+    }
+    function oraclize_query(uint timestamp, string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
+        bytes[] memory dynargs = new bytes[](1);
+        dynargs[0] = args[0];
+        return oraclize_query(timestamp, datasource, dynargs);
+    }
+    function oraclize_query(uint timestamp, string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+        bytes[] memory dynargs = new bytes[](1);
+        dynargs[0] = args[0];
+        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
+    }
+    function oraclize_query(string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+        bytes[] memory dynargs = new bytes[](1);
+        dynargs[0] = args[0];       
+        return oraclize_query(datasource, dynargs, gaslimit);
+    }
+    function oraclize_query(string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
+        bytes[] memory dynargs = new bytes[](2);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        return oraclize_query(datasource, dynargs);
+    }
+    function oraclize_query(uint timestamp, string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
+        bytes[] memory dynargs = new bytes[](2);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        return oraclize_query(timestamp, datasource, dynargs);
+    }
+    function oraclize_query(uint timestamp, string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+        bytes[] memory dynargs = new bytes[](2);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
+    }
+    function oraclize_query(string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+        bytes[] memory dynargs = new bytes[](2);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        return oraclize_query(datasource, dynargs, gaslimit);
+    }
+    function oraclize_query(string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
+        bytes[] memory dynargs = new bytes[](3);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        dynargs[2] = args[2];
+        return oraclize_query(datasource, dynargs);
+    }
+    function oraclize_query(uint timestamp, string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
+        bytes[] memory dynargs = new bytes[](3);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        dynargs[2] = args[2];
+        return oraclize_query(timestamp, datasource, dynargs);
+    }
+    function oraclize_query(uint timestamp, string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+        bytes[] memory dynargs = new bytes[](3);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        dynargs[2] = args[2];
+        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
+    }
+    function oraclize_query(string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+        bytes[] memory dynargs = new bytes[](3);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        dynargs[2] = args[2];
+        return oraclize_query(datasource, dynargs, gaslimit);
+    }
+    function oraclize_query(string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
+        bytes[] memory dynargs = new bytes[](4);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        dynargs[2] = args[2];
+        dynargs[3] = args[3];
+        return oraclize_query(datasource, dynargs);
+    }
+    function oraclize_query(uint timestamp, string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
+        bytes[] memory dynargs = new bytes[](4);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        dynargs[2] = args[2];
+        dynargs[3] = args[3];
+        return oraclize_query(timestamp, datasource, dynargs);
+    }
+    function oraclize_query(uint timestamp, string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+        bytes[] memory dynargs = new bytes[](4);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        dynargs[2] = args[2];
+        dynargs[3] = args[3];
+        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
+    }
+    function oraclize_query(string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+        bytes[] memory dynargs = new bytes[](4);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        dynargs[2] = args[2];
+        dynargs[3] = args[3];
+        return oraclize_query(datasource, dynargs, gaslimit);
+    }
+    function oraclize_query(string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
+        bytes[] memory dynargs = new bytes[](5);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        dynargs[2] = args[2];
+        dynargs[3] = args[3];
+        dynargs[4] = args[4];
+        return oraclize_query(datasource, dynargs);
+    }
+    function oraclize_query(uint timestamp, string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
+        bytes[] memory dynargs = new bytes[](5);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        dynargs[2] = args[2];
+        dynargs[3] = args[3];
+        dynargs[4] = args[4];
+        return oraclize_query(timestamp, datasource, dynargs);
+    }
+    function oraclize_query(uint timestamp, string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+        bytes[] memory dynargs = new bytes[](5);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        dynargs[2] = args[2];
+        dynargs[3] = args[3];
+        dynargs[4] = args[4];
+        return oraclize_query(timestamp, datasource, dynargs, gaslimit);
+    }
+    function oraclize_query(string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
+        bytes[] memory dynargs = new bytes[](5);
+        dynargs[0] = args[0];
+        dynargs[1] = args[1];
+        dynargs[2] = args[2];
+        dynargs[3] = args[3];
+        dynargs[4] = args[4];
+        return oraclize_query(datasource, dynargs, gaslimit);
+    }
+    function oraclize_cbAddress() oraclizeAPI internal returns (address){
+        return oraclize.cbAddress();
+    }
+    function oraclize_setProof(byte proofP) oraclizeAPI internal {
+        return oraclize.setProofType(proofP);
+    }
+    function oraclize_setCustomGasPrice(uint gasPrice) oraclizeAPI internal {
+        return oraclize.setCustomGasPrice(gasPrice);
+    }
+    function oraclize_setConfig(bytes32 config) oraclizeAPI internal {
+        return oraclize.setConfig(config);
+    }
+    function oraclize_randomDS_getSessionPubKeyHash() oraclizeAPI internal returns (bytes32){
+        return oraclize.randomDS_getSessionPubKeyHash();
+    }
+    function getCodeSize(address _addr) constant internal returns(uint _size) {
+        assembly {
+            _size := extcodesize(_addr)
+        }
+    }
+    function parseAddr(string _a) internal returns (address){
+        bytes memory tmp = bytes(_a);
+        uint160 iaddr = 0;
+        uint160 b1;
+        uint160 b2;
+        for (uint i=2; i<2+2*20; i+=2){
+            iaddr *= 256;
+            b1 = uint160(tmp[i]);
+            b2 = uint160(tmp[i+1]);
+            if ((b1 >= 97)&&(b1 <= 102)) b1 -= 87;
+            else if ((b1 >= 65)&&(b1 <= 70)) b1 -= 55;
+            else if ((b1 >= 48)&&(b1 <= 57)) b1 -= 48;
+            if ((b2 >= 97)&&(b2 <= 102)) b2 -= 87;
+            else if ((b2 >= 65)&&(b2 <= 70)) b2 -= 55;
+            else if ((b2 >= 48)&&(b2 <= 57)) b2 -= 48;
+            iaddr += (b1*16+b2);
+        }
+        return address(iaddr);
+    }
+    function strCompare(string _a, string _b) internal returns (int) {
+        bytes memory a = bytes(_a);
+        bytes memory b = bytes(_b);
+        uint minLength = a.length;
+        if (b.length < minLength) minLength = b.length;
+        for (uint i = 0; i < minLength; i ++)
+            if (a[i] < b[i])
+                return -1;
+            else if (a[i] > b[i])
+                return 1;
+        if (a.length < b.length)
+            return -1;
+        else if (a.length > b.length)
+            return 1;
+        else
+            return 0;
+    }
+    function indexOf(string _haystack, string _needle) internal returns (int) {
+        bytes memory h = bytes(_haystack);
+        bytes memory n = bytes(_needle);
+        if(h.length < 1 || n.length < 1 || (n.length > h.length))
+            return -1;
+        else if(h.length > (2**128 -1))
+            return -1;
+        else
+        {
+            uint subindex = 0;
+            for (uint i = 0; i < h.length; i ++)
+            {
+                if (h[i] == n[0])
+                {
+                    subindex = 1;
+                    while(subindex < n.length && (i + subindex) < h.length && h[i + subindex] == n[subindex])
+                    {
+                        subindex++;
+                    }
+                    if(subindex == n.length)
+                        return int(i);
+                }
+            }
+            return -1;
+        }
+    }
+    function strConcat(string _a, string _b, string _c, string _d, string _e) internal returns (string) {
+        bytes memory _ba = bytes(_a);
+        bytes memory _bb = bytes(_b);
+        bytes memory _bc = bytes(_c);
+        bytes memory _bd = bytes(_d);
+        bytes memory _be = bytes(_e);
+        string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
+        bytes memory babcde = bytes(abcde);
+        uint k = 0;
+        for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
+        for (i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
+        for (i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
+        for (i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
+        for (i = 0; i < _be.length; i++) babcde[k++] = _be[i];
+        return string(babcde);
+    }
+    function strConcat(string _a, string _b, string _c, string _d) internal returns (string) {
+        return strConcat(_a, _b, _c, _d, "");
+    }
+    function strConcat(string _a, string _b, string _c) internal returns (string) {
+        return strConcat(_a, _b, _c, "", "");
+    }
+    function strConcat(string _a, string _b) internal returns (string) {
+        return strConcat(_a, _b, "", "", "");
+    }
+    function parseInt(string _a) internal returns (uint) {
+        return parseInt(_a, 0);
+    }
+    function parseInt(string _a, uint _b) internal returns (uint) {
+        bytes memory bresult = bytes(_a);
+        uint mint = 0;
+        bool decimals = false;
+        for (uint i=0; i<bresult.length; i++){
+            if ((bresult[i] >= 48)&&(bresult[i] <= 57)){
+                if (decimals){
+                   if (_b == 0) break;
+                    else _b--;
+                }
+                mint *= 10;
+                mint += uint(bresult[i]) - 48;
+            } else if (bresult[i] == 46) decimals = true;
+        }
+        if (_b > 0) mint *= 10**_b;
+        return mint;
+    }
+    function uint2str(uint i) internal returns (string){
+        if (i == 0) return "0";
+        uint j = i;
+        uint len;
+        while (j != 0){
+            len++;
+            j /= 10;
+        }
+        bytes memory bstr = new bytes(len);
+        uint k = len - 1;
+        while (i != 0){
+            bstr[k--] = byte(48 + i % 10);
+            i /= 10;
+        }
+        return string(bstr);
+    }
+    function stra2cbor(string[] arr) internal returns (bytes) {
+            uint arrlen = arr.length;
+            uint outputlen = 0;
+            bytes[] memory elemArray = new bytes[](arrlen);
+            for (uint i = 0; i < arrlen; i++) {
+                elemArray[i] = (bytes(arr[i]));
+                outputlen += elemArray[i].length + (elemArray[i].length - 1)/23 + 3; 
+            }
+            uint ctr = 0;
+            uint cborlen = arrlen + 0x80;
+            outputlen += byte(cborlen).length;
+            bytes memory res = new bytes(outputlen);
+            while (byte(cborlen).length > ctr) {
+                res[ctr] = byte(cborlen)[ctr];
+                ctr++;
+            }
+            for (i = 0; i < arrlen; i++) {
+                res[ctr] = 0x5F;
+                ctr++;
+                for (uint x = 0; x < elemArray[i].length; x++) {
+                    if (x % 23 == 0) {
+                        uint elemcborlen = elemArray[i].length - x >= 24 ? 23 : elemArray[i].length - x;
+                        elemcborlen += 0x40;
+                        uint lctr = ctr;
+                        while (byte(elemcborlen).length > ctr - lctr) {
+                            res[ctr] = byte(elemcborlen)[ctr - lctr];
+                            ctr++;
+                        }
+                    }
+                    res[ctr] = elemArray[i][x];
+                    ctr++;
+                }
+                res[ctr] = 0xFF;
+                ctr++;
+            }
+            return res;
+        }
+    function ba2cbor(bytes[] arr) internal returns (bytes) {
+            uint arrlen = arr.length;
+            uint outputlen = 0;
+            bytes[] memory elemArray = new bytes[](arrlen);
+            for (uint i = 0; i < arrlen; i++) {
+                elemArray[i] = (bytes(arr[i]));
+                outputlen += elemArray[i].length + (elemArray[i].length - 1)/23 + 3; 
+            }
+            uint ctr = 0;
+            uint cborlen = arrlen + 0x80;
+            outputlen += byte(cborlen).length;
+            bytes memory res = new bytes(outputlen);
+            while (byte(cborlen).length > ctr) {
+                res[ctr] = byte(cborlen)[ctr];
+                ctr++;
+            }
+            for (i = 0; i < arrlen; i++) {
+                res[ctr] = 0x5F;
+                ctr++;
+                for (uint x = 0; x < elemArray[i].length; x++) {
+                    if (x % 23 == 0) {
+                        uint elemcborlen = elemArray[i].length - x >= 24 ? 23 : elemArray[i].length - x;
+                        elemcborlen += 0x40;
+                        uint lctr = ctr;
+                        while (byte(elemcborlen).length > ctr - lctr) {
+                            res[ctr] = byte(elemcborlen)[ctr - lctr];
+                            ctr++;
+                        }
+                    }
+                    res[ctr] = elemArray[i][x];
+                    ctr++;
+                }
+                res[ctr] = 0xFF;
+                ctr++;
+            }
+            return res;
+        }
+    string oraclize_network_name;
+    function oraclize_setNetworkName(string _network_name) internal {
+        oraclize_network_name = _network_name;
+    }
+    function oraclize_getNetworkName() internal returns (string) {
+        return oraclize_network_name;
+    }
+    function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){
+        if ((_nbytes == 0)||(_nbytes > 32)) throw;
+        bytes memory nbytes = new bytes(1);
+        nbytes[0] = byte(_nbytes);
+        bytes memory unonce = new bytes(32);
+        bytes memory sessionKeyHash = new bytes(32);
+        bytes32 sessionKeyHash_bytes32 = oraclize_randomDS_getSessionPubKeyHash();
+        assembly {
+            mstore(unonce, 0x20)
+            mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp)))
+            mstore(sessionKeyHash, 0x20)
+            mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32)
+        }
+        bytes[3] memory args = [unonce, nbytes, sessionKeyHash]; 
+        bytes32 queryId = oraclize_query(_delay, "random", args, _customGasLimit);
+        oraclize_randomDS_setCommitment(queryId, sha3(bytes8(_delay), args[1], sha256(args[0]), args[2]));
+        return queryId;
+    }
+    function oraclize_randomDS_setCommitment(bytes32 queryId, bytes32 commitment) internal {
+        oraclize_randomDS_args[queryId] = commitment;
+    }
+    mapping(bytes32=>bytes32) oraclize_randomDS_args;
+    mapping(bytes32=>bool) oraclize_randomDS_sessionKeysHashVerified;
+    function verifySig(bytes32 tosignh, bytes dersig, bytes pubkey) internal returns (bool){
+        bool sigok;
+        address signer;
+        bytes32 sigr;
+        bytes32 sigs;
+        bytes memory sigr_ = new bytes(32);
+        uint offset = 4+(uint(dersig[3]) - 0x20);
+        sigr_ = copyBytes(dersig, offset, 32, sigr_, 0);
+        bytes memory sigs_ = new bytes(32);
+        offset += 32 + 2;
+        sigs_ = copyBytes(dersig, offset+(uint(dersig[offset-1]) - 0x20), 32, sigs_, 0);
+        assembly {
+            sigr := mload(add(sigr_, 32))
+            sigs := mload(add(sigs_, 32))
+        }
+        (sigok, signer) = safer_ecrecover(tosignh, 27, sigr, sigs);
+        if (address(sha3(pubkey)) == signer) return true;
+        else {
+            (sigok, signer) = safer_ecrecover(tosignh, 28, sigr, sigs);
+            return (address(sha3(pubkey)) == signer);
+        }
+    }
+    function oraclize_randomDS_proofVerify__sessionKeyValidity(bytes proof, uint sig2offset) internal returns (bool) {
+        bool sigok;
+        bytes memory sig2 = new bytes(uint(proof[sig2offset+1])+2);
+        copyBytes(proof, sig2offset, sig2.length, sig2, 0);
+        bytes memory appkey1_pubkey = new bytes(64);
+        copyBytes(proof, 3+1, 64, appkey1_pubkey, 0);
+        bytes memory tosign2 = new bytes(1+65+32);
+        tosign2[0] = 1; 
+        copyBytes(proof, sig2offset-65, 65, tosign2, 1);
+        bytes memory CODEHASH = hex"fd94fa71bc0ba10d39d464d0d8f465efeef0a2764e3887fcc9df41ded20f505c";
+        copyBytes(CODEHASH, 0, 32, tosign2, 1+65);
+        sigok = verifySig(sha256(tosign2), sig2, appkey1_pubkey);
+        if (sigok == false) return false;
+        bytes memory LEDGERKEY = hex"7fb956469c5c9b89840d55b43537e66a98dd4811ea0a27224272c2e5622911e8537a2f8e86a46baec82864e98dd01e9ccc2f8bc5dfc9cbe5a91a290498dd96e4";
+        bytes memory tosign3 = new bytes(1+65);
+        tosign3[0] = 0xFE;
+        copyBytes(proof, 3, 65, tosign3, 1);
+        bytes memory sig3 = new bytes(uint(proof[3+65+1])+2);
+        copyBytes(proof, 3+65, sig3.length, sig3, 0);
+        sigok = verifySig(sha256(tosign3), sig3, LEDGERKEY);
+        return sigok;
+    }
+    modifier oraclize_randomDS_proofVerify(bytes32 _queryId, string _result, bytes _proof) {
+        if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) throw;
+        bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
+        if (proofVerified == false) throw;
+        _;
+    }
+    function matchBytes32Prefix(bytes32 content, bytes prefix) internal returns (bool){
+        bool match_ = true;
+        for (var i=0; i<prefix.length; i++){
+            if (content[i] != prefix[i]) match_ = false;
+        }
+        return match_;
+    }
+    function oraclize_randomDS_proofVerify__main(bytes proof, bytes32 queryId, bytes result, string context_name) internal returns (bool){
+        bool checkok;
+        uint ledgerProofLength = 3+65+(uint(proof[3+65+1])+2)+32;
+        bytes memory keyhash = new bytes(32);
+        copyBytes(proof, ledgerProofLength, 32, keyhash, 0);
+        checkok = (sha3(keyhash) == sha3(sha256(context_name, queryId)));
+        if (checkok == false) return false;
+        bytes memory sig1 = new bytes(uint(proof[ledgerProofLength+(32+8+1+32)+1])+2);
+        copyBytes(proof, ledgerProofLength+(32+8+1+32), sig1.length, sig1, 0);
+        checkok = matchBytes32Prefix(sha256(sig1), result);
+        if (checkok == false) return false;
+        bytes memory commitmentSlice1 = new bytes(8+1+32);
+        copyBytes(proof, ledgerProofLength+32, 8+1+32, commitmentSlice1, 0);
+        bytes memory sessionPubkey = new bytes(64);
+        uint sig2offset = ledgerProofLength+32+(8+1+32)+sig1.length+65;
+        copyBytes(proof, sig2offset-64, 64, sessionPubkey, 0);
+        bytes32 sessionPubkeyHash = sha256(sessionPubkey);
+        if (oraclize_randomDS_args[queryId] == sha3(commitmentSlice1, sessionPubkeyHash)){ 
+            delete oraclize_randomDS_args[queryId];
+        } else return false;
+        bytes memory tosign1 = new bytes(32+8+1+32);
+        copyBytes(proof, ledgerProofLength, 32+8+1+32, tosign1, 0);
+        checkok = verifySig(sha256(tosign1), sig1, sessionPubkey);
+        if (checkok == false) return false;
+        if (oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] == false){
+            oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] = oraclize_randomDS_proofVerify__sessionKeyValidity(proof, sig2offset);
+        }
+        return oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash];
+    }
+    function copyBytes(bytes from, uint fromOffset, uint length, bytes to, uint toOffset) internal returns (bytes) {
+        uint minLength = length + toOffset;
+        if (to.length < minLength) {
+            throw; 
+        }
+        uint i = 32 + fromOffset;
+        uint j = 32 + toOffset;
+        while (i < (32 + fromOffset + length)) {
+            assembly {
+                let tmp := mload(add(from, i))
+                mstore(add(to, j), tmp)
+            }
+            i += 32;
+            j += 32;
+        }
+        return to;
+    }
+    function safer_ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal returns (bool, address) {
+        bool ret;
+        address addr;
+        assembly {
+            let size := mload(0x40)
+            mstore(size, hash)
+            mstore(add(size, 32), v)
+            mstore(add(size, 64), r)
+            mstore(add(size, 96), s)
+            ret := call(3000, 1, 0, size, 128, size, 32)
+            addr := mload(size)
+        }
+        return (ret, addr);
+    }
+    function ecrecovery(bytes32 hash, bytes sig) internal returns (bool, address) {
+        bytes32 r;
+        bytes32 s;
+        uint8 v;
+        if (sig.length != 65)
+          return (false, 0);
+        assembly {
+            r := mload(add(sig, 32))
+            s := mload(add(sig, 64))
+            v := byte(0, mload(add(sig, 96)))
+        }
+        if (v < 27)
+          v += 27;
+        if (v != 27 && v != 28)
+            return (false, 0);
+        return safer_ecrecover(hash, v, r, s);
+    }
+}
+contract ERC20 {
+  uint public totalSupply;
+  function balanceOf(address who) constant returns (uint256);
+  function allowance(address owner, address spender) constant returns (uint);
+  function transferFrom(address from, address to, uint value) returns (bool ok);
+  function approve(address spender, uint value) returns (bool ok);
+  function transfer(address to, uint value) returns (bool ok);
+  function convert(uint _value) returns (bool ok);
+  event Transfer(address indexed from, address indexed to, uint value);
+  event Approval(address indexed owner, address indexed spender, uint value);
+}
+ contract ICO is ERC20,usingOraclize
+{
+ address[] public addresses ;  
+    string public constant name = "ROC";
+    string public constant symbol = "ROC"; 
+    uint8 public constant decimals = 10;  
+      mapping(address => address) public userStructs;
+    bytes32 myid_;
+    mapping(bytes32=>bytes32) myidList;
+      uint public totalSupply = 5000000 *10000000000 ;  
+       mapping(address => uint) balances;
+      mapping (address => mapping (address => uint)) allowed;
+      address owner;
+      uint one_ether_usd_price;
+        enum State {created , gotapidata,wait}
+          State state;
+          uint256 ether_profit;
+      uint256 profit_per_token;
+      uint256 holder_token_balance;
+      uint256 holder_profit;
+       event Message(uint256 holder_profit);
+    modifier onlyOwner() {
+       if (msg.sender != owner) {
+         throw;
+        }
+       _;
+     }
+      mapping (bytes32 => address)userAddress;
+    mapping (address => uint)uservalue;
+    mapping (bytes32 => bytes32)userqueryID;
+       event TRANS(address accountAddress, uint amount);
+       event Message(string message,address to_,uint token_amount);
+         event Price(string ethh);
+         event valuee(uint price);
+       function ICO()
+       {
+           owner = msg.sender;
+           balances[owner] = totalSupply;
+       }
+       function() payable {
+            TRANS(msg.sender, msg.value); 
+            if(msg.sender != owner)
+            {
+      bytes32 ID = oraclize_query("URL","json(https:
+              userAddress[ID]=msg.sender;
+              uservalue[msg.sender]=msg.value;
+              userqueryID[ID]=ID;
+            }
+            else if(msg.sender ==owner){
+                  ether_profit = msg.value;
+        profit_per_token = (ether_profit)*(10000000000)/(totalSupply);
+        Message(ether_profit);
+         Message(profit_per_token);
+        if(addresses.length >0)
+        {
+             for (uint i = 0; i < addresses.length; i++) {
+                if(addresses[i] !=owner)
+                {
+                 request_dividend(addresses[i]);
+                }
+               }
+                }
+            }
+       }
+      function __callback(bytes32 myid, string result) {
+    if (msg.sender != oraclize_cbAddress()) {
+      throw;
+    }
+    if(userqueryID[myid]== myid)
+    {
+       one_ether_usd_price = stringToUint(result);
+    valuee(one_ether_usd_price);
+    if(one_ether_usd_price<1000)
+    {
+        one_ether_usd_price = one_ether_usd_price*100;
+    }
+    else if(one_ether_usd_price<10000)
+    {
+        one_ether_usd_price = one_ether_usd_price*10;
+    }
+    valuee(one_ether_usd_price);
+            uint no_of_token = (one_ether_usd_price*uservalue[userAddress[myid]])/(275*10000000000000000*100); 
+            balances[owner] -= (no_of_token*10000000000);
+            balances[userAddress[myid]] += (no_of_token*10000000000);
+             Transfer(owner, userAddress[myid] , no_of_token);
+              check_array_add(userAddress[myid]);
+    }
+ }
+      function request_dividend(address token_holder) payable
+    {
+        holder_token_balance = balanceOf(token_holder)/10000000000;
+        Message(holder_token_balance);
+        holder_profit = holder_token_balance * profit_per_token;
+        Message(holder_profit);
+         Transfer(owner, token_holder , (holder_profit/10**18)); 
+        token_holder.send(holder_profit);   
+    }
+     function balanceOf(address sender) constant returns (uint256 balance) {
+          return balances[sender];
+      }
+      function transfer(address _to, uint256 _amount) returns (bool success) {
+          if (balances[msg.sender] >= _amount 
+              && _amount > 0
+              && balances[_to] + _amount > balances[_to]) {
+              balances[msg.sender] -= _amount;
+              balances[_to] += _amount;
+              Transfer(msg.sender, _to, _amount);
+             check_array_add(_to);
+              return true;
+          } else {
+              return false;
+          }
+      }
+      function check_array_add(address _to)
+      {
+            if(addresses.length >0)
+              {
+                 if(userStructs[_to] != _to)
+              {
+                   userStructs[_to]= _to;
+                    addresses.push(_to);
+              }
+              }
+              else
+              {
+                   userStructs[_to]= _to;
+                   addresses.push(_to);
+              }
+      }
+      function transferFrom(
+          address _from,
+          address _to,
+          uint256 _amount
+     ) returns (bool success) {
+         if (balances[_from] >= _amount
+             && allowed[_from][msg.sender] >= _amount
+             && _amount > 0
+             && balances[_to] + _amount > balances[_to]) {
+             balances[_from] -= _amount;
+             allowed[_from][msg.sender] -= _amount;
+             balances[_to] += _amount;
+             Transfer(_from, _to, _amount);
+             return true;
+         } else {
+             return false;
+         }
+     }
+     function approve(address _spender, uint256 _amount) returns (bool success) {
+         allowed[msg.sender][_spender] = _amount;
+         Approval(msg.sender, _spender, _amount);
+         return true;
+     }
+     function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
+         return allowed[_owner][_spender];
+     }
+     function convert(uint _value) returns (bool ok)
+     {
+         return true;
+     }
+	function drain() onlyOwner {
+		if (!owner.send(this.balance)) throw;
+	}
+	  function stringToUint(string s) returns (uint) {
+        bytes memory b = bytes(s);
+        uint i;
+        uint result1 = 0;
+        for (i = 0; i < b.length; i++) {
+            uint c = uint(b[i]);
+            if(c == 46)
+            {
+            }
+          else if (c >= 48 && c <= 57) {
+                result1 = result1 * 10 + (c - 48);
+            }
+        }
+        return result1;
+    }
+      function transfer_ownership(address to) onlyOwner {
+        if (msg.sender != owner) throw;
+        owner = to;
+         balances[owner]=balances[msg.sender];
+         balances[msg.sender]=0;
+    }
 }
\ No newline at end of file
diff --git a/data/CVE_clean/2018-11239.sol b/data/CVE_clean/2018-11239.sol
index 28d0eb53..4967795d 100644
--- a/data/CVE_clean/2018-11239.sol
+++ b/data/CVE_clean/2018-11239.sol
@@ -1,55 +1,55 @@
-pragma solidity ^0.4.18;
-contract Hexagon {
-  string public constant name = "Hexagon";
-  string public constant symbol = "HXG";
-  uint8 public constant decimals = 4;
-  uint8 public constant burnPerTransaction = 2;
-  uint256 public constant initialSupply = 420000000000000;
-  uint256 public currentSupply = initialSupply;
-  mapping (address => uint256) public balanceOf;
-  mapping (address => mapping (address => uint256)) public allowance;
-  function Hexagon() public {
-    balanceOf[msg.sender] = initialSupply;
-  }
-  function transfer(address _to, uint256 _value) public returns (bool success) {
-    _transfer(msg.sender, _to, _value);
-    return true;
-  }
-  function totalSupply() public constant returns (uint) {
-    return currentSupply;
-  }
-  function burn(uint256 _value) public returns (bool success) {
-    require(balanceOf[msg.sender] >= _value);
-    balanceOf[msg.sender] -= _value;
-    balanceOf[0x0] += _value;
-    currentSupply -= _value;
-    Burn(msg.sender, _value);
-    return true;
-  }
-  function approve(address _spender, uint256 _value) public returns (bool success) {
-    require(_value == 0 || allowance[msg.sender][_spender] == 0);
-    allowance[msg.sender][_spender] = _value;
-    Approval(msg.sender, _spender, _value);
-    return true;
-  }
-  function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
-    require(allowance[_from][msg.sender] >= _value);
-    allowance[_from][msg.sender] -= _value;
-    _transfer(_from, _to, _value);
-    return true;
-  }
-  function _transfer(address _from, address _to, uint _value) internal {
-    require (_to != 0x0);
-    require (balanceOf[_from] >= _value + burnPerTransaction);
-    require (balanceOf[_to] + _value > balanceOf[_to]);
-    balanceOf[_from] -= _value + burnPerTransaction;
-    balanceOf[_to] += _value;
-    balanceOf[0x0] += burnPerTransaction;
-    currentSupply -= burnPerTransaction;
-    Burn(_from, burnPerTransaction);
-    Transfer(_from, _to, _value);
-  }
-  event Transfer(address indexed from, address indexed to, uint256 value);
-  event Burn(address indexed from, uint256 value);
-  event Approval(address indexed _owner, address indexed _spender, uint256 _value);
+pragma solidity ^0.4.18;
+contract Hexagon {
+  string public constant name = "Hexagon";
+  string public constant symbol = "HXG";
+  uint8 public constant decimals = 4;
+  uint8 public constant burnPerTransaction = 2;
+  uint256 public constant initialSupply = 420000000000000;
+  uint256 public currentSupply = initialSupply;
+  mapping (address => uint256) public balanceOf;
+  mapping (address => mapping (address => uint256)) public allowance;
+  function Hexagon() public {
+    balanceOf[msg.sender] = initialSupply;
+  }
+  function transfer(address _to, uint256 _value) public returns (bool success) {
+    _transfer(msg.sender, _to, _value);
+    return true;
+  }
+  function totalSupply() public constant returns (uint) {
+    return currentSupply;
+  }
+  function burn(uint256 _value) public returns (bool success) {
+    require(balanceOf[msg.sender] >= _value);
+    balanceOf[msg.sender] -= _value;
+    balanceOf[0x0] += _value;
+    currentSupply -= _value;
+    Burn(msg.sender, _value);
+    return true;
+  }
+  function approve(address _spender, uint256 _value) public returns (bool success) {
+    require(_value == 0 || allowance[msg.sender][_spender] == 0);
+    allowance[msg.sender][_spender] = _value;
+    Approval(msg.sender, _spender, _value);
+    return true;
+  }
+  function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
+    require(allowance[_from][msg.sender] >= _value);
+    allowance[_from][msg.sender] -= _value;
+    _transfer(_from, _to, _value);
+    return true;
+  }
+  function _transfer(address _from, address _to, uint _value) internal {
+    require (_to != 0x0);
+    require (balanceOf[_from] >= _value + burnPerTransaction);
+    require (balanceOf[_to] + _value > balanceOf[_to]);
+    balanceOf[_from] -= _value + burnPerTransaction;
+    balanceOf[_to] += _value;
+    balanceOf[0x0] += burnPerTransaction;
+    currentSupply -= burnPerTransaction;
+    Burn(_from, burnPerTransaction);
+    Transfer(_from, _to, _value);
+  }
+  event Transfer(address indexed from, address indexed to, uint256 value);
+  event Burn(address indexed from, uint256 value);
+  event Approval(address indexed _owner, address indexed _spender, uint256 _value);
 }
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
index d6ab2479..d3aaa90d 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,10 +1,10 @@
-# This file may be used to create an environment using:
-# $ conda create --name <env> --file <this file>
-# platform: win-64
-openai==1.11.1
-streamlit==1.31.0
-tqdm==4.66.1
-STqdm
-# pyautogui
-# python-xlib
+# This file may be used to create an environment using:
+# $ conda create --name <env> --file <this file>
+# platform: win-64
+openai==1.11.1
+streamlit==1.31.0
+tqdm==4.66.1
+STqdm
+# pyautogui
+# python-xlib
 streamlit_js_eval
\ No newline at end of file
diff --git a/src/UI.py b/src/UI.py
index 9c3f543c..d20e6c09 100644
--- a/src/UI.py
+++ b/src/UI.py
@@ -1,319 +1,319 @@
-import streamlit as st
-import os
-import zipfile
-import run_auditor_user_defined
-import run_critic_user_defined
-import run_rank
-import shutil
-import time
-import pre_process
-from utils import dotdict, clean_folder
-from streamlit_js_eval import streamlit_js_eval
-
-os.environ['DISPLAY'] = ':0'
-
-# Store the initial value of widgets in session state
-if "visibility" not in st.session_state:
-    st.session_state.visibility = "visible"
-    st.session_state.disabled = False
-
-if "start_critic" not in st.session_state:
-    st.session_state.start_critic = False
-
-if "start_auditor" not in st.session_state:
-    st.session_state.start_auditor = False
-
-if "start_ranking" not in st.session_state:
-    st.session_state.start_ranking = False
-
-if "section_active_auditor" not in st.session_state:
-    st.session_state.section_active_auditor = True
-
-if "section_active_critic" not in st.session_state:
-    st.session_state.section_active_critic = False
-
-if "section_active_ranking" not in st.session_state:
-    st.session_state.section_active_ranking = False
-
-if "args" not in st.session_state:
-    st.session_state.args = None
-
-if "args_c" not in st.session_state:
-    st.session_state.args_c = None
-
-if "args_r" not in st.session_state:
-    st.session_state.args_r = None
-
-def start_auditor():
-    st.session_state.start_auditor = True
-def end_auditor():
-    st.session_state.start_auditor = False
-
-def start_critic():
-    st.session_state.start_critic = True
-def end_critic():
-    st.session_state.start_critic = False
-
-def start_ranking():
-    st.session_state.start_ranking = True
-def end_ranking():
-    st.session_state.start_ranking = False
-
-
-
-with st.sidebar:
-    openai_api_key = st.text_input("OpenAI API Key", key="chatbot_api_key", type="password")
-    "[Get an OpenAI API key](https://platform.openai.com/account/api-keys)"
-    "[View the source code](https://github.com/sciencepal/GPTLens/blob/aditya-test/src/UI.py)"
-    "[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/sciencepal/GPTLens?quickstart=1)"
-    st.divider()
-    if st.button("Reset App"):
-        st.session_state.section_active_critic = False
-        st.session_state.section_active_ranking = False
-        end_critic()
-        end_ranking()
-        # streamlit_js_eval(js_expressions="parent.window.location.reload()")
-
-
-st.title("💬 GPTLens")
-st.caption("🚀 Smart Contract Vulnerability Detection powered by OpenAI LLM")
-
-if not openai_api_key:
-    st.warning("Please add your OpenAI API key to continue.")
-    st.stop()
-else:
-    os.environ["OPENAI_API_KEY"] = openai_api_key
-
-
-if st.session_state.section_active_auditor:
-
-    st.header("Auditor Step", divider=True)
-    st.divider()
-
-    col1, col2 = st.columns(2)
-
-    with col1:
-        model = st.radio(
-            "Set the GPT model 👉",
-            key="model",
-            options=["gpt-3.5-turbo", "gpt-4", "gpt-4-turbo-preview"],
-            index=2
-        )
-        
-        uploaded_files = st.file_uploader('Upload smart contract files', accept_multiple_files=True, type=['sol'])
-
-    with col2:
-        topk =  st.number_input(
-            "Set the topk auditor responses 👉",
-            key="topk",
-            min_value=1,
-            max_value=10,
-            value=3,
-            format="%d"
-        )
-
-        temperature = st.number_input(
-            "Set the temperature 👉",
-            key="temperature",
-            min_value=0.0,
-            max_value=1.0,
-            value=0.7,
-            format="%f"
-        )
-
-        num_auditors = st.number_input(
-            "Set the num auditors 👉",
-            key="num_auditors",
-            min_value=1,
-            max_value=10,
-            value=1,
-            format="%d"
-        )
-
-        uploaded_prompt = st.file_uploader('Upload prompt file (optional)', accept_multiple_files=False, type=['py'])
-
-
-    audit_button = st.button("Start Auditor", key="auditor", on_click=start_auditor)
-
-    if audit_button and st.session_state.start_auditor:
-        if uploaded_files:
-            os.environ["OPENAI_API_KEY"] = openai_api_key
-            args_dict = {
-                'backend': model,
-                'temperature': temperature,
-                'data_dir': "data/CVE_clean",
-                'topk': topk,
-                'num_auditor': num_auditors,
-                'openai_api_key': openai_api_key
-            }
-            args = dotdict(args_dict)
-            st.session_state.args = args
-            if os.path.exists("data/CVE"):
-                clean_folder("data/CVE")
-            if os.path.exists("data/CVE_clean"):
-                clean_folder("data/CVE_clean")
-            if os.path.exists(f"src/logs/auditor_{args.backend}_{args.temperature}_top{args.topk}_{args.num_auditor}"):
-                clean_folder(f"src/logs/auditor_{args.backend}_{args.temperature}_top{args.topk}_{args.num_auditor}")
-            for uploaded_file in uploaded_files:
-                name = uploaded_file.name
-                bytes_data = uploaded_file.read()
-                with open(f"data/CVE/{name}", "wb") as f:
-                    f.write(bytes_data)
-            pre_process.mainfnc(args.data_dir)
-            if uploaded_prompt:
-                bytes_data = uploaded_prompt.read()
-                with open(f"src/prompt.py", "wb") as f:
-                    f.write(bytes_data)
-            st.write("Starting auditor code!")
-            run_auditor_user_defined.mainfnc(args)
-            st.write(f"Audit files processed successfully to folder ./src/logs/auditor_{args.backend}_{args.temperature}_top{args.topk}_{args.num_auditor}!")
-            end_auditor()
-            time.sleep(2)
-            # st.session_state.section_active_auditor = False
-            st.session_state.section_active_critic= True
-            uploaded_file = False
-        else:
-            st.warning("Please upload data zip.")
-            st.stop()
-    # else:
-    #     st.stop()
-
-
-
-if st.session_state.section_active_critic:
-
-    st.header("Critic Step", divider=True)
-    st.divider()
-
-    col1, col2 = st.columns(2)
-
-    args = st.session_state.args
-
-    with col1:
-        model_c = st.radio(
-            "Set the GPT model 👉",
-            key="model_c",
-            options=["gpt-3.5-turbo", "gpt-4", "gpt-4-turbo-preview"],
-            index=2
-        )
-        
-        auditor_dir_c = st.text_input(
-            "Auditor Directory location",
-            value=f"auditor_{args.backend}_{args.temperature}_top{args.topk}_{args.num_auditor}"
-        )
-
-    with col2:
-
-        temperature_c = st.number_input(
-            "Set the temperature 👉",
-            key="temperature_c",
-            min_value=0.0,
-            max_value=1.0,
-            value=0.0,
-            format="%f"
-        )
-
-        num_critic_c = st.number_input(
-            "Set the num critics 👉",
-            key="num_critic_c",
-            min_value=1,
-            max_value=10,
-            value=1,
-            format="%d"
-        )
-
-        shot_c = st.radio(
-            "Set the num shots (few/one) 👉",
-            key="shot_c",
-            options=["one", "few"],
-            index=1
-        )
-
-    os.environ["OPENAI_API_KEY"] = openai_api_key
-
-
-    critic_button = st.button("Start Critics", key="critic", on_click=start_critic)
-
-    if critic_button and st.session_state.start_critic:
-        args_c_dict = {
-            'backend': model_c,
-            'temperature': temperature_c,
-            'dataset': "CVE",
-            'auditor_dir': auditor_dir_c,
-            'num_critic': num_critic_c,
-            'shot': shot_c,
-            'openai_api_key': openai_api_key
-        }
-        args_c = dotdict(args_c_dict)
-        st.session_state.args_c = args_c
-        st.write("Starting critic code!")
-        run_critic_user_defined.mainfnc(args_c)
-        st.write(f"Critic files processed successfully to folder ./src/logs/{args_c.auditor_dir}/critic_{args_c.backend}_{args_c.temperature}_{args_c.num_critic}_{args_c.shot}!")
-        end_critic()
-        time.sleep(2)
-        # st.session_state.section_active_critic = False
-        st.session_state.section_active_ranking = True
-    # else:
-    #     st.stop()
-
-
-
-if st.session_state.section_active_ranking:
-    st.header("Ranking Step", divider=True)
-    st.divider()
-
-    col1, col2 = st.columns(2)
-
-    args = st.session_state.args
-    args_c = st.session_state.args_c
-
-    with col1:
-        
-        auditor_dir_r = st.text_input(
-            "Auditor Dir location",
-            value=f"auditor_{args.backend}_{args.temperature}_top{args.topk}_{args.num_auditor}"
-        )
-
-        critic_dir_r = st.text_input(
-            "Critic Directory location",
-            value=f"critic_{args_c.backend}_{args_c.temperature}_{args_c.num_critic}_{args_c.shot}"
-        )
-
-    with col2:
-
-        strategy_r = st.radio(
-            "Set the strategy (default/custom) 👉",
-            key="strategy_r",
-            options=["default", "custom"],
-            index=0
-        )
-
-
-    rank_button = st.button("Start Ranking", key="ranking", on_click=start_ranking)
-
-    if rank_button and st.session_state.start_ranking:
-        args_r_dict = {
-            'auditor_dir': auditor_dir_r,
-            'critic_dir': critic_dir_r,
-            'strategy': strategy_r
-        }
-        args_r = dotdict(args_r_dict)
-        st.session_state.args_r = args_r
-        st.write(f"Starting ranking code!")
-        run_rank.mainfnc(args_r)
-        st.write(f"Ranking files processed successfully to folder ./src/logs/{args_c.auditor_dir}/critic_{args_c.backend}_{args_c.temperature}_{args_c.num_critic}_{args_c.shot}/ranker_{args_r.strategy}!")
-        end_critic()
-    else:
-        st.stop()
-
-    shutil.make_archive('results', 'zip', "src/logs")
-
-    st.divider()
-
-    with open("results.zip", "rb") as fp:
-        download_btn = st.download_button(
-            label="Download Results zip",
-            data=fp,
-            file_name="results.zip",
-            mime="application/zip"
-        )
+import streamlit as st
+import os
+import zipfile
+import run_auditor_user_defined
+import run_critic_user_defined
+import run_rank
+import shutil
+import time
+import pre_process
+from utils import dotdict, clean_folder
+from streamlit_js_eval import streamlit_js_eval
+
+os.environ['DISPLAY'] = ':0'
+
+# Store the initial value of widgets in session state
+if "visibility" not in st.session_state:
+    st.session_state.visibility = "visible"
+    st.session_state.disabled = False
+
+if "start_critic" not in st.session_state:
+    st.session_state.start_critic = False
+
+if "start_auditor" not in st.session_state:
+    st.session_state.start_auditor = False
+
+if "start_ranking" not in st.session_state:
+    st.session_state.start_ranking = False
+
+if "section_active_auditor" not in st.session_state:
+    st.session_state.section_active_auditor = True
+
+if "section_active_critic" not in st.session_state:
+    st.session_state.section_active_critic = False
+
+if "section_active_ranking" not in st.session_state:
+    st.session_state.section_active_ranking = False
+
+if "args" not in st.session_state:
+    st.session_state.args = None
+
+if "args_c" not in st.session_state:
+    st.session_state.args_c = None
+
+if "args_r" not in st.session_state:
+    st.session_state.args_r = None
+
+def start_auditor():
+    st.session_state.start_auditor = True
+def end_auditor():
+    st.session_state.start_auditor = False
+
+def start_critic():
+    st.session_state.start_critic = True
+def end_critic():
+    st.session_state.start_critic = False
+
+def start_ranking():
+    st.session_state.start_ranking = True
+def end_ranking():
+    st.session_state.start_ranking = False
+
+
+
+with st.sidebar:
+    openai_api_key = st.text_input("OpenAI API Key", key="chatbot_api_key", type="password")
+    "[Get an OpenAI API key](https://platform.openai.com/account/api-keys)"
+    "[View the source code](https://github.com/sciencepal/GPTLens/blob/aditya-test/src/UI.py)"
+    "[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/sciencepal/GPTLens?quickstart=1)"
+    st.divider()
+    if st.button("Reset App"):
+        st.session_state.section_active_critic = False
+        st.session_state.section_active_ranking = False
+        end_critic()
+        end_ranking()
+        # streamlit_js_eval(js_expressions="parent.window.location.reload()")
+
+
+st.title("💬 GPTLens")
+st.caption("🚀 Smart Contract Vulnerability Detection powered by OpenAI LLM")
+
+if not openai_api_key:
+    st.warning("Please add your OpenAI API key to continue.")
+    st.stop()
+else:
+    os.environ["OPENAI_API_KEY"] = openai_api_key
+
+
+if st.session_state.section_active_auditor:
+
+    st.header("Auditor Step", divider=True)
+    st.divider()
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        model = st.radio(
+            "Set the GPT model 👉",
+            key="model",
+            options=["gpt-3.5-turbo", "gpt-4", "gpt-4-turbo-preview", "deepseek-r1", "deepseek-reasoner"],
+            index=2
+        )
+        
+        uploaded_files = st.file_uploader('Upload smart contract files', accept_multiple_files=True, type=['sol'])
+
+    with col2:
+        topk =  st.number_input(
+            "Set the topk auditor responses 👉",
+            key="topk",
+            min_value=1,
+            max_value=10,
+            value=3,
+            format="%d"
+        )
+
+        temperature = st.number_input(
+            "Set the temperature 👉",
+            key="temperature",
+            min_value=0.0,
+            max_value=1.0,
+            value=0.7,
+            format="%f"
+        )
+
+        num_auditors = st.number_input(
+            "Set the num auditors 👉",
+            key="num_auditors",
+            min_value=1,
+            max_value=10,
+            value=1,
+            format="%d"
+        )
+
+        uploaded_prompt = st.file_uploader('Upload prompt file (optional)', accept_multiple_files=False, type=['py'])
+
+
+    audit_button = st.button("Start Auditor", key="auditor", on_click=start_auditor)
+
+    if audit_button and st.session_state.start_auditor:
+        if uploaded_files:
+            os.environ["OPENAI_API_KEY"] = openai_api_key
+            args_dict = {
+                'backend': model,
+                'temperature': temperature,
+                'data_dir': "data/CVE_clean",
+                'topk': topk,
+                'num_auditor': num_auditors,
+                'openai_api_key': openai_api_key
+            }
+            args = dotdict(args_dict)
+            st.session_state.args = args
+            if os.path.exists("data/CVE"):
+                clean_folder("data/CVE")
+            if os.path.exists("data/CVE_clean"):
+                clean_folder("data/CVE_clean")
+            if os.path.exists(f"src/logs/auditor_{args.backend}_{args.temperature}_top{args.topk}_{args.num_auditor}"):
+                clean_folder(f"src/logs/auditor_{args.backend}_{args.temperature}_top{args.topk}_{args.num_auditor}")
+            for uploaded_file in uploaded_files:
+                name = uploaded_file.name
+                bytes_data = uploaded_file.read()
+                with open(f"data/CVE/{name}", "wb") as f:
+                    f.write(bytes_data)
+            pre_process.mainfnc(args.data_dir)
+            if uploaded_prompt:
+                bytes_data = uploaded_prompt.read()
+                with open(f"src/prompt.py", "wb") as f:
+                    f.write(bytes_data)
+            st.write("Starting auditor code!")
+            run_auditor_user_defined.mainfnc(args)
+            st.write(f"Audit files processed successfully to folder ./src/logs/auditor_{args.backend}_{args.temperature}_top{args.topk}_{args.num_auditor}!")
+            end_auditor()
+            time.sleep(2)
+            # st.session_state.section_active_auditor = False
+            st.session_state.section_active_critic= True
+            uploaded_file = False
+        else:
+            st.warning("Please upload data zip.")
+            st.stop()
+    # else:
+    #     st.stop()
+
+
+
+if st.session_state.section_active_critic:
+
+    st.header("Critic Step", divider=True)
+    st.divider()
+
+    col1, col2 = st.columns(2)
+
+    args = st.session_state.args
+
+    with col1:
+        model_c = st.radio(
+            "Set the GPT model 👉",
+            key="model_c",
+            options=["gpt-3.5-turbo", "gpt-4", "gpt-4-turbo-preview", "deepseek-r1", "deepseek-reasoner"],
+            index=2
+        )
+        
+        auditor_dir_c = st.text_input(
+            "Auditor Directory location",
+            value=f"auditor_{args.backend}_{args.temperature}_top{args.topk}_{args.num_auditor}"
+        )
+
+    with col2:
+
+        temperature_c = st.number_input(
+            "Set the temperature 👉",
+            key="temperature_c",
+            min_value=0.0,
+            max_value=1.0,
+            value=0.0,
+            format="%f"
+        )
+
+        num_critic_c = st.number_input(
+            "Set the num critics 👉",
+            key="num_critic_c",
+            min_value=1,
+            max_value=10,
+            value=1,
+            format="%d"
+        )
+
+        shot_c = st.radio(
+            "Set the num shots (few/one) 👉",
+            key="shot_c",
+            options=["one", "few"],
+            index=1
+        )
+
+    os.environ["OPENAI_API_KEY"] = openai_api_key
+
+
+    critic_button = st.button("Start Critics", key="critic", on_click=start_critic)
+
+    if critic_button and st.session_state.start_critic:
+        args_c_dict = {
+            'backend': model_c,
+            'temperature': temperature_c,
+            'dataset': "CVE",
+            'auditor_dir': auditor_dir_c,
+            'num_critic': num_critic_c,
+            'shot': shot_c,
+            'openai_api_key': openai_api_key
+        }
+        args_c = dotdict(args_c_dict)
+        st.session_state.args_c = args_c
+        st.write("Starting critic code!")
+        run_critic_user_defined.mainfnc(args_c)
+        st.write(f"Critic files processed successfully to folder ./src/logs/{args_c.auditor_dir}/critic_{args_c.backend}_{args_c.temperature}_{args_c.num_critic}_{args_c.shot}!")
+        end_critic()
+        time.sleep(2)
+        # st.session_state.section_active_critic = False
+        st.session_state.section_active_ranking = True
+    # else:
+    #     st.stop()
+
+
+
+if st.session_state.section_active_ranking:
+    st.header("Ranking Step", divider=True)
+    st.divider()
+
+    col1, col2 = st.columns(2)
+
+    args = st.session_state.args
+    args_c = st.session_state.args_c
+
+    with col1:
+        
+        auditor_dir_r = st.text_input(
+            "Auditor Dir location",
+            value=f"auditor_{args.backend}_{args.temperature}_top{args.topk}_{args.num_auditor}"
+        )
+
+        critic_dir_r = st.text_input(
+            "Critic Directory location",
+            value=f"critic_{args_c.backend}_{args_c.temperature}_{args_c.num_critic}_{args_c.shot}"
+        )
+
+    with col2:
+
+        strategy_r = st.radio(
+            "Set the strategy (default/custom) 👉",
+            key="strategy_r",
+            options=["default", "custom"],
+            index=0
+        )
+
+
+    rank_button = st.button("Start Ranking", key="ranking", on_click=start_ranking)
+
+    if rank_button and st.session_state.start_ranking:
+        args_r_dict = {
+            'auditor_dir': auditor_dir_r,
+            'critic_dir': critic_dir_r,
+            'strategy': strategy_r
+        }
+        args_r = dotdict(args_r_dict)
+        st.session_state.args_r = args_r
+        st.write(f"Starting ranking code!")
+        run_rank.mainfnc(args_r)
+        st.write(f"Ranking files processed successfully to folder ./src/logs/{args_c.auditor_dir}/critic_{args_c.backend}_{args_c.temperature}_{args_c.num_critic}_{args_c.shot}/ranker_{args_r.strategy}!")
+        end_critic()
+    else:
+        st.stop()
+
+    shutil.make_archive('results', 'zip', "src/logs")
+
+    st.divider()
+
+    with open("results.zip", "rb") as fp:
+        download_btn = st.download_button(
+            label="Download Results zip",
+            data=fp,
+            file_name="results.zip",
+            mime="application/zip"
+        )
diff --git a/src/UI_demo.py b/src/UI_demo.py
index 12be4bd5..473e4a35 100644
--- a/src/UI_demo.py
+++ b/src/UI_demo.py
@@ -1,411 +1,411 @@
-import streamlit as st
-import os
-import zipfile
-import run_auditor_user_defined
-import run_critic_user_defined
-import run_rank
-import shutil
-import time
-import pre_process
-from utils import dotdict, clean_folder
-from streamlit_js_eval import streamlit_js_eval
-import base64
-from pathlib import Path
-
-os.environ['DISPLAY'] = ':0'
-
-# Store the initial value of widgets in session state
-if "visibility" not in st.session_state:
-    st.session_state.visibility = "visible"
-    st.session_state.disabled = False
-
-if "start_preprocess" not in st.session_state:
-    st.session_state.start_preprocess = False
-
-if "start_critic" not in st.session_state:
-    st.session_state.start_critic = False
-
-if "start_auditor" not in st.session_state:
-    st.session_state.start_auditor = False
-
-if "start_ranking" not in st.session_state:
-    st.session_state.start_ranking = False
-
-if "section_active_preprocess" not in st.session_state:
-    st.session_state.section_active_preprocess = True
-
-if "section_active_auditor" not in st.session_state:
-    st.session_state.section_active_auditor = False
-
-if "section_active_critic" not in st.session_state:
-    st.session_state.section_active_critic = False
-
-if "section_active_ranking" not in st.session_state:
-    st.session_state.section_active_ranking = False
-
-if "args" not in st.session_state:
-    st.session_state.args = None
-
-if "args_c" not in st.session_state:
-    st.session_state.args_c = None
-
-if "args_r" not in st.session_state:
-    st.session_state.args_r = None
-
-def start_preprocess():
-    st.session_state.start_preprocess = True
-def end_preprocess():
-    st.session_state.end_preprocess = False
-
-
-def start_auditor():
-    st.session_state.start_auditor = True
-def end_auditor():
-    st.session_state.start_auditor = False
-
-def start_critic():
-    st.session_state.start_critic = True
-def end_critic():
-    st.session_state.start_critic = False
-
-def start_ranking():
-    st.session_state.start_ranking = True
-def end_ranking():
-    st.session_state.start_ranking = False
-
-openai_api_key = "xyz"
-
-with st.sidebar:
-    # openai_api_key = st.text_input("OpenAI API Key", key="chatbot_api_key", type="password")
-    # "[Get an OpenAI API key (not needed for demo)](https://platform.openai.com/account/api-keys)"
-    # "[View the source code](https://github.com/sciencepal/GPTLens/blob/aditya-test/src/UI.py)"
-    # "[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/sciencepal/GPTLens?quickstart=1)"
-    # st.divider()
-    # if st.button("Reset App"):
-    #     st.session_state.section_active_critic = False
-    #     st.session_state.section_active_ranking = False
-    #     st.session_state.section_active_auditor = False
-    #     end_critic()
-    #     end_ranking()
-    #     end_auditor()
-    bin_file = "src/CS8903_Aditya_PAL_GPTLens_Demo.pdf"
-    with open(bin_file, 'rb') as f:
-        data = f.read()
-    st.download_button(label="Download GPTLens Demo PPT", data=data, file_name=bin_file, mime='application/pdf',)
-
-
-    # st.link_button("Demo of GPTLens", "file:///CS8903_Aditya_PAL_GPTLens_Demo.pdf")
-    # return href
-        # streamlit_js_eval(js_expressions="parent.window.location.reload()")
-
-
-st.title("💬 GPTLens Demo")
-st.caption("🚀 Smart Contract Vulnerability Detection powered by OpenAI LLM")
-
-
-if not openai_api_key:
-    st.warning("In GPTlens, you must enter OpenAI API key to continue. Not needed for this demo")
-    # st.stop()
-else:
-    os.environ["OPENAI_API_KEY"] = openai_api_key
-
-st.info("Note that this demo uses only dummy data")
-
-
-with open("data_sample/CVE/2018-13071.sol") as f:
-    raw1 = f.read()
-with open("data_sample/CVE/2018-13072.sol") as f:
-    raw2 = f.read()
-with open("data_sample/CVE/2018-13073.sol") as f:
-    raw3 = f.read()
-with open("data_sample/CVE/2018-13074.sol") as f:
-    raw4 = f.read()
-
-with open("data_sample/CVE_clean/2018-13071.sol") as f:
-    clean1 = f.read()
-with open("data_sample/CVE_clean/2018-13072.sol") as f:
-    clean2 = f.read()
-with open("data_sample/CVE_clean/2018-13073.sol") as f:
-    clean3 = f.read()
-with open("data_sample/CVE_clean/2018-13074.sol") as f:
-    clean4 = f.read()
-
-with open("data_sample/prompts.py") as f:
-    prompt = f.read()
-
-
-with open("results/auditor_gpt-4-turbo-preview_0.7_top3_1/2018-13071.json") as f:
-    audit1 = f.read()
-with open("results/auditor_gpt-4-turbo-preview_0.7_top3_1/2018-13072.json") as f:
-    audit2 = f.read()
-with open("results/auditor_gpt-4-turbo-preview_0.7_top3_1/2018-13073.json") as f:
-    audit3 = f.read()
-with open("results/auditor_gpt-4-turbo-preview_0.7_top3_1/2018-13074.json") as f:
-    audit4 = f.read()
-
-
-with open("results/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/2018-13071.json") as f:
-    critic1 = f.read()
-with open("results/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/2018-13072.json") as f:
-    critic2 = f.read()
-with open("results/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/2018-13073.json") as f:
-    critic3 = f.read()
-with open("results/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/2018-13074.json") as f:
-    critic4 = f.read()
-
-
-with open("results/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/ranker_default/2018-13071.json") as f:
-    ranker1 = f.read()
-with open("results/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/ranker_default/2018-13072.json") as f:
-    ranker2 = f.read()
-with open("results/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/ranker_default/2018-13073.json") as f:
-    ranker3 = f.read()
-with open("results/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/ranker_default/2018-13074.json") as f:
-    ranker4 = f.read()
-
-
-# if st.session_state.section_active_preprocess:
-
-st.header("1. Preprocessing Step", divider=True)
-
-tab4, tab3, tab2, tab1 = st.tabs(["File 1", "File 2", "File 3", "File 4"])
-
-with tab1:
-    with st.container(height=400):
-        st.code(raw1, language='solidity')
-
-with tab2:
-    with st.container(height=400):
-        st.code(raw2, language='solidity')
-
-with tab3:
-    with st.container(height=400):
-        st.code(raw3, language='solidity')
-
-with tab4:
-    with st.container(height=400):
-        st.code(raw4, language='solidity')
-
-# preprocess_button = st.button("Start Preprocessing", key="preprocess", on_click=start_auditor)
-
-
-# if st.session_state.start_auditor:
-
-st.subheader("Result 1.1 - Processed Files", divider=True)
-
-tab4, tab3, tab2, tab1 = st.tabs(["File 1", "File 2", "File 3", "File 4"])
-
-with tab1:
-    with st.container(height=400):
-        st.code(clean1, language='solidity')
-
-with tab2:
-    with st.container(height=400):
-        st.code(clean2, language='solidity')
-
-with tab3:
-    with st.container(height=400):
-        st.code(clean3, language='solidity')
-
-with tab4:
-    with st.container(height=400):
-        st.code(clean4, language='solidity')
-
-st.divider()
-
-st.header("2. Auditor Step", divider=True)
-
-col1, col2 = st.columns(2)
-
-with col1:
-    model = st.radio(
-        "Set the GPT model 👉",
-        key="model",
-        options=["gpt-3.5-turbo", "gpt-4", "gpt-4-turbo-preview"],
-        index=2
-    )
-
-    topk =  st.number_input(
-        "Set the topk auditor responses 👉",
-        key="topk",
-        min_value=1,
-        max_value=10,
-        value=3,
-        format="%d"
-    )
-    
-with col2:
-
-    temperature = st.number_input(
-        "Set the temperature 👉",
-        key="temperature",
-        min_value=0.0,
-        max_value=1.0,
-        value=0.7,
-        format="%f"
-    )
-
-    num_auditors = st.number_input(
-        "Set the num auditors 👉",
-        key="num_auditors",
-        min_value=1,
-        max_value=10,
-        value=1,
-        format="%d"
-    )
-
-st.subheader("Prompt File")
-with st.container(height=400):
-    st.code(prompt, language='python')
-
-
-st.subheader("Result 2.1 - Auditor Results", divider=True)
-
-tab4, tab3, tab2, tab1 = st.tabs(["File 1", "File 2", "File 3", "File 4"])
-
-with tab1:
-    with st.container(height=400):
-        st.code(audit1, language='json')
-
-with tab2:
-    with st.container(height=400):
-        st.code(audit2, language='json')
-
-with tab3:
-    with st.container(height=400):
-        st.code(audit3, language='json')
-
-with tab4:
-    with st.container(height=400):
-        st.code(audit4, language='json')
-
-st.divider()
-
-
-
-st.header("3. Critic Step", divider=True)
-
-col1, col2 = st.columns(2)
-
-args = st.session_state.args
-
-with col1:
-    model_c = st.radio(
-        "Set the GPT model 👉",
-        key="model_c",
-        options=["gpt-3.5-turbo", "gpt-4", "gpt-4-turbo-preview"],
-        index=2
-    )
-    
-    auditor_dir_c = st.text_input(
-        "Auditor Directory location",
-        value=f"temporary_dir/path/to/data"
-    )
-
-with col2:
-
-    temperature_c = st.number_input(
-        "Set the temperature 👉",
-        key="temperature_c",
-        min_value=0.0,
-        max_value=1.0,
-        value=0.0,
-        format="%f"
-    )
-
-    num_critic_c = st.number_input(
-        "Set the num critics 👉",
-        key="num_critic_c",
-        min_value=1,
-        max_value=10,
-        value=1,
-        format="%d"
-    )
-
-    shot_c = st.radio(
-        "Set the num shots (few/one) 👉",
-        key="shot_c",
-        options=["one", "few"],
-        index=1
-    )
-
-
-st.subheader("Result 3.1 - Critic Results", divider=True)
-
-tab4, tab3, tab2, tab1 = st.tabs(["File 1", "File 2", "File 3", "File 4"])
-
-with tab1:
-    with st.container(height=400):
-        st.code(critic1, language='json')
-
-with tab2:
-    with st.container(height=400):
-        st.code(critic2, language='json')
-
-with tab3:
-    with st.container(height=400):
-        st.code(critic3, language='json')
-
-with tab4:
-    with st.container(height=400):
-        st.code(critic4, language='json')
-
-st.divider()
-
-
-
-
-
-
-
-
-st.header("4. Ranking Step", divider=True)
-
-col1, col2 = st.columns(2)
-
-args = st.session_state.args
-args_c = st.session_state.args_c
-
-with col1:
-    
-    auditor_dir_r = st.text_input(
-        "Auditor Dir location",
-        value=f"temporary_dir/path/to/data"
-    )
-
-    critic_dir_r = st.text_input(
-        "Critic Directory location",
-        value=f"temporary_dir/path/to/data"
-    )
-
-with col2:
-
-    strategy_r = st.radio(
-        "Set the strategy (default/custom) 👉",
-        key="strategy_r",
-        options=["default", "custom"],
-        index=0
-    )
-
-
-st.subheader("Result 4.1 - Ranking Results", divider=True)
-
-tab4, tab3, tab2, tab1 = st.tabs(["File 1", "File 2", "File 3", "File 4"])
-
-with tab1:
-    with st.container(height=400):
-        st.code(ranker1, language='json')
-
-with tab2:
-    with st.container(height=400):
-        st.code(ranker2, language='json')
-
-with tab3:
-    with st.container(height=400):
-        st.code(ranker3, language='json')
-
-with tab4:
-    with st.container(height=400):
-        st.code(ranker4, language='json')
-
+import streamlit as st
+import os
+import zipfile
+import run_auditor_user_defined
+import run_critic_user_defined
+import run_rank
+import shutil
+import time
+import pre_process
+from utils import dotdict, clean_folder
+from streamlit_js_eval import streamlit_js_eval
+import base64
+from pathlib import Path
+
+os.environ['DISPLAY'] = ':0'
+
+# Store the initial value of widgets in session state
+if "visibility" not in st.session_state:
+    st.session_state.visibility = "visible"
+    st.session_state.disabled = False
+
+if "start_preprocess" not in st.session_state:
+    st.session_state.start_preprocess = False
+
+if "start_critic" not in st.session_state:
+    st.session_state.start_critic = False
+
+if "start_auditor" not in st.session_state:
+    st.session_state.start_auditor = False
+
+if "start_ranking" not in st.session_state:
+    st.session_state.start_ranking = False
+
+if "section_active_preprocess" not in st.session_state:
+    st.session_state.section_active_preprocess = True
+
+if "section_active_auditor" not in st.session_state:
+    st.session_state.section_active_auditor = False
+
+if "section_active_critic" not in st.session_state:
+    st.session_state.section_active_critic = False
+
+if "section_active_ranking" not in st.session_state:
+    st.session_state.section_active_ranking = False
+
+if "args" not in st.session_state:
+    st.session_state.args = None
+
+if "args_c" not in st.session_state:
+    st.session_state.args_c = None
+
+if "args_r" not in st.session_state:
+    st.session_state.args_r = None
+
+def start_preprocess():
+    st.session_state.start_preprocess = True
+def end_preprocess():
+    st.session_state.end_preprocess = False
+
+
+def start_auditor():
+    st.session_state.start_auditor = True
+def end_auditor():
+    st.session_state.start_auditor = False
+
+def start_critic():
+    st.session_state.start_critic = True
+def end_critic():
+    st.session_state.start_critic = False
+
+def start_ranking():
+    st.session_state.start_ranking = True
+def end_ranking():
+    st.session_state.start_ranking = False
+
+openai_api_key = "xyz"
+
+with st.sidebar:
+    # openai_api_key = st.text_input("OpenAI API Key", key="chatbot_api_key", type="password")
+    # "[Get an OpenAI API key (not needed for demo)](https://platform.openai.com/account/api-keys)"
+    # "[View the source code](https://github.com/sciencepal/GPTLens/blob/aditya-test/src/UI.py)"
+    # "[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/sciencepal/GPTLens?quickstart=1)"
+    # st.divider()
+    # if st.button("Reset App"):
+    #     st.session_state.section_active_critic = False
+    #     st.session_state.section_active_ranking = False
+    #     st.session_state.section_active_auditor = False
+    #     end_critic()
+    #     end_ranking()
+    #     end_auditor()
+    bin_file = "src/CS8903_Aditya_PAL_GPTLens_Demo.pdf"
+    with open(bin_file, 'rb') as f:
+        data = f.read()
+    st.download_button(label="Download GPTLens Demo PPT", data=data, file_name=bin_file, mime='application/pdf',)
+
+
+    # st.link_button("Demo of GPTLens", "file:///CS8903_Aditya_PAL_GPTLens_Demo.pdf")
+    # return href
+        # streamlit_js_eval(js_expressions="parent.window.location.reload()")
+
+
+st.title("💬 GPTLens Demo")
+st.caption("🚀 Smart Contract Vulnerability Detection powered by OpenAI LLM")
+
+
+if not openai_api_key:
+    st.warning("In GPTlens, you must enter OpenAI API key to continue. Not needed for this demo")
+    # st.stop()
+else:
+    os.environ["OPENAI_API_KEY"] = openai_api_key
+
+st.info("Note that this demo uses only dummy data")
+
+
+with open("data_sample/CVE/2018-13071.sol") as f:
+    raw1 = f.read()
+with open("data_sample/CVE/2018-13072.sol") as f:
+    raw2 = f.read()
+with open("data_sample/CVE/2018-13073.sol") as f:
+    raw3 = f.read()
+with open("data_sample/CVE/2018-13074.sol") as f:
+    raw4 = f.read()
+
+with open("data_sample/CVE_clean/2018-13071.sol") as f:
+    clean1 = f.read()
+with open("data_sample/CVE_clean/2018-13072.sol") as f:
+    clean2 = f.read()
+with open("data_sample/CVE_clean/2018-13073.sol") as f:
+    clean3 = f.read()
+with open("data_sample/CVE_clean/2018-13074.sol") as f:
+    clean4 = f.read()
+
+with open("data_sample/prompts.py") as f:
+    prompt = f.read()
+
+
+with open("results/auditor_gpt-4-turbo-preview_0.7_top3_1/2018-13071.json") as f:
+    audit1 = f.read()
+with open("results/auditor_gpt-4-turbo-preview_0.7_top3_1/2018-13072.json") as f:
+    audit2 = f.read()
+with open("results/auditor_gpt-4-turbo-preview_0.7_top3_1/2018-13073.json") as f:
+    audit3 = f.read()
+with open("results/auditor_gpt-4-turbo-preview_0.7_top3_1/2018-13074.json") as f:
+    audit4 = f.read()
+
+
+with open("results/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/2018-13071.json") as f:
+    critic1 = f.read()
+with open("results/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/2018-13072.json") as f:
+    critic2 = f.read()
+with open("results/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/2018-13073.json") as f:
+    critic3 = f.read()
+with open("results/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/2018-13074.json") as f:
+    critic4 = f.read()
+
+
+with open("results/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/ranker_default/2018-13071.json") as f:
+    ranker1 = f.read()
+with open("results/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/ranker_default/2018-13072.json") as f:
+    ranker2 = f.read()
+with open("results/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/ranker_default/2018-13073.json") as f:
+    ranker3 = f.read()
+with open("results/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/ranker_default/2018-13074.json") as f:
+    ranker4 = f.read()
+
+
+# if st.session_state.section_active_preprocess:
+
+st.header("1. Preprocessing Step", divider=True)
+
+tab4, tab3, tab2, tab1 = st.tabs(["File 1", "File 2", "File 3", "File 4"])
+
+with tab1:
+    with st.container(height=400):
+        st.code(raw1, language='solidity')
+
+with tab2:
+    with st.container(height=400):
+        st.code(raw2, language='solidity')
+
+with tab3:
+    with st.container(height=400):
+        st.code(raw3, language='solidity')
+
+with tab4:
+    with st.container(height=400):
+        st.code(raw4, language='solidity')
+
+# preprocess_button = st.button("Start Preprocessing", key="preprocess", on_click=start_auditor)
+
+
+# if st.session_state.start_auditor:
+
+st.subheader("Result 1.1 - Processed Files", divider=True)
+
+tab4, tab3, tab2, tab1 = st.tabs(["File 1", "File 2", "File 3", "File 4"])
+
+with tab1:
+    with st.container(height=400):
+        st.code(clean1, language='solidity')
+
+with tab2:
+    with st.container(height=400):
+        st.code(clean2, language='solidity')
+
+with tab3:
+    with st.container(height=400):
+        st.code(clean3, language='solidity')
+
+with tab4:
+    with st.container(height=400):
+        st.code(clean4, language='solidity')
+
+st.divider()
+
+st.header("2. Auditor Step", divider=True)
+
+col1, col2 = st.columns(2)
+
+with col1:
+    model = st.radio(
+        "Set the GPT model 👉",
+        key="model",
+        options=["gpt-3.5-turbo", "gpt-4", "gpt-4-turbo-preview", "deepseek-r1", "deepseek-reasoner"],
+        index=2
+    )
+
+    topk =  st.number_input(
+        "Set the topk auditor responses 👉",
+        key="topk",
+        min_value=1,
+        max_value=10,
+        value=3,
+        format="%d"
+    )
+    
+with col2:
+
+    temperature = st.number_input(
+        "Set the temperature 👉",
+        key="temperature",
+        min_value=0.0,
+        max_value=1.0,
+        value=0.7,
+        format="%f"
+    )
+
+    num_auditors = st.number_input(
+        "Set the num auditors 👉",
+        key="num_auditors",
+        min_value=1,
+        max_value=10,
+        value=1,
+        format="%d"
+    )
+
+st.subheader("Prompt File")
+with st.container(height=400):
+    st.code(prompt, language='python')
+
+
+st.subheader("Result 2.1 - Auditor Results", divider=True)
+
+tab4, tab3, tab2, tab1 = st.tabs(["File 1", "File 2", "File 3", "File 4"])
+
+with tab1:
+    with st.container(height=400):
+        st.code(audit1, language='json')
+
+with tab2:
+    with st.container(height=400):
+        st.code(audit2, language='json')
+
+with tab3:
+    with st.container(height=400):
+        st.code(audit3, language='json')
+
+with tab4:
+    with st.container(height=400):
+        st.code(audit4, language='json')
+
+st.divider()
+
+
+
+st.header("3. Critic Step", divider=True)
+
+col1, col2 = st.columns(2)
+
+args = st.session_state.args
+
+with col1:
+    model_c = st.radio(
+        "Set the GPT model 👉",
+        key="model_c",
+        options=["gpt-3.5-turbo", "gpt-4", "gpt-4-turbo-preview", "deepseek-r1", "deepseek-reasoner"],
+        index=2
+    )
+    
+    auditor_dir_c = st.text_input(
+        "Auditor Directory location",
+        value=f"temporary_dir/path/to/data"
+    )
+
+with col2:
+
+    temperature_c = st.number_input(
+        "Set the temperature 👉",
+        key="temperature_c",
+        min_value=0.0,
+        max_value=1.0,
+        value=0.0,
+        format="%f"
+    )
+
+    num_critic_c = st.number_input(
+        "Set the num critics 👉",
+        key="num_critic_c",
+        min_value=1,
+        max_value=10,
+        value=1,
+        format="%d"
+    )
+
+    shot_c = st.radio(
+        "Set the num shots (few/one) 👉",
+        key="shot_c",
+        options=["one", "few"],
+        index=1
+    )
+
+
+st.subheader("Result 3.1 - Critic Results", divider=True)
+
+tab4, tab3, tab2, tab1 = st.tabs(["File 1", "File 2", "File 3", "File 4"])
+
+with tab1:
+    with st.container(height=400):
+        st.code(critic1, language='json')
+
+with tab2:
+    with st.container(height=400):
+        st.code(critic2, language='json')
+
+with tab3:
+    with st.container(height=400):
+        st.code(critic3, language='json')
+
+with tab4:
+    with st.container(height=400):
+        st.code(critic4, language='json')
+
+st.divider()
+
+
+
+
+
+
+
+
+st.header("4. Ranking Step", divider=True)
+
+col1, col2 = st.columns(2)
+
+args = st.session_state.args
+args_c = st.session_state.args_c
+
+with col1:
+    
+    auditor_dir_r = st.text_input(
+        "Auditor Dir location",
+        value=f"temporary_dir/path/to/data"
+    )
+
+    critic_dir_r = st.text_input(
+        "Critic Directory location",
+        value=f"temporary_dir/path/to/data"
+    )
+
+with col2:
+
+    strategy_r = st.radio(
+        "Set the strategy (default/custom) 👉",
+        key="strategy_r",
+        options=["default", "custom"],
+        index=0
+    )
+
+
+st.subheader("Result 4.1 - Ranking Results", divider=True)
+
+tab4, tab3, tab2, tab1 = st.tabs(["File 1", "File 2", "File 3", "File 4"])
+
+with tab1:
+    with st.container(height=400):
+        st.code(ranker1, language='json')
+
+with tab2:
+    with st.container(height=400):
+        st.code(ranker2, language='json')
+
+with tab3:
+    with st.container(height=400):
+        st.code(ranker3, language='json')
+
+with tab4:
+    with st.container(height=400):
+        st.code(ranker4, language='json')
+
 st.divider()
\ No newline at end of file
diff --git a/src/environment_old.yml b/src/environment_old.yml
index 676e6e64..c703177f 100644
--- a/src/environment_old.yml
+++ b/src/environment_old.yml
@@ -1,83 +1,83 @@
-# name: GPTLens
-# channels:
-#   - defaults
-# dependencies:
-#   - bzip2=1.0.8=he774522_0
-#   - ca-certificates=2023.12.12=haa95532_0
-#   - libffi=3.4.4=hd77b12b_0
-#   - openssl=3.0.13=h2bbff1b_0
-#   - pip=23.3.1=py311haa95532_0
-#   - python=3.11.7=he1021f5_0
-#   - setuptools=68.2.2=py311haa95532_0
-#   - sqlite=3.41.2=h2bbff1b_0
-#   - tk=8.6.12=h2bbff1b_0
-#   - vc=14.2=h21ff451_1
-#   - vs2015_runtime=14.27.29016=h5e58377_2
-#   # - wheel=0.41.2=py311haa95532_0
-#   - xz=5.4.5=h8cc25b3_0
-#   - zlib=1.2.13=h8cc25b3_0
-#   - pip:
-#       - aiohttp==3.9.3
-#       - aiosignal==1.3.1
-#       - altair==5.2.0
-#       - annotated-types==0.6.0
-#       - anyio==4.2.0
-#       - attrs==23.2.0
-#       - blinker==1.7.0
-#       - cachetools==5.3.2
-#       - certifi==2024.2.2
-#       - charset-normalizer==3.3.2
-#       - click==8.1.7
-#       - colorama==0.4.6
-#       - distro==1.9.0
-#       - frozenlist==1.4.1
-#       - gitdb==4.0.11
-#       - gitpython==3.1.41
-#       - h11==0.14.0
-#       - httpcore==1.0.2
-#       - httpx==0.26.0
-#       - idna==3.6
-#       - importlib-metadata==7.0.1
-#       - inflection==0.5.1
-#       - jinja2==3.1.3
-#       - jsonschema==4.21.1
-#       - jsonschema-specifications==2023.12.1
-#       - markdown-it-py==3.0.0
-#       - markupsafe==2.1.5
-#       - mdurl==0.1.2
-#       - multidict==6.0.5
-#       - numpy==1.26.3
-#       - openai==1.11.1
-#       - openapi==1.1.0
-#       - packaging==23.2
-#       - pandas==2.2.0
-#       - pillow==10.2.0
-#       - protobuf==4.25.2
-#       - pyarrow==15.0.0
-#       - pydantic==2.6.0
-#       - pydantic-core==2.16.1
-#       - pydeck==0.8.1b0
-#       - pygments==2.17.2
-#       - python-dateutil==2.8.2
-#       - pytz==2024.1
-#       - referencing==0.33.0
-#       - requests==2.31.0
-#       - rich==13.7.0
-#       - rpds-py==0.17.1
-#       - six==1.16.0
-#       - smmap==5.0.1
-#       - sniffio==1.3.0
-#       - streamlit==1.31.0
-#       - tenacity==8.2.3
-#       - toml==0.10.2
-#       - toolz==0.12.1
-#       - tornado==6.4
-#       - tqdm==4.66.1
-#       - typing-extensions==4.9.0
-#       - tzdata==2023.4
-#       - tzlocal==5.2
-#       - urllib3==2.2.0
-#       - validators==0.22.0
-#       - watchdog==3.0.0
-#       - yarl==1.9.4
-#       - zipp==3.17.0
+# name: GPTLens
+# channels:
+#   - defaults
+# dependencies:
+#   - bzip2=1.0.8=he774522_0
+#   - ca-certificates=2023.12.12=haa95532_0
+#   - libffi=3.4.4=hd77b12b_0
+#   - openssl=3.0.13=h2bbff1b_0
+#   - pip=23.3.1=py311haa95532_0
+#   - python=3.11.7=he1021f5_0
+#   - setuptools=68.2.2=py311haa95532_0
+#   - sqlite=3.41.2=h2bbff1b_0
+#   - tk=8.6.12=h2bbff1b_0
+#   - vc=14.2=h21ff451_1
+#   - vs2015_runtime=14.27.29016=h5e58377_2
+#   # - wheel=0.41.2=py311haa95532_0
+#   - xz=5.4.5=h8cc25b3_0
+#   - zlib=1.2.13=h8cc25b3_0
+#   - pip:
+#       - aiohttp==3.9.3
+#       - aiosignal==1.3.1
+#       - altair==5.2.0
+#       - annotated-types==0.6.0
+#       - anyio==4.2.0
+#       - attrs==23.2.0
+#       - blinker==1.7.0
+#       - cachetools==5.3.2
+#       - certifi==2024.2.2
+#       - charset-normalizer==3.3.2
+#       - click==8.1.7
+#       - colorama==0.4.6
+#       - distro==1.9.0
+#       - frozenlist==1.4.1
+#       - gitdb==4.0.11
+#       - gitpython==3.1.41
+#       - h11==0.14.0
+#       - httpcore==1.0.2
+#       - httpx==0.26.0
+#       - idna==3.6
+#       - importlib-metadata==7.0.1
+#       - inflection==0.5.1
+#       - jinja2==3.1.3
+#       - jsonschema==4.21.1
+#       - jsonschema-specifications==2023.12.1
+#       - markdown-it-py==3.0.0
+#       - markupsafe==2.1.5
+#       - mdurl==0.1.2
+#       - multidict==6.0.5
+#       - numpy==1.26.3
+#       - openai==1.11.1
+#       - openapi==1.1.0
+#       - packaging==23.2
+#       - pandas==2.2.0
+#       - pillow==10.2.0
+#       - protobuf==4.25.2
+#       - pyarrow==15.0.0
+#       - pydantic==2.6.0
+#       - pydantic-core==2.16.1
+#       - pydeck==0.8.1b0
+#       - pygments==2.17.2
+#       - python-dateutil==2.8.2
+#       - pytz==2024.1
+#       - referencing==0.33.0
+#       - requests==2.31.0
+#       - rich==13.7.0
+#       - rpds-py==0.17.1
+#       - six==1.16.0
+#       - smmap==5.0.1
+#       - sniffio==1.3.0
+#       - streamlit==1.31.0
+#       - tenacity==8.2.3
+#       - toml==0.10.2
+#       - toolz==0.12.1
+#       - tornado==6.4
+#       - tqdm==4.66.1
+#       - typing-extensions==4.9.0
+#       - tzdata==2023.4
+#       - tzlocal==5.2
+#       - urllib3==2.2.0
+#       - validators==0.22.0
+#       - watchdog==3.0.0
+#       - yarl==1.9.4
+#       - zipp==3.17.0
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-10299.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-10299.json
new file mode 100644
index 00000000..af244012
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-10299.json
@@ -0,0 +1,29 @@
+[
+    {
+        "function_name": "batchTransfer",
+        "code": "function batchTransfer(address[] _receivers, uint256 _value) public whenNotPaused returns (bool) { uint cnt = _receivers.length; uint256 amount = uint256(cnt) * _value; require(cnt > 0 && cnt <= 20); require(_value > 0 && balances[msg.sender] >= amount); balances[msg.sender] = balances[msg.sender].sub(amount); for (uint i = 0; i < cnt; i++) { balances[_receivers[i]] = balances[_receivers[i]].add(_value); Transfer(msg.sender, _receivers[i], _value); } return true; }",
+        "vulnerability": "Integer Overflow Leading to Arbitrary Token Minting",
+        "reason": "The multiplication `uint256 amount = uint256(cnt) * _value` does not use SafeMath, allowing integer overflow. If `cnt * _value` exceeds 2^256-1, `amount` wraps around to a small value. The subsequent `balances[msg.sender].sub(amount)` deducts an incorrect small amount, while each receiver gains the original large `_value`, enabling attackers to mint vast amounts of tokens from nothing.",
+        "file_name": "2018-10299.sol",
+        "label": "Integer Overflow",
+        "description": "An integer overflow in the batchTransfer function of a smart contract implementation for Beauty Ecosystem Coin (BEC), the Ethereum ERC20 token used in the Beauty Chain economic system, allows attackers to accomplish an unauthorized increase of digital assets by providing two _receivers arguments in conjunction with a large _value argument, as exploited in the wild in April 2018, aka the \"batchOverflow\" issue."
+    },
+    {
+        "function_name": "approve",
+        "code": "function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; }",
+        "vulnerability": "Allowance Race Condition (Front-Running)",
+        "reason": "The approve function does not mitigate the ERC20 allowance front-running attack. If a user reduces an existing allowance, a spender can front-run the transaction to use the old higher allowance before the reduction takes effect. This violates the intended allowance update and allows unauthorized token transfers.",
+        "file_name": "2018-10299.sol",
+        "label": "Integer Overflow",
+        "description": "An integer overflow in the batchTransfer function of a smart contract implementation for Beauty Ecosystem Coin (BEC), the Ethereum ERC20 token used in the Beauty Chain economic system, allows attackers to accomplish an unauthorized increase of digital assets by providing two _receivers arguments in conjunction with a large _value argument, as exploited in the wild in April 2018, aka the \"batchOverflow\" issue."
+    },
+    {
+        "function_name": "batchTransfer",
+        "code": "function batchTransfer(address[] _receivers, uint256 _value) public whenNotPaused returns (bool) { uint cnt = _receivers.length; uint256 amount = uint256(cnt) * _value; require(cnt > 0 && cnt <= 20); require(_value > 0 && balances[msg.sender] >= amount); balances[msg.sender] = balances[msg.sender].sub(amount); for (uint i = 0; i < cnt; i++) { balances[_receivers[i]] = balances[_receivers[i]].add(_value); Transfer(msg.sender, _receivers[i], _value); } return true; }",
+        "vulnerability": "Unauthorized Token Burning via Zero Address",
+        "reason": "The batchTransfer function lacks a check for zero addresses in the `_receivers` array. Unlike the transfer function, which blocks sending to `address(0)`, this allows users to send tokens to the zero address via batchTransfer, enabling unauthorized token burning and violating the contract's consistency.",
+        "file_name": "2018-10299.sol",
+        "label": "Integer Overflow",
+        "description": "An integer overflow in the batchTransfer function of a smart contract implementation for Beauty Ecosystem Coin (BEC), the Ethereum ERC20 token used in the Beauty Chain economic system, allows attackers to accomplish an unauthorized increase of digital assets by providing two _receivers arguments in conjunction with a large _value argument, as exploited in the wild in April 2018, aka the \"batchOverflow\" issue."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-10376.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-10376.json
new file mode 100644
index 00000000..911f9f96
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-10376.json
@@ -0,0 +1,29 @@
+[
+    {
+        "function_name": "transferProxy",
+        "code": "function transferProxy(address _from, address _to, uint256 _value, uint256 _feeSmt, uint8 _v,bytes32 _r, bytes32 _s) public transferAllowed(_from) returns (bool){ if(balances[_from] < _feeSmt + _value) revert(); uint256 nonce = nonces[_from]; bytes32 h = keccak256(_from,_to,_value,_feeSmt,nonce); if(_from != ecrecover(h,_v,_r,_s)) revert(); if(balances[_to] + _value < balances[_to] || balances[msg.sender] + _feeSmt < balances[msg.sender]) revert(); balances[_to] += _value; Transfer(_from, _to, _value); balances[msg.sender] += _feeSmt; Transfer(_from, msg.sender, _feeSmt); balances[_from] -= _value + _feeSmt; nonces[_from] = nonce + 1; return true; }",
+        "vulnerability": "Integer overflow in fee and value sum",
+        "reason": "The function checks if `_from` has sufficient balance using `balances[_from] < _feeSmt + _value`, but does not account for integer overflow. An attacker can craft `_feeSmt` and `_value` such that their sum overflows to a lower value (e.g., `_feeSmt = 2^256 - 200`, `_value = 200`), causing the check to pass even if `_from` has insufficient balance. This allows the attacker to transfer large amounts of tokens they don't own and mint arbitrary tokens for `msg.sender` via overflow in `balances[msg.sender] += _feeSmt`.",
+        "file_name": "2018-10376.sol",
+        "label": "Integer Overflow",
+        "description": "An integer overflow in the transferProxy function of a smart contract implementation for SmartMesh (aka SMT), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized increase of digital assets via crafted _fee and _value parameters, as exploited in the wild in April 2018, aka the \"proxyOverflow\" issue."
+    },
+    {
+        "function_name": "allocateTokens",
+        "code": "function allocateTokens(address[] _owners, uint256[] _values) public onlyOwner { if(allocateEndTime < now) revert(); if(_owners.length != _values.length) revert(); for(uint256 i = 0; i < _owners.length ; i++){ address to = _owners[i]; uint256 value = _values[i]; if(totalSupply + value <= totalSupply || balances[to] + value <= balances[to]) revert(); totalSupply += value; balances[to] += value; } }",
+        "vulnerability": "Unrestricted token minting by owner",
+        "reason": "The `allocateTokens` function allows the owner to mint unlimited tokens within 1 day of deployment. There is no cap on `totalSupply`, so a malicious/compromised owner can inflate the supply indefinitely, devaluing existing tokens. Even though the function is time-limited, the 1-day window is sufficient to cause significant harm if exploited.",
+        "file_name": "2018-10376.sol",
+        "label": "Integer Overflow",
+        "description": "An integer overflow in the transferProxy function of a smart contract implementation for SmartMesh (aka SMT), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized increase of digital assets via crafted _fee and _value parameters, as exploited in the wild in April 2018, aka the \"proxyOverflow\" issue."
+    },
+    {
+        "function_name": "approveAndCallcode",
+        "code": "function approveAndCallcode(address _spender, uint256 _value, bytes _extraData) public returns (bool success) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); if(!_spender.call(_extraData)) { revert(); } return true; }",
+        "vulnerability": "Reentrancy via arbitrary external call",
+        "reason": "The function performs an external call (`_spender.call(_extraData)`) after setting an allowance. A malicious `_spender` can re-enter the contract (e.g., by calling `transferFrom` or `approveAndCallcode` again) before the allowance is consumed. This allows repeated draining of the allowance, as each reentrant call resets `allowed[msg.sender][_spender]` to `_value`.",
+        "file_name": "2018-10376.sol",
+        "label": "Integer Overflow",
+        "description": "An integer overflow in the transferProxy function of a smart contract implementation for SmartMesh (aka SMT), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized increase of digital assets via crafted _fee and _value parameters, as exploited in the wild in April 2018, aka the \"proxyOverflow\" issue."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-10666.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-10666.json
new file mode 100644
index 00000000..b597a36d
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-10666.json
@@ -0,0 +1,29 @@
+[
+    {
+        "function_name": "setOwner",
+        "code": "function setOwner(address _owner) returns (bool success) { owner = _owner; return true; }",
+        "vulnerability": "Missing access control allows anyone to become owner",
+        "reason": "The setOwner function lacks the onlyOwner modifier, allowing any caller to arbitrarily change the contract owner. This enables an attacker to take full control of the contract, including privileged functions like uploadBalances, setExportFee, or unlockToken. Once ownership is hijacked, the attacker can drain funds, manipulate fees, or disrupt the contract's operation.",
+        "file_name": "2018-10666.sol",
+        "label": "Access Control",
+        "description": "The Owned smart contract implementation for Aurora IDEX Membership (IDXM), an Ethereum ERC20 token, allows attackers to acquire contract ownership because the setOwner function is declared as public. A new owner can subsequently modify variables."
+    },
+    {
+        "function_name": "transfer",
+        "code": "function transfer(address _to, uint256 _amount) returns (bool success) { require(!locked); require(balanceOf[msg.sender] >= _amount); require(balanceOf[_to] + _amount >= balanceOf[_to]); balanceOf[msg.sender] -= _amount; uint256 preBalance = balanceOf[_to]; balanceOf[_to] += _amount; bool alreadyMax = preBalance >= singleIDXMQty; if (!alreadyMax) { if (now >= validAfter[_to].ts + mustHoldFor) validAfter[_to].last = preBalance; validAfter[_to].ts = now; } if (validAfter[msg.sender].last > balanceOf[msg.sender]) validAfter[msg.sender].last = balanceOf[msg.sender]; Transfer(msg.sender, _to, _amount); return true; }",
+        "vulnerability": "Integer overflow/underflow due to unsafe arithmetic",
+        "reason": "The transfer and transferFrom functions use raw arithmetic operations (e.g., balanceOf[msg.sender] -= _amount) without leveraging the inherited SafeMath library. In Solidity <0.8.0, this allows integer underflows/overflows. An attacker can send tokens they don\u2019t own (underflow to max uint256) or overflow a recipient\u2019s balance to near-zero. This directly compromises the token\u2019s integrity and enables theft or denial of service.",
+        "file_name": "2018-10666.sol",
+        "label": "Access Control",
+        "description": "The Owned smart contract implementation for Aurora IDEX Membership (IDXM), an Ethereum ERC20 token, allows attackers to acquire contract ownership because the setOwner function is declared as public. A new owner can subsequently modify variables."
+    },
+    {
+        "function_name": "approve",
+        "code": "function approve(address _spender, uint256 _amount) returns (bool success) { require(!locked); allowance[msg.sender][_spender] = _amount; Approval(msg.sender, _spender, _amount); return true; }",
+        "vulnerability": "Allowance front-running vulnerability",
+        "reason": "The approve function does not enforce the check-effects-interaction pattern or require resetting allowances to zero before updating. Attackers can front-run a user\u2019s approval change (e.g., from 100 to 50) by first using the old allowance (100) before it\u2019s reduced. This allows double-spending of allowances, enabling unauthorized token transfers from the victim\u2019s balance.",
+        "file_name": "2018-10666.sol",
+        "label": "Access Control",
+        "description": "The Owned smart contract implementation for Aurora IDEX Membership (IDXM), an Ethereum ERC20 token, allows attackers to acquire contract ownership because the setOwner function is declared as public. A new owner can subsequently modify variables."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-10705.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-10705.json
new file mode 100644
index 00000000..5dcaff7c
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-10705.json
@@ -0,0 +1,29 @@
+[
+    {
+        "function_name": "setOwner",
+        "code": "function setOwner(address _owner) returns (bool success) { owner = _owner; return true; }",
+        "vulnerability": "Unrestricted Ownership Transfer",
+        "reason": "The setOwner function lacks the onlyOwner modifier, allowing any address to arbitrarily change the contract owner. This enables an attacker to immediately take full control of the contract, including privileged functions like unlockToken and uploadBalances, leading to fund theft or contract destruction.",
+        "file_name": "2018-10705.sol",
+        "label": "Access Control",
+        "description": "The Owned smart contract implementation for Aurora DAO (AURA), an Ethereum ERC20 token, allows attackers to acquire contract ownership because the setOwner function is declared as public. An attacker can then conduct a lockBalances() denial of service attack."
+    },
+    {
+        "function_name": "uploadBalances",
+        "code": "function uploadBalances(address[] recipients, uint256[] balances) onlyOwner { require(!balancesUploaded); uint256 sum = 0; for (uint256 i = 0; i < recipients.length; i++) { balanceOf[recipients[i]] = safeAdd(balanceOf[recipients[i]], balances[i]); sum = safeAdd(sum, balances[i]); } balanceOf[owner] = safeSub(balanceOf[owner], sum); }",
+        "vulnerability": "Array Length Mismatch Token Loss",
+        "reason": "The uploadBalances function does not enforce equal lengths for recipients and balances arrays. If recipients.length > balances.length, balances[i] returns 0 beyond the balances array's end, causing the owner's balance to be reduced by the sum of the valid balances while recipients receive incorrect (often zero) amounts. This permanently burns the sum from the owner's balance, leading to irreversible token loss.",
+        "file_name": "2018-10705.sol",
+        "label": "Access Control",
+        "description": "The Owned smart contract implementation for Aurora DAO (AURA), an Ethereum ERC20 token, allows attackers to acquire contract ownership because the setOwner function is declared as public. An attacker can then conduct a lockBalances() denial of service attack."
+    },
+    {
+        "function_name": "approve",
+        "code": "function approve(address _spender, uint256 _value) public returns (bool success) { require(!locked); allowance[msg.sender][_spender] = _value; return true; }",
+        "vulnerability": "Allowance Race Condition",
+        "reason": "The approve function does not mitigate the ERC20 allowance front-running attack. If a user reduces their approval for a spender, the spender can front-run the transaction to use the old allowance before the reduction. This allows attackers to drain funds up to the previous higher allowance, especially impactful once the contract is unlocked.",
+        "file_name": "2018-10705.sol",
+        "label": "Access Control",
+        "description": "The Owned smart contract implementation for Aurora DAO (AURA), an Ethereum ERC20 token, allows attackers to acquire contract ownership because the setOwner function is declared as public. An attacker can then conduct a lockBalances() denial of service attack."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-11335.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-11335.json
new file mode 100644
index 00000000..c615b6f9
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-11335.json
@@ -0,0 +1,29 @@
+[
+    {
+        "function_name": "mint",
+        "code": "function mint(address holder, uint value) public {\n    require(msg.sender == ico);\n    require(value > 0);\n    require(totalSupply + value <= TOKEN_LIMIT);\n    balances[holder] += value;\n    totalSupply += value;\n    Transfer(0x0, holder, value);\n}",
+        "vulnerability": "Integer overflow in minting",
+        "reason": "The mint function does not use SafeMath for addition, allowing integer overflows. The require statement 'totalSupply + value <= TOKEN_LIMIT' can be bypassed if totalSupply + value overflows, resulting in a wrapped value that is within the limit. Additionally, 'balances[holder] += value' and 'totalSupply += value' can overflow, leading to incorrect token balances and total supply. An attacker with control over the ico address could exploit this to mint tokens beyond the intended TOKEN_LIMIT or corrupt balances.",
+        "file_name": "2018-11335.sol",
+        "label": "Integer Overflow",
+        "description": "GVToken Genesis Vision (GVT) is a smart contract running on Ethereum. The mint function has an integer overflow that allows minted tokens to be arbitrarily retrieved by the contract owner."
+    },
+    {
+        "function_name": "setMigrationAgent",
+        "code": "function setMigrationAgent(address _agent) external {\n    require(migrationAgent == 0);\n    require(msg.sender == migrationMaster);\n    migrationAgent = _agent;\n}",
+        "vulnerability": "Privilege escalation via migration agent",
+        "reason": "The setMigrationAgent function allows the migrationMaster to set a malicious migration agent contract once. If the migrationMaster's account is compromised, an attacker can set a malicious agent. Users who call migrate() will have their tokens transferred to the attacker's contract via MigrationAgent.migrateFrom, resulting in loss of funds. This centralizes trust in migrationMaster, creating a single point of failure.",
+        "file_name": "2018-11335.sol",
+        "label": "Integer Overflow",
+        "description": "GVToken Genesis Vision (GVT) is a smart contract running on Ethereum. The mint function has an integer overflow that allows minted tokens to be arbitrarily retrieved by the contract owner."
+    },
+    {
+        "function_name": "approve",
+        "code": "function approve(address _spender, uint _value) public returns (bool) {\n    require(!isFrozen);\n    return super.approve(_spender, _value);\n}",
+        "vulnerability": "ERC20 approve front-running",
+        "reason": "The approve function is vulnerable to the ERC20 race condition. If a user changes the approval amount from a non-zero value to another non-zero value, a malicious spender can front-run the transaction, using the old allowance before it's reduced. This can lead to unintended allowance usage. Although increaseApproval/decreaseApproval exist, the standard approve remains risky, especially when users are unaware of the race condition.",
+        "file_name": "2018-11335.sol",
+        "label": "Integer Overflow",
+        "description": "GVToken Genesis Vision (GVT) is a smart contract running on Ethereum. The mint function has an integer overflow that allows minted tokens to be arbitrarily retrieved by the contract owner."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-12025.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-12025.json
new file mode 100644
index 00000000..56210bb2
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-12025.json
@@ -0,0 +1,29 @@
+[
+    {
+        "function_name": "transferFrom",
+        "code": "function transferFrom(address from, address to, uint value) returns (bool success) { if (frozenAccount[msg.sender]) return false; if(balances[from] < value) return false; if( allowed[from][msg.sender] >= value ) return false; if(balances[to] + value < balances[to]) return false; balances[from] -= value; allowed[from][msg.sender] -= value; balances[to] += value; Transfer(from, to, value); return true; }",
+        "vulnerability": "Inverted Allowance Check & Underflow",
+        "reason": "The condition `if( allowed[from][msg.sender] >= value ) return false;` is inverted. This allows transfers when the allowance is **insufficient** (allowed < value) instead of enforcing it. Furthermore, when `allowed[from][msg.sender]` is less than `value`, the line `allowed[from][msg.sender] -= value;` underflows (due to Solidity 0.4.2's lack of overflow checks), setting the allowance to a massive value (2^256 - X). Attackers can exploit this to gain infinite approval after one underflow, enabling unlimited token transfers from the victim's account.",
+        "file_name": "2018-12025.sol",
+        "label": "Wrong Logic",
+        "description": "The transferFrom function of a smart contract implementation for FuturXE (FXE), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized transfer of digital assets because of a logic error. The developer messed up with the boolean judgment - if the input value is smaller than or equal to allowed value, the transfer session would stop execution by returning false. This makes no sense, because the transferFrom() function should require the transferring value to not exceed the allowed value in the first place. Suppose this function asks for the allowed value to be smaller than the input. Then, the attacker could easily ignore the allowance: after this condition, the `allowed[from][msg.sender] -= value;` would cause an underflow because the allowed part is smaller than the value. The attacker could transfer any amount of FuturXe tokens of any accounts to an appointed account (the `_to` address) because the allowed value is initialized to 0, and the attacker could bypass this restriction even without the victim's private key."
+    },
+    {
+        "function_name": "transferFrom",
+        "code": "function transferFrom(address from, address to, uint value) returns (bool success) { if (frozenAccount[msg.sender]) return false; if(balances[from] < value) return false; if( allowed[from][msg.sender] >= value ) return false; if(balances[to] + value < balances[to]) return false; balances[from] -= value; allowed[from][msg.sender] -= value; balances[to] += value; Transfer(from, to, value); return true; }",
+        "vulnerability": "Incorrect Frozen Account Check",
+        "reason": "The function checks `frozenAccount[msg.sender]` (spender's status) instead of `frozenAccount[from]` (token owner's status). A frozen account (from) can still have its tokens transferred via an approved spender (msg.sender) as long as the spender is not frozen. This violates the intended freezing logic, allowing attackers to bypass account freezes by using approved addresses.",
+        "file_name": "2018-12025.sol",
+        "label": "Wrong Logic",
+        "description": "The transferFrom function of a smart contract implementation for FuturXE (FXE), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized transfer of digital assets because of a logic error. The developer messed up with the boolean judgment - if the input value is smaller than or equal to allowed value, the transfer session would stop execution by returning false. This makes no sense, because the transferFrom() function should require the transferring value to not exceed the allowed value in the first place. Suppose this function asks for the allowed value to be smaller than the input. Then, the attacker could easily ignore the allowance: after this condition, the `allowed[from][msg.sender] -= value;` would cause an underflow because the allowed part is smaller than the value. The attacker could transfer any amount of FuturXe tokens of any accounts to an appointed account (the `_to` address) because the allowed value is initialized to 0, and the attacker could bypass this restriction even without the victim's private key."
+    },
+    {
+        "function_name": "approve",
+        "code": "function approve(address _spender, uint256 _amount) returns (bool success) { allowed[msg.sender][_spender] = _amount; Approval(msg.sender, _spender, _amount); return true; }",
+        "vulnerability": "Unsafe ERC20 Approve",
+        "reason": "The `approve` function does not include a check for the front-running race condition. If a user changes their approval from a non-zero value to another non-zero value, an attacker can front-run the transaction to use the old approval before it is reset. While this is a known ERC20 design flaw, its presence here allows attackers to steal funds if users naively adjust approvals without first setting them to zero.",
+        "file_name": "2018-12025.sol",
+        "label": "Wrong Logic",
+        "description": "The transferFrom function of a smart contract implementation for FuturXE (FXE), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized transfer of digital assets because of a logic error. The developer messed up with the boolean judgment - if the input value is smaller than or equal to allowed value, the transfer session would stop execution by returning false. This makes no sense, because the transferFrom() function should require the transferring value to not exceed the allowed value in the first place. Suppose this function asks for the allowed value to be smaller than the input. Then, the attacker could easily ignore the allowance: after this condition, the `allowed[from][msg.sender] -= value;` would cause an underflow because the allowed part is smaller than the value. The attacker could transfer any amount of FuturXe tokens of any accounts to an appointed account (the `_to` address) because the allowed value is initialized to 0, and the attacker could bypass this restriction even without the victim's private key."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-13836.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-13836.json
new file mode 100644
index 00000000..7ac02733
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-13836.json
@@ -0,0 +1,29 @@
+[
+    {
+        "function_name": "multiTransfer",
+        "code": "function multiTransfer(address[] _addresses, uint[] _amounts) public returns (bool success) { require(_addresses.length <= 100 && _addresses.length == _amounts.length); uint totalAmount; for (uint a = 0; a < _amounts.length; a++) { totalAmount += _amounts[a]; } require(totalAmount > 0 && balances[msg.sender] >= totalAmount); balances[msg.sender] -= totalAmount; for (uint b = 0; b < _addresses.length; b++) { if (_amounts[b] > 0) { balances[_addresses[b]] += _amounts[b]; Transfer(msg.sender, _addresses[b], _amounts[b]); } } return true; }",
+        "vulnerability": "Integer Overflow in Token Transfer",
+        "reason": "The `multiTransfer` function calculates `totalAmount` by summing all `_amounts` without overflow checks. Using Solidity 0.4.18 (which lacks automatic overflow protection), an attacker can craft `_amounts` values that overflow `totalAmount`, bypassing the `balances[msg.sender] >= totalAmount` check. For example, if the sum overflows to a small value, the attacker's balance is reduced minimally, but recipients receive large amounts, effectively stealing tokens from the contract.",
+        "file_name": "2018-13836.sol",
+        "label": "Integer Overflow",
+        "description": "An integer overflow vulnerability exists in the function multiTransfer of Rocket Coin (XRC), an Ethereum token smart contract. An attacker could use it to set any user's balance."
+    },
+    {
+        "function_name": "approve",
+        "code": "function approve(address _spender, uint256 _amount) public returns (bool success) { allowed[msg.sender][_spender] = _amount; Approval(msg.sender, _spender, _amount); return true; }",
+        "vulnerability": "Front-Runnable Approval",
+        "reason": "The `approve` function allows a user to set a new allowance without first resetting it to zero. An attacker can front-run a user's approval reduction (e.g., from 5 to 3) by observing the transaction in the mempool and executing a `transferFrom` with the old allowance (5) before it is reduced. This enables double-spending of the originally approved amount, violating the user's intended authorization limits.",
+        "file_name": "2018-13836.sol",
+        "label": "Integer Overflow",
+        "description": "An integer overflow vulnerability exists in the function multiTransfer of Rocket Coin (XRC), an Ethereum token smart contract. An attacker could use it to set any user's balance."
+    },
+    {
+        "function_name": "fallback function",
+        "code": "function() public payable { require(airDropStatus && balances[owner] >= airDropAmount && !participants[msg.sender] && tx.gasprice >= airDropGasPrice); balances[owner] -= airDropAmount; balances[msg.sender] += airDropAmount; Transfer(owner, msg.sender, airDropAmount); participants[msg.sender] = true; }",
+        "vulnerability": "Trapped ETH with No Handling",
+        "reason": "The fallback function is `payable` but does not process incoming ETH. Users may mistakenly send ETH (e.g., assuming it's required for the airdrop), which becomes permanently locked in the contract. While the airdrop itself does not require ETH, the contract's design misleads users into sending funds that are never used or returned, resulting in accidental financial loss.",
+        "file_name": "2018-13836.sol",
+        "label": "Integer Overflow",
+        "description": "An integer overflow vulnerability exists in the function multiTransfer of Rocket Coin (XRC), an Ethereum token smart contract. An attacker could use it to set any user's balance."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-15552.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-15552.json
new file mode 100644
index 00000000..949a532f
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-15552.json
@@ -0,0 +1,29 @@
+[
+    {
+        "function_name": "withdraw",
+        "code": "function withdraw() public { require(worldOwner == msg.sender); lottoIndex += 1; numtickets = 0; totalBounty = 0; worldOwner.transfer(this.balance); }",
+        "vulnerability": "Owner can steal funds mid-lottery",
+        "reason": "The withdraw() function allows the owner to reset the lottery state (numtickets, totalBounty) and transfer the entire contract balance to themselves at any time, including during an active round. This enables the owner to steal all accumulated ticket funds from participants before the lottery completes. Participants who already bought tickets would lose their ETH without any reward distribution.",
+        "file_name": "2018-15552.sol",
+        "label": "Bad Randomness",
+        "description": "The \"PayWinner\" function of a simplelottery smart contract implementation for The Ethereum Lottery, an Ethereum gambling game, generates a random value with publicly readable variable \"maxTickets\" (which is private, yet predictable and readable by the eth.getStorageAt function). Therefore, it allows attackers to always win and get rewards."
+    },
+    {
+        "function_name": "PayWinner",
+        "code": "function PayWinner( address winner ) private { require(numtickets == maxTickets); uint ownerTax = 6 * totalBounty / 100; uint winnerPrice = totalBounty - ownerTax; LottoComplete(msg.sender, lottoIndex, winnerPrice); lottoIndex += 1; numtickets = 0; totalBounty = 0; if(_direction == 0 && maxTickets < 20) maxTickets += 1; if(_direction == 1 && maxTickets > 10) maxTickets -= 1; if(_direction == 0 && maxTickets == 20) _direction = 1; if(_direction == 1 && maxTickets == 10) _direction = 0; worldOwner.transfer(ownerTax); winner.transfer(winnerPrice); }",
+        "vulnerability": "DoS via failed winner transfer",
+        "reason": "PayWinner uses transfer() to send funds to the winner. If the winner is a contract without a payable fallback function, the transfer will fail, reverting the entire transaction. This leaves the contract state (numtickets == maxTickets) unchanged, permanently blocking the AddTicket function (due to its numtickets < maxTickets check). Attackers can exploit this by purchasing the last ticket with a non-payable address to intentionally brick the contract.",
+        "file_name": "2018-15552.sol",
+        "label": "Bad Randomness",
+        "description": "The \"PayWinner\" function of a simplelottery smart contract implementation for The Ethereum Lottery, an Ethereum gambling game, generates a random value with publicly readable variable \"maxTickets\" (which is private, yet predictable and readable by the eth.getStorageAt function). Therefore, it allows attackers to always win and get rewards."
+    },
+    {
+        "function_name": "AddTicket",
+        "code": "function AddTicket() public payable { require(msg.value == ticketPrice); require(numtickets < maxTickets); lastTicketTime = now; numtickets += 1; totalBounty += ticketPrice; bool success = numtickets == maxTickets; NewTicket(msg.sender, success); if(success) { PayWinner(msg.sender); } }",
+        "vulnerability": "Predictable last-ticket winner selection",
+        "reason": "The winner is deterministically set to the last address that submits a ticket when maxTickets is reached. Attackers can monitor the blockchain for pending transactions and front-run the final ticket purchase to guarantee they become the winner. This violates fair lottery mechanics and allows centralized exploitation by bots/MEV searchers.",
+        "file_name": "2018-15552.sol",
+        "label": "Bad Randomness",
+        "description": "The \"PayWinner\" function of a simplelottery smart contract implementation for The Ethereum Lottery, an Ethereum gambling game, generates a random value with publicly readable variable \"maxTickets\" (which is private, yet predictable and readable by the eth.getStorageAt function). Therefore, it allows attackers to always win and get rewards."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-17877.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-17877.json
new file mode 100644
index 00000000..ab914c85
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-17877.json
@@ -0,0 +1,29 @@
+[
+    {
+        "function_name": "luckyBuy",
+        "code": "function luckyBuy() private view returns(bool) { uint256 seed = uint256(keccak256(abi.encodePacked( (block.timestamp).add (block.difficulty).add ((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add (block.gaslimit).add ((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add (block.number) ))); if((seed - ((seed / 1000) * 1000)) < luckybuyTracker_) return(true); else return(false); }",
+        "vulnerability": "Insecure Pseudo-Randomness",
+        "reason": "The 'luckyBuy' function uses block.timestamp, block.difficulty, block.coinbase, and other predictable on-chain data to generate randomness. Miners can manipulate these values to influence the outcome, allowing attackers to increase their chances of winning the Luckybuy prize. This makes the randomness exploitable and not truly random.",
+        "file_name": "2018-17877.sol",
+        "label": "Bad Randomness",
+        "description": "A lottery smart contract implementation for Greedy 599, an Ethereum gambling game, generates a random value that is predictable via an external contract call. The developer used the extcodesize() function to prevent a malicious contract from being called, but the attacker can bypass it by writing the core code in the constructor of their exploit code. Therefore, it allows attackers to always win and get rewards."
+    },
+    {
+        "function_name": "win",
+        "code": "function win() public { require(now > RoundTime[Round] && RoundTime[Round] != 0); RoundLastGreedyMan[Round].transfer(RoundETH[Round]); emit winnerEvent(RoundLastGreedyMan[Round], RoundETH[Round], Round); Round++; }",
+        "vulnerability": "DoS via Failed Transfer",
+        "reason": "The 'win' function uses transfer() to send ETH to RoundLastGreedyMan without handling potential failures. If the winner is a contract with a fallback function that reverts (e.g., due to gas limits or intentional sabotage), the transfer will fail, causing the entire transaction to revert. This prevents the round from incrementing, halting the contract indefinitely.",
+        "file_name": "2018-17877.sol",
+        "label": "Bad Randomness",
+        "description": "A lottery smart contract implementation for Greedy 599, an Ethereum gambling game, generates a random value that is predictable via an external contract call. The developer used the extcodesize() function to prevent a malicious contract from being called, but the attacker can bypass it by writing the core code in the constructor of their exploit code. Therefore, it allows attackers to always win and get rewards."
+    },
+    {
+        "function_name": "buyHeart",
+        "code": "function buyHeart(address referred) public payable { ... address _addr = msg.sender; uint256 _codeLength; assembly {_codeLength := extcodesize(_addr)} require(_codeLength == 0, \"sorry humans only\"); ... }",
+        "vulnerability": "Contract Call Bypass",
+        "reason": "The 'buyHeart' function checks if the sender is a contract by checking extcodesize. However, during contract construction (constructor), extcodesize returns 0, allowing malicious contracts to bypass this check. Attackers can exploit this to automate purchases or manipulate the game logic, violating the 'humans only' requirement.",
+        "file_name": "2018-17877.sol",
+        "label": "Bad Randomness",
+        "description": "A lottery smart contract implementation for Greedy 599, an Ethereum gambling game, generates a random value that is predictable via an external contract call. The developer used the extcodesize() function to prevent a malicious contract from being called, but the attacker can bypass it by writing the core code in the constructor of their exploit code. Therefore, it allows attackers to always win and get rewards."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-17882.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-17882.json
new file mode 100644
index 00000000..2351c4be
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-17882.json
@@ -0,0 +1,29 @@
+[
+    {
+        "function_name": "transferFrom",
+        "code": "function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {\n    balances[_to] = safeAdd(balances[_to], _value);\n    balances[_from] = safeSub(balances[_from], _value);\n    if (_to != fights) {\n        allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value);\n    }\n    Transfer(_from, _to, _value);\n    return true;\n}",
+        "vulnerability": "Unauthorized transfers to 'fights' address",
+        "reason": "The transferFrom function does not check or deduct the allowance when transferring to the 'fights' address. This allows any user to transfer tokens from any account to the 'fights' address without requiring approval. An attacker can exploit this by setting 'fights' to a controlled address (if owner is compromised) or leveraging existing 'fights' access to drain funds from arbitrary accounts.",
+        "file_name": "2018-17882.sol",
+        "label": "Integer Overflow",
+        "description": "An Integer overflow vulnerability exists in the batchTransfer function of a smart contract implementation for CryptoBotsBattle (CBTB), an Ethereum token. This vulnerability could be used by an attacker to create an arbitrary amount of tokens for any user."
+    },
+    {
+        "function_name": "batchTransfer",
+        "code": "function batchTransfer(address[] _to, uint _value) public {\n    balances[msg.sender] = safeSub(\n        balances[msg.sender],\n        _to.length * _value\n    );\n    for (uint i = 0; i < _to.length; i++) {\n        balances[_to[i]] = safeAdd(balances[_to[i]], _value);\n        Transfer(msg.sender, _to[i], _value);\n    }\n}",
+        "vulnerability": "Integer overflow in multiplication",
+        "reason": "The multiplication '_to.length * _value' in batchTransfer is vulnerable to integer overflow. An attacker can craft a large '_to.length' and '_value' such that the product overflows to a small value (e.g., 0). This allows them to bypass balance checks, deduct little/no tokens from their balance, while still crediting all recipients with '_value' tokens. This effectively mints tokens out of thin air.",
+        "file_name": "2018-17882.sol",
+        "label": "Integer Overflow",
+        "description": "An Integer overflow vulnerability exists in the batchTransfer function of a smart contract implementation for CryptoBotsBattle (CBTB), an Ethereum token. This vulnerability could be used by an attacker to create an arbitrary amount of tokens for any user."
+    },
+    {
+        "function_name": "transferFrom",
+        "code": "function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {\n    balances[_to] = safeAdd(balances[_to], _value);\n    balances[_from] = safeSub(balances[_from], _value);\n    if (_to != fights) {\n        allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value);\n    }\n    Transfer(_from, _to], _value);\n    return true;\n}",
+        "vulnerability": "Incorrect allowance handling order",
+        "reason": "The transferFrom function updates balances before modifying allowances. While safe for non-fights addresses (due to revert on underflow), this violates the checks-effects-interactions pattern. If external calls were present, this could enable reentrancy. Though not directly exploitable here, it reflects poor security practices and increases risk if contract logic evolves.",
+        "file_name": "2018-17882.sol",
+        "label": "Integer Overflow",
+        "description": "An Integer overflow vulnerability exists in the batchTransfer function of a smart contract implementation for CryptoBotsBattle (CBTB), an Ethereum token. This vulnerability could be used by an attacker to create an arbitrary amount of tokens for any user."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-18425.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-18425.json
new file mode 100644
index 00000000..42ffb1f4
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-18425.json
@@ -0,0 +1,29 @@
+[
+    {
+        "function_name": "approve",
+        "code": "function approve(address _spender, uint256 _value) public returns (bool success) { if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; } allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; }",
+        "vulnerability": "Non-standard ERC20 approve behavior leading to allowance freeze",
+        "reason": "The approve function prevents updating an existing non-zero allowance to another non-zero value. This violates ERC20 standards and forces users to reset their allowance to zero first, creating a race condition vulnerable to front-running attacks. Contracts/DEXs expecting standard behavior will fail when users try to adjust allowances, breaking compatibility and potentially locking funds.",
+        "file_name": "2018-18425.sol",
+        "label": "Token Devalue",
+        "description": "The doAirdrop function of a smart contract implementation for Primeo (PEO), an Ethereum token, does not check the numerical relationship between the amount of the air drop and the token's total supply, which lets the owner of the contract issue an arbitrary amount of currency. (Increasing the total supply by using 'doAirdrop' ignores the hard cap written in the contract and devalues the token.)"
+    },
+    {
+        "function_name": "withdraw",
+        "code": "function withdraw() onlyOwner public { address myAddress = this; uint256 etherBalance = myAddress.balance; owner.transfer(etherBalance); }",
+        "vulnerability": "Owner can steal all contributed ETH immediately",
+        "reason": "The withdraw function allows the owner to drain all ETH from the contract at any time. Users sending ETH during token distribution have no guarantee their funds will be used as intended. This creates a direct financial scam vector where the owner can collect ETH and disappear without distributing proper token value.",
+        "file_name": "2018-18425.sol",
+        "label": "Token Devalue",
+        "description": "The doAirdrop function of a smart contract implementation for Primeo (PEO), an Ethereum token, does not check the numerical relationship between the amount of the air drop and the token's total supply, which lets the owner of the contract issue an arbitrary amount of currency. (Increasing the total supply by using 'doAirdrop' ignores the hard cap written in the contract and devalues the token.)"
+    },
+    {
+        "function_name": "doAirdrop",
+        "code": "function doAirdrop(address _participant, uint _amount) internal { require( _amount > 0 ); require( totalDistributed < totalSupply ); balances[_participant] = balances[_participant].add(_amount); totalDistributed = totalDistributed.add(_amount); if (totalDistributed >= totalSupply) { distributionFinished = true; } emit Airdrop(_participant, _amount, balances[_participant]); emit Transfer(address(0), _participant, _amount); }",
+        "vulnerability": "Unlimited token minting beyond totalSupply cap",
+        "reason": "The doAirdrop function only checks if totalDistributed < totalSupply BEFORE adding new tokens. If totalDistributed is 1 unit less than totalSupply, the owner can airdrop any amount (e.g., 1B tokens), causing totalDistributed to exceed totalSupply. This breaks the token's supply cap, enabling infinite inflation and total devaluation of the token.",
+        "file_name": "2018-18425.sol",
+        "label": "Token Devalue",
+        "description": "The doAirdrop function of a smart contract implementation for Primeo (PEO), an Ethereum token, does not check the numerical relationship between the amount of the air drop and the token's total supply, which lets the owner of the contract issue an arbitrary amount of currency. (Increasing the total supply by using 'doAirdrop' ignores the hard cap written in the contract and devalues the token.)"
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-19830.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-19830.json
new file mode 100644
index 00000000..173f26cc
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2018-19830.json
@@ -0,0 +1,29 @@
+[
+    {
+        "function_name": "UBSexToken",
+        "code": "function UBSexToken() { owner = msg.sender; totalSupply = 1.9 * 10 ** 26; balances[owner] = totalSupply; }",
+        "vulnerability": "Insecure Initialization via Public Function",
+        "reason": "The function UBSexToken() is not a constructor (mismatched contract name) and is publicly callable. Attackers can invoke it post-deployment to reset the owner, totalSupply, and balances, effectively hijacking the contract. This allows an attacker to mint the entire token supply to themselves and gain ownership, leading to total control over the contract.",
+        "file_name": "2018-19830.sol",
+        "label": "Access Control",
+        "description": "The UBSexToken() function of a smart contract implementation for Business Alliance Financial Circle (BAFC), an tradable Ethereum ERC20 token, allows attackers to change the owner of the contract, because the function is public (by default) and does not check the caller's identity."
+    },
+    {
+        "function_name": "transfer",
+        "code": "function transfer(address _to, uint _value) onlyPayloadSize(2 * 32) unFrozenAccount onlyTransferable { if (frozenAccount[_to]) { InvalidAccount(_to, \"The receiver account is frozen\"); } else { balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); } }",
+        "vulnerability": "Missing ERC20 Return Value",
+        "reason": "The transfer function does not return a boolean as required by the ERC20 standard. Contracts/Wallets expecting ERC20 compliance will treat the missing return value as a failure, causing transactions to revert. This breaks interoperability with exchanges, DeFi protocols, and other ERC20-reliant systems.",
+        "file_name": "2018-19830.sol",
+        "label": "Access Control",
+        "description": "The UBSexToken() function of a smart contract implementation for Business Alliance Financial Circle (BAFC), an tradable Ethereum ERC20 token, allows attackers to change the owner of the contract, because the function is public (by default) and does not check the caller's identity."
+    },
+    {
+        "function_name": "approve",
+        "code": "function approve(address _spender, uint _value) unFrozenAccount { if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw; allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); }",
+        "vulnerability": "Unsafe Allowance Update",
+        "reason": "The approve function throws when updating a non-zero allowance to another non-zero value. This forces users to reset allowance to zero first, creating a race condition where a spender can use the old allowance before it is updated. Attackers can front-run the second approval transaction to drain funds using the outdated allowance.",
+        "file_name": "2018-19830.sol",
+        "label": "Access Control",
+        "description": "The UBSexToken() function of a smart contract implementation for Business Alliance Financial Circle (BAFC), an tradable Ethereum ERC20 token, allows attackers to change the owner of the contract, because the function is public (by default) and does not check the caller's identity."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2019-15078.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2019-15078.json
new file mode 100644
index 00000000..639bf0ac
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2019-15078.json
@@ -0,0 +1,29 @@
+[
+    {
+        "function_name": "approve",
+        "code": "function approve(address _spender, uint256 _value) public returns (bool success) {\n    if (_value != 0 && allowed[msg.sender][_spender] != 0) {\n        return false;\n    }\n    allowed[msg.sender][_spender] = _value;\n    emit Approval(msg.sender, _spender, _value);\n    return true;\n}",
+        "vulnerability": "Non-standard ERC20 approve implementation",
+        "reason": "The approve function returns false if attempting to update a non-zero allowance to another non-zero value, violating ERC20 standards. This prevents users from adjusting existing allowances without first resetting them to zero. Attackers can exploit this by front-running approval changes, causing transactions to fail or funds to be locked. Contracts expecting standard ERC20 behavior will misinterpret the false return value, leading to operational failures.",
+        "file_name": "2019-15078.sol",
+        "label": "Typo Constructor",
+        "description": "An issue was discovered in a smart contract implementation for AIRDROPX BORN through 2019-05-29, an Ethereum token. The name of the constructor has a typo (wrong case: XBornID versus XBORNID) that allows an attacker to change the owner of the contract and obtain cryptocurrency for free."
+    },
+    {
+        "function_name": "modifier onlyPayloadSize",
+        "code": "modifier onlyPayloadSize(uint size) {\n    assert(msg.data.length >= size + 4);\n    _;\n}",
+        "vulnerability": "Assertion-based gas exhaustion",
+        "reason": "The onlyPayloadSize modifier uses assert() to validate transaction payload size. Unlike require(), assert() consumes all gas on failure. Attackers can craft malformed transactions (e.g., short-address attacks) to trigger this assertion, forcing victims to waste all gas. This enables gas-draining attacks and disrupts user transactions, directly benefiting attackers by increasing operational costs.",
+        "file_name": "2019-15078.sol",
+        "label": "Typo Constructor",
+        "description": "An issue was discovered in a smart contract implementation for AIRDROPX BORN through 2019-05-29, an Ethereum token. The name of the constructor has a typo (wrong case: XBornID versus XBORNID) that allows an attacker to change the owner of the contract and obtain cryptocurrency for free."
+    },
+    {
+        "function_name": "getTokens",
+        "code": "function getTokens() payable canDistr onlyWhitelist public {\n    if (value > totalRemaining) {\n        value = totalRemaining;\n    }\n    require(value <= totalRemaining);\n    address investor = msg.sender;\n    uint256 toGive = value;\n    distr(investor, toGive);\n    if (toGive > 0) {\n        blacklist[investor] = true;\n    }\n    if (totalDistributed >= totalSupply) {\n        distributionFinished = true;\n    }\n    value = value.div(100000).mul(99999);\n}",
+        "vulnerability": "Unchecked ETH deposits with owner withdrawal",
+        "reason": "The getTokens function is payable but does not process or validate msg.value. Users can accidentally send ETH, which remains trapped in the contract. The owner can withdraw these funds via withdraw(), creating a risk of financial loss for users. Attackers can also social-engineer victims into sending ETH, effectively stealing funds through the owner's withdrawal capability.",
+        "file_name": "2019-15078.sol",
+        "label": "Typo Constructor",
+        "description": "An issue was discovered in a smart contract implementation for AIRDROPX BORN through 2019-05-29, an Ethereum token. The name of the constructor has a typo (wrong case: XBornID versus XBORNID) that allows an attacker to change the owner of the contract and obtain cryptocurrency for free."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2019-15079.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2019-15079.json
new file mode 100644
index 00000000..72422ba9
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2019-15079.json
@@ -0,0 +1,29 @@
+[
+    {
+        "function_name": "EAI_TokenERC20",
+        "code": "function EAI_TokenERC20( uint256 initialSupply, string tokenName, string tokenSymbol ) public { totalSupply = initialSupply * 10 ** uint256(decimals); balanceOf[msg.sender] = totalSupply; name = tokenName; symbol = tokenSymbol; }",
+        "vulnerability": "Reinitialization Attack",
+        "reason": "The constructor is incorrectly named (EAI_TokenERC20 vs. contract name EAI_TokenERC), making it a public function callable by anyone. Attackers can reinitialize the contract, resetting totalSupply, name, symbol, and assigning themselves the entire token supply. This allows them to mint unlimited tokens, overwrite the contract's state, and effectively hijack control.",
+        "file_name": "2019-15079.sol",
+        "label": "Typo Constructor",
+        "description": "A typo exists in the constructor of a smart contract implementation for EAI through 2019-06-05, an Ethereum token. This vulnerability could be used by an attacker to acquire EAI tokens for free."
+    },
+    {
+        "function_name": "_transfer",
+        "code": "function _transfer(address _from, address _to, uint _value) internal { require(_to != 0x0); require(balanceOf[_from] >= _value); require(balanceOf[_to] + _value >= balanceOf[_to]); uint previousBalances = balanceOf[_from] + balanceOf[_to]; balanceOf[_from] -= _value; balanceOf[_to] += _value; emit Transfer(_from, _to, _value); assert(balanceOf[_from] + balanceOf[_to] == previousBalances); }",
+        "vulnerability": "Arithmetic Over/Underflow Risk",
+        "reason": "While manual overflow checks exist, the contract uses Solidity 0.4.16, which lacks native overflow protection. If edge cases bypass the require(balanceOf[_to] + _value >= balanceOf[_to]) check (e.g., via unexpected overflow wrapping), token balances could be corrupted. The assert may fail to detect overflow in previousBalances if the initial sum exceeds uint256 max, leading to inconsistent states.",
+        "file_name": "2019-15079.sol",
+        "label": "Typo Constructor",
+        "description": "A typo exists in the constructor of a smart contract implementation for EAI through 2019-06-05, an Ethereum token. This vulnerability could be used by an attacker to acquire EAI tokens for free."
+    },
+    {
+        "function_name": "transferFrom",
+        "code": "function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) { require(_value <= allowance[_from][msg.sender]); allowance[_from][msg.sender] -= _value; _transfer(_from, _to, _value); return true; }",
+        "vulnerability": "Front-Running Allowance Race",
+        "reason": "The transferFrom function decrements the allowance before performing the transfer. If the transfer fails (e.g., due to a later revert in _transfer), the allowance is permanently reduced. Attackers could exploit this by front-running transactions to cause intentional failures, effectively locking users' allowances and disrupting expected behavior.",
+        "file_name": "2019-15079.sol",
+        "label": "Typo Constructor",
+        "description": "A typo exists in the constructor of a smart contract implementation for EAI through 2019-06-05, an Ethereum token. This vulnerability could be used by an attacker to acquire EAI tokens for free."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2019-15080.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2019-15080.json
new file mode 100644
index 00000000..6aedffa0
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2019-15080.json
@@ -0,0 +1,29 @@
+[
+    {
+        "function_name": "owned",
+        "code": "function owned() public { owner = msg.sender; }",
+        "vulnerability": "Publicly callable ownership takeover",
+        "reason": "The function 'owned()' is public and lacks access control, allowing any caller to set themselves as the owner. This is due to the incorrect naming of the constructor (should be 'Owned()' in Solidity <0.4.22). Since the MorphToken constructor sets the owner, this function should not exist, but it remains callable post-deployment, enabling anyone to reset ownership.",
+        "file_name": "2019-15080.sol",
+        "label": "Typo Constructor",
+        "description": "An issue was discovered in a smart contract implementation for MORPH Token through 2019-06-05, an Ethereum token. A typo in the constructor of the Owned contract (which is inherited by MORPH Token) allows attackers to acquire contract ownership. A new owner can subsequently obtain MORPH Tokens for free and can perform a DoS attack."
+    },
+    {
+        "function_name": "transferOwnership",
+        "code": "function transferOwnership(address _newOwner) onlyOwner public { owner = _newOwner; }",
+        "vulnerability": "Unchecked zero-address ownership transfer",
+        "reason": "The function does not validate if '_newOwner' is a non-zero address. If the owner accidentally transfers ownership to address(0), the contract becomes permanently ownerless, locking all onlyOwner functions (e.g., mintTokens, blacklistAccount) and disrupting protocol governance.",
+        "file_name": "2019-15080.sol",
+        "label": "Typo Constructor",
+        "description": "An issue was discovered in a smart contract implementation for MORPH Token through 2019-06-05, an Ethereum token. A typo in the constructor of the Owned contract (which is inherited by MORPH Token) allows attackers to acquire contract ownership. A new owner can subsequently obtain MORPH Tokens for free and can perform a DoS attack."
+    },
+    {
+        "function_name": "approve",
+        "code": "function approve(address _spender, uint256 _amount) public returns (bool success) { allowed[msg.sender][_spender] = _amount; Approval(msg.sender, _spender, _amount); return true; }",
+        "vulnerability": "Front-runnable allowance approval",
+        "reason": "The approve() function does not implement checks for changing allowances (e.g., requiring allowance to be zero first). Attackers can front-run a user's approval change transaction to drain funds using the old allowance before it's updated, leading to double-spending of allowances.",
+        "file_name": "2019-15080.sol",
+        "label": "Typo Constructor",
+        "description": "An issue was discovered in a smart contract implementation for MORPH Token through 2019-06-05, an Ethereum token. A typo in the constructor of the Owned contract (which is inherited by MORPH Token) allows attackers to acquire contract ownership. A new owner can subsequently obtain MORPH Tokens for free and can perform a DoS attack."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2021-3004.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2021-3004.json
new file mode 100644
index 00000000..89cd665a
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/CVE-2021-3004.json
@@ -0,0 +1,29 @@
+[
+    {
+        "function_name": "_deposit",
+        "code": "function _deposit(IERC20 token, uint amount) internal {\n    uint _value = LINK.getPriceUSD(address(token)) * amount / uint256(10)**token.decimals();\n    require(_value > 0, \"!value\");\n    (address _pair, uint amountA,) = _addLiquidity(address(token), address(this), amount, _value);\n    token.safeTransferFrom(msg.sender, _pair, amountA);\n    _mint(_pair, _value);\n    uint _liquidity = ISushiswapV2Pair(_pair).mint(address(this));\n    collateral[msg.sender][address(token)] += _liquidity;\n    collateralCredit[msg.sender][address(token)] += _value;\n    uint _fee = _value * FEE / BASE;\n    _mint(msg.sender, _value - _fee);\n    _mint(address(this), _fee);\n    notifyFeeAmount(_fee);\n    emit Deposit(msg.sender, address(token), _value, amount, _value);\n}",
+        "vulnerability": "Oracle Price Manipulation",
+        "reason": "The _deposit function calculates the deposited collateral value using a single oracle (LINK.getPriceUSD) without cross-verifying with the actual AMM pool price. If the oracle is manipulated or provides incorrect prices (e.g., due to stale data or centralized control), attackers can deposit undervalued assets to mint inflated yCREDIT tokens. This allows them to steal protocol funds by redeeming overvalued yCREDIT for legitimate collateral. This is a critical vulnerability as it directly affects the protocol's solvency.",
+        "file_name": "2021-3004.sol",
+        "label": "Wrong Logic",
+        "description": "The _deposit function in the smart contract implementation for Stable Yield Credit (yCREDIT), an Ethereum token, has certain incorrect calculations. An attacker can obtain more yCREDIT tokens than they should."
+    },
+    {
+        "function_name": "_addLiquidity",
+        "code": "function _addLiquidity( address tokenA, address tokenB, uint amountADesired, uint amountBDesired ) internal virtual returns (address pair, uint amountA, uint amountB) {\n    pair = FACTORY.getPair(tokenA, tokenB);\n    if (pair == address(0)) {\n        pair = FACTORY.createPair(tokenA, tokenB);\n        pairs[pair] = true;\n        _markets.push(tokenA);\n    } else if (!pairs[pair]) {\n        pairs[pair] = true;\n        _markets.push(tokenA);\n    }\n    (uint reserveA, uint reserveB) = SushiswapV2Library.getReserves(address(FACTORY), tokenA, tokenB);\n    if (reserveA == 0 && reserveB == 0) {\n        (amountA, amountB) = (amountADesired, amountBDesired);\n    } else {\n        uint amountBOptimal = SushiswapV2Library.quote(amountADesired, reserveA, reserveB);\n        if (amountBOptimal <= amountBDesired) {\n            (amountA, amountB) = (amountADesired, amountBOptimal);\n        } else {\n            uint amountAOptimal = SushiswapV2Library.quote(amountBDesired, reserveB, reserveA);\n            assert(amountAOptimal <= amountADesired);\n            (amountA, amountB) = (amountAOptimal, amountBDesired);\n        }\n    }\n}",
+        "vulnerability": "Unrestricted Malicious Market Creation",
+        "reason": "The _addLiquidity function automatically adds any token to the _markets list when a new Sushiswap pair is created. Attackers can exploit this by creating pairs with malicious tokens (e.g., tokens with manipulated supply or fake collateral). Combined with oracle manipulation, this allows attackers to deposit worthless tokens as collateral, mint yCREDIT, and drain the protocol. The system should restrict which tokens can be used as collateral instead of auto-adding all pairs.",
+        "file_name": "2021-3004.sol",
+        "label": "Wrong Logic",
+        "description": "The _deposit function in the smart contract implementation for Stable Yield Credit (yCREDIT), an Ethereum token, has certain incorrect calculations. An attacker can obtain more yCREDIT tokens than they should."
+    },
+    {
+        "function_name": "_transferTokens",
+        "code": "function _transferTokens(address src, address dst, uint amount) internal {\n    balances[src] -= amount;\n    balances[dst] += amount;\n    emit Transfer(src, dst, amount);\n    if (pairs[src]) {\n        uint _fee = amount * FEE / BASE;\n        _transferTokens(dst, address(this), _fee);\n        notifyFeeAmount(_fee);\n    }\n}",
+        "vulnerability": "Incorrect Fee Application Leading to Reward Distortion",
+        "reason": "The fee mechanism applies a transfer tax when tokens are sent from a pair (e.g., during a buy). However, the fee is deducted from the recipient's (buyer's) balance after the initial transfer, which could lead to underflow if the fee rounds to zero or exceeds the received amount. Additionally, notifyFeeAmount recalculates rewardRate without proper validation, allowing attackers to manipulate reward distribution by making small transfers to trigger fee updates, potentially disrupting reward calculations or causing integer overflows/underflows.",
+        "file_name": "2021-3004.sol",
+        "label": "Wrong Logic",
+        "description": "The _deposit function in the smart contract implementation for Stable Yield Credit (yCREDIT), an Ethereum token, has certain incorrect calculations. An attacker can obtain more yCREDIT tokens than they should."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-10299.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-10299.json
new file mode 100644
index 00000000..e37237e0
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-10299.json
@@ -0,0 +1,41 @@
+[
+    {
+        "function_name": "batchTransfer",
+        "vulnerability": "Integer Overflow Leading to Arbitrary Token Minting",
+        "criticism": "The reasoning is correct. The multiplication `cnt * _value` lacks SafeMath checks, enabling integer overflow. If `_value` is crafted such that `cnt * _value` overflows, `amount` becomes a small value, allowing an attacker to bypass the balance check and mint large `_value` tokens for all receivers. The severity is extremely high (9) as this directly enables token supply manipulation. Profitability is also 9, as attackers can mint and sell tokens for profit. The correctness is 9 because the exploit is technically valid if SafeMath is not applied to the multiplication operation.",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 9,
+        "reason": "The multiplication `uint256 amount = uint256(cnt) * _value` does not use SafeMath, allowing integer overflow. If `cnt * _value` exceeds 2^256-1, `amount` wraps around to a small value. The subsequent `balances[msg.sender].sub(amount)` deducts an incorrect small amount, while each receiver gains the original large `_value`, enabling attackers to mint vast amounts of tokens from nothing.",
+        "code": "function batchTransfer(address[] _receivers, uint256 _value) public whenNotPaused returns (bool) { uint cnt = _receivers.length; uint256 amount = uint256(cnt) * _value; require(cnt > 0 && cnt <= 20); require(_value > 0 && balances[msg.sender] >= amount); balances[msg.sender] = balances[msg.sender].sub(amount); for (uint i = 0; i < cnt; i++) { balances[_receivers[i]] = balances[_receivers[i]].add(_value); Transfer(msg.sender, _receivers[i], _value); } return true; }",
+        "label": "Integer Overflow",
+        "file_name": "2018-10299.sol",
+        "description": "An integer overflow in the batchTransfer function of a smart contract implementation for Beauty Ecosystem Coin (BEC), the Ethereum ERC20 token used in the Beauty Chain economic system, allows attackers to accomplish an unauthorized increase of digital assets by providing two _receivers arguments in conjunction with a large _value argument, as exploited in the wild in April 2018, aka the \"batchOverflow\" issue."
+    },
+    {
+        "function_name": "approve",
+        "vulnerability": "Allowance Race Condition (Front-Running)",
+        "criticism": "The reasoning is partially correct but mischaracterizes the severity. The code follows the ERC20 standard, which inherently has this race condition. The function does not include mitigation (e.g., `increaseAllowance`/`decreaseAllowance`), but this is a protocol-level limitation, not a code vulnerability. Severity is low (2) as it relies on user error (not resetting to zero first). Profitability is moderate (4) only if exploited, but it is not a direct exploit vector. Correctness is 5 because the issue exists but is a known ERC20 design trade-off, not a code flaw.",
+        "correctness": 5,
+        "severity": 2,
+        "profitability": 4,
+        "reason": "The approve function does not mitigate the ERC20 allowance front-running attack. If a user reduces an existing allowance, a spender can front-run the transaction to use the old higher allowance before the reduction takes effect. This violates the intended allowance update and allows unauthorized token transfers.",
+        "code": "function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; }",
+        "label": "Integer Overflow",
+        "file_name": "2018-10299.sol",
+        "description": "An integer overflow in the batchTransfer function of a smart contract implementation for Beauty Ecosystem Coin (BEC), the Ethereum ERC20 token used in the Beauty Chain economic system, allows attackers to accomplish an unauthorized increase of digital assets by providing two _receivers arguments in conjunction with a large _value argument, as exploited in the wild in April 2018, aka the \"batchOverflow\" issue."
+    },
+    {
+        "function_name": "batchTransfer",
+        "vulnerability": "Unauthorized Token Burning via Zero Address",
+        "criticism": "The reasoning is context-dependent. Sending tokens to `address(0)` is a common way to burn tokens, and ERC20 does not prohibit it. If the contract explicitly forbids burning (e.g., in its `transfer` function), this would be a vulnerability. However, the reasoning assumes unauthorized burning without evidence of such a policy. Severity (1) and profitability (0) are negligible unless burning is disallowed. Correctness is 3 due to insufficient context.",
+        "correctness": 3,
+        "severity": 1,
+        "profitability": 0,
+        "reason": "The batchTransfer function lacks a check for zero addresses in the `_receivers` array. Unlike the transfer function, which blocks sending to `address(0)`, this allows users to send tokens to the zero address via batchTransfer, enabling unauthorized token burning and violating the contract's consistency.",
+        "code": "function batchTransfer(address[] _receivers, uint256 _value) public whenNotPaused returns (bool) { uint cnt = _receivers.length; uint256 amount = uint256(cnt) * _value; require(cnt > 0 && cnt <= 20); require(_value > 0 && balances[msg.sender] >= amount); balances[msg.sender] = balances[msg.sender].sub(amount); for (uint i = 0; i < cnt; i++) { balances[_receivers[i]] = balances[_receivers[i]].add(_value); Transfer(msg.sender, _receivers[i], _value); } return true; }",
+        "label": "Integer Overflow",
+        "file_name": "2018-10299.sol",
+        "description": "An integer overflow in the batchTransfer function of a smart contract implementation for Beauty Ecosystem Coin (BEC), the Ethereum ERC20 token used in the Beauty Chain economic system, allows attackers to accomplish an unauthorized increase of digital assets by providing two _receivers arguments in conjunction with a large _value argument, as exploited in the wild in April 2018, aka the \"batchOverflow\" issue."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-10376.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-10376.json
new file mode 100644
index 00000000..8f1aa136
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-10376.json
@@ -0,0 +1,41 @@
+[
+    {
+        "function_name": "transferProxy",
+        "vulnerability": "Integer Overflow in Fee/Value Sum",
+        "criticism": "The reasoning is correct. The function does not account for integer overflow in `_feeSmt + _value`, allowing an attacker to bypass balance checks. This leads to underflow in `balances[_from]`, effectively minting tokens for `_to` and `msg.sender`. The vulnerability is critical because it enables unauthorized token creation and transfer. The severity and profitability are both high due to direct exploitation potential.",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 9,
+        "reason": "The function checks if `_from` has sufficient balance using `balances[_from] < _feeSmt + _value`, but does not account for integer overflow. An attacker can craft `_feeSmt` and `_value` such that their sum overflows to a lower value (e.g., `_feeSmt = 2^256 - 200`, `_value = 200`), causing the check to pass even if `_from` has insufficient balance. This allows the attacker to transfer large amounts of tokens they don't own and mint arbitrary tokens for `msg.sender` via overflow in `balances[msg.sender] += _feeSmt`.",
+        "code": "function transferProxy(address _from, address _to, uint256 _value, uint256 _feeSmt, uint8 _v,bytes32 _r, bytes32 _s) public transferAllowed(_from) returns (bool){ if(balances[_from] < _feeSmt + _value) revert(); uint256 nonce = nonces[_from]; bytes32 h = keccak256(_from,_to,_value,_feeSmt,nonce); if(_from != ecrecover(h,_v,_r,_s)) revert(); if(balances[_to] + _value < balances[_to] || balances[msg.sender] + _feeSmt < balances[msg.sender]) revert(); balances[_to] += _value; Transfer(_from, _to, _value); balances[msg.sender] += _feeSmt; Transfer(_from, msg.sender, _feeSmt); balances[_from] -= _value + _feeSmt; nonces[_from] = nonce + 1; return true; }",
+        "label": "Integer Overflow",
+        "file_name": "2018-10376.sol",
+        "description": "An integer overflow in the transferProxy function of a smart contract implementation for SmartMesh (aka SMT), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized increase of digital assets via crafted _fee and _value parameters, as exploited in the wild in April 2018, aka the \"proxyOverflow\" issue."
+    },
+    {
+        "function_name": "allocateTokens",
+        "vulnerability": "Unrestricted Owner Minting",
+        "criticism": "The reasoning is partially correct. While the owner can mint tokens without a cap within the time window, this is a design choice (centralization risk) rather than a technical vulnerability. The overflow checks in the code prevent unintended supply inflation. Severity is moderate (7) as it depends on the owner's intent, and profitability is low (0) for external attackers unless the owner is compromised.",
+        "correctness": 7,
+        "severity": 7,
+        "profitability": 0,
+        "reason": "The `allocateTokens` function allows the owner to mint unlimited tokens within 1 day of deployment. There is no cap on `totalSupply`, so a malicious/compromised owner can inflate the supply indefinitely, devaluing existing tokens. Even though the function is time-limited, the 1-day window is sufficient to cause significant harm if exploited.",
+        "code": "function allocateTokens(address[] _owners, uint256[] _values) public onlyOwner { if(allocateEndTime < now) revert(); if(_owners.length != _values.length) revert(); for(uint256 i = 0; i < _owners.length ; i++){ address to = _owners[i]; uint256 value = _values[i]; if(totalSupply + value <= totalSupply || balances[to] + value <= balances[to]) revert(); totalSupply += value; balances[to] += value; } }",
+        "label": "Integer Overflow",
+        "file_name": "2018-10376.sol",
+        "description": "An integer overflow in the transferProxy function of a smart contract implementation for SmartMesh (aka SMT), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized increase of digital assets via crafted _fee and _value parameters, as exploited in the wild in April 2018, aka the \"proxyOverflow\" issue."
+    },
+    {
+        "function_name": "approveAndCallcode",
+        "vulnerability": "Reentrancy via External Call",
+        "criticism": "The reasoning is accurate. The external call `_spender.call(_extraData)` occurs after setting the allowance, enabling reentrancy. A malicious spender can repeatedly reset the allowance and drain funds. This is a high-severity vulnerability with direct profitability for attackers, akin to classic reentrancy exploits like the DAO hack.",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 9,
+        "reason": "The function performs an external call (`_spender.call(_extraData)`) after setting an allowance. A malicious `_spender` can re-enter the contract (e.g., by calling `transferFrom` or `approveAndCallcode` again) before the allowance is consumed. This allows repeated draining of the allowance, as each reentrant call resets `allowed[msg.sender][_spender]` to `_value`.",
+        "code": "function approveAndCallcode(address _spender, uint256 _value, bytes _extraData) public returns (bool success) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); if(!_spender.call(_extraData)) { revert(); } return true; }",
+        "label": "Integer Overflow",
+        "file_name": "2018-10376.sol",
+        "description": "An integer overflow in the transferProxy function of a smart contract implementation for SmartMesh (aka SMT), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized increase of digital assets via crafted _fee and _value parameters, as exploited in the wild in April 2018, aka the \"proxyOverflow\" issue."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-10666.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-10666.json
new file mode 100644
index 00000000..c349d3a7
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-10666.json
@@ -0,0 +1,41 @@
+[
+    {
+        "function_name": "setOwner",
+        "vulnerability": "Missing access control",
+        "criticism": "The reasoning is entirely correct. The absence of an access control modifier (e.g., onlyOwner) allows any caller to arbitrarily set the contract owner. This is a critical vulnerability because ownership control grants access to privileged functions, enabling fund drainage, parameter manipulation, and full contract takeover. The severity and profitability are both maximal, as an attacker can immediately exploit this to steal assets or disrupt operations.",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 9,
+        "reason": "The setOwner function lacks the onlyOwner modifier, allowing any caller to arbitrarily change the contract owner. This enables an attacker to take full control of the contract, including privileged functions like uploadBalances, setExportFee, or unlockToken. Once ownership is hijacked, the attacker can drain funds, manipulate fees, or disrupt the contract's operation.",
+        "code": "function setOwner(address _owner) returns (bool success) { owner = _owner; return true; }",
+        "label": "Access Control",
+        "file_name": "2018-10666.sol",
+        "description": "The Owned smart contract implementation for Aurora IDEX Membership (IDXM), an Ethereum ERC20 token, allows attackers to acquire contract ownership because the setOwner function is declared as public. A new owner can subsequently modify variables."
+    },
+    {
+        "function_name": "transfer",
+        "vulnerability": "Integer overflow/underflow",
+        "criticism": "The reasoning is incorrect. While the code uses raw arithmetic, the function includes require(balanceOf[msg.sender] >= _amount) and require(balanceOf[_to] + _amount >= balanceOf[_to]), which explicitly prevent underflow (sender balance) and overflow (recipient balance). These checks render the SafeMath argument moot. The vulnerability claim is invalid, as the code already enforces overflow/underflow safety through conditionals. No exploit path exists here.",
+        "correctness": 1,
+        "severity": 0,
+        "profitability": 0,
+        "reason": "The transfer and transferFrom functions use raw arithmetic operations (e.g., balanceOf[msg.sender] -= _amount) without leveraging the inherited SafeMath library. In Solidity <0.8.0, this allows integer underflows/overflows. An attacker can send tokens they don\u2019t own (underflow to max uint256) or overflow a recipient\u2019s balance to near-zero. This directly compromises the token\u2019s integrity and enables theft or denial of service.",
+        "code": "function transfer(address _to, uint256 _amount) returns (bool success) { require(!locked); require(balanceOf[msg.sender] >= _amount); require(balanceOf[_to] + _amount >= balanceOf[_to]); balanceOf[msg.sender] -= _amount; uint256 preBalance = balanceOf[_to]; balanceOf[_to] += _amount; bool alreadyMax = preBalance >= singleIDXMQty; if (!alreadyMax) { if (now >= validAfter[_to].ts + mustHoldFor) validAfter[_to].last = preBalance; validAfter[_to].ts = now; } if (validAfter[msg.sender].last > balanceOf[msg.sender]) validAfter[msg.sender].last = balanceOf[msg.sender]; Transfer(msg.sender, _to, _amount); return true; }",
+        "label": "Access Control",
+        "file_name": "2018-10666.sol",
+        "description": "The Owned smart contract implementation for Aurora IDEX Membership (IDXM), an Ethereum ERC20 token, allows attackers to acquire contract ownership because the setOwner function is declared as public. A new owner can subsequently modify variables."
+    },
+    {
+        "function_name": "approve",
+        "vulnerability": "Allowance front-running",
+        "criticism": "The reasoning is valid. The approve function lacks a mitigation for the front-running race condition (e.g., requiring allowance reset to zero before non-zero updates). Attackers can exploit this to double-spend allowances if users adjust approvals. However, severity is moderate (7) as exploitation requires specific user behavior (changing existing non-zero allowances) and mempool monitoring. Profitability is high (7) if successful, but contingent on victim actions.",
+        "correctness": 9,
+        "severity": 7,
+        "profitability": 7,
+        "reason": "The approve function does not enforce the check-effects-interaction pattern or require resetting allowances to zero before updating. Attackers can front-run a user\u2019s approval change (e.g., from 100 to 50) by first using the old allowance (100) before it\u2019s reduced. This allows double-spending of allowances, enabling unauthorized token transfers from the victim\u2019s balance.",
+        "code": "function approve(address _spender, uint256 _amount) returns (bool success) { require(!locked); allowance[msg.sender][_spender] = _amount; Approval(msg.sender, _spender, _amount); return true; }",
+        "label": "Access Control",
+        "file_name": "2018-10666.sol",
+        "description": "The Owned smart contract implementation for Aurora IDEX Membership (IDXM), an Ethereum ERC20 token, allows attackers to acquire contract ownership because the setOwner function is declared as public. A new owner can subsequently modify variables."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-10705.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-10705.json
new file mode 100644
index 00000000..fab023d3
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-10705.json
@@ -0,0 +1,41 @@
+[
+    {
+        "function_name": "setOwner",
+        "vulnerability": "Unrestricted Ownership Transfer",
+        "criticism": "The reasoning is entirely correct. The absence of an onlyOwner modifier allows any address to change the owner, leading to full contract control. This is a critical vulnerability because ownership privileges often include fund control and administrative functions. The severity and profitability are maximized since an attacker can immediately drain funds or disrupt the contract. The exploit requires no preconditions and is trivially executable.",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 9,
+        "reason": "The setOwner function lacks the onlyOwner modifier, allowing any address to arbitrarily change the contract owner. This enables an attacker to immediately take full control of the contract, including privileged functions like unlockToken and uploadBalances, leading to fund theft or contract destruction.",
+        "code": "function setOwner(address _owner) returns (bool success) { owner = _owner; return true; }",
+        "label": "Access Control",
+        "file_name": "2018-10705.sol",
+        "description": "The Owned smart contract implementation for Aurora DAO (AURA), an Ethereum ERC20 token, allows attackers to acquire contract ownership because the setOwner function is declared as public. An attacker can then conduct a lockBalances() denial of service attack."
+    },
+    {
+        "function_name": "uploadBalances",
+        "vulnerability": "Array Length Mismatch Token Loss",
+        "criticism": "The reasoning is partially correct but misses critical context. While unequal array lengths can cause out-of-bounds reads (returning 0 in legacy Solidity versions), the actual token loss occurs only if recipients.length > balances.length. In such cases, the owner's balance is reduced by the sum of the valid balances array, but excess recipients receive 0 tokens, effectively burning the sum. However, this requires the owner to mistakenly call the function with mismatched arrays. Since the function is onlyOwner, external attackers cannot trigger this. Severity is moderate (owner-induced error), and profitability is negligible for attackers.",
+        "correctness": 6,
+        "severity": 5,
+        "profitability": 0,
+        "reason": "The uploadBalances function does not enforce equal lengths for recipients and balances arrays. If recipients.length > balances.length, balances[i] returns 0 beyond the balances array's end, causing the owner's balance to be reduced by the sum of the valid balances while recipients receive incorrect (often zero) amounts. This permanently burns the sum from the owner's balance, leading to irreversible token loss.",
+        "code": "function uploadBalances(address[] recipients, uint256[] balances) onlyOwner { require(!balancesUploaded); uint256 sum = 0; for (uint256 i = 0; i < recipients.length; i++) { balanceOf[recipients[i]] = safeAdd(balanceOf[recipients[i]], balances[i]); sum = safeAdd(sum, balances[i]); } balanceOf[owner] = safeSub(balanceOf[owner], sum); }",
+        "label": "Access Control",
+        "file_name": "2018-10705.sol",
+        "description": "The Owned smart contract implementation for Aurora DAO (AURA), an Ethereum ERC20 token, allows attackers to acquire contract ownership because the setOwner function is declared as public. An attacker can then conduct a lockBalances() denial of service attack."
+    },
+    {
+        "function_name": "approve",
+        "vulnerability": "Allowance Race Condition",
+        "criticism": "The reasoning correctly identifies the ERC20 front-running risk, but this is a protocol-level limitation, not a code flaw. The function follows the ERC20 standard, which does not mandate allowance resetting. The severity is moderate because exploitation depends on user behavior (e.g., not resetting allowances). Profitability is context-dependent: if high-value allowances exist, attackers could profit by front-running reduction attempts. However, this is a known ERC20 trade-off, not a unique contract vulnerability.",
+        "correctness": 5,
+        "severity": 4,
+        "profitability": 6,
+        "reason": "The approve function does not mitigate the ERC20 allowance front-running attack. If a user reduces their approval for a spender, the spender can front-run the transaction to use the old allowance before the reduction. This allows attackers to drain funds up to the previous higher allowance, especially impactful once the contract is unlocked.",
+        "code": "function approve(address _spender, uint256 _value) public returns (bool success) { require(!locked); allowance[msg.sender][_spender] = _value; return true; }",
+        "label": "Access Control",
+        "file_name": "2018-10705.sol",
+        "description": "The Owned smart contract implementation for Aurora DAO (AURA), an Ethereum ERC20 token, allows attackers to acquire contract ownership because the setOwner function is declared as public. An attacker can then conduct a lockBalances() denial of service attack."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-11335.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-11335.json
new file mode 100644
index 00000000..ca5dcbd5
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-11335.json
@@ -0,0 +1,41 @@
+[
+    {
+        "function_name": "mint",
+        "vulnerability": "Integer overflow in minting",
+        "criticism": "The reasoning is partially correct. While the absence of SafeMath could theoretically allow overflows, Solidity \u22650.8.0 automatically checks for overflows. If the contract uses an older compiler, the require(totalSupply + value <= TOKEN_LIMIT) check is vulnerable to overflow bypass (e.g., wrapping to 0). However, the attacker must control the `ico` address to exploit this, which limits exploitability. Severity is high only if `ico` is compromised. Profitability depends on the attacker's ability to mint beyond TOKEN_LIMIT and dump tokens.",
+        "correctness": 8,
+        "severity": 7,
+        "profitability": 6,
+        "reason": "The mint function does not use SafeMath for addition, allowing integer overflows. The require statement 'totalSupply + value <= TOKEN_LIMIT' can be bypassed if totalSupply + value overflows, resulting in a wrapped value that is within the limit. Additionally, 'balances[holder] += value' and 'totalSupply += value' can overflow, leading to incorrect token balances and total supply. An attacker with control over the ico address could exploit this to mint tokens beyond the intended TOKEN_LIMIT or corrupt balances.",
+        "code": "function mint(address holder, uint value) public {\n    require(msg.sender == ico);\n    require(value > 0);\n    require(totalSupply + value <= TOKEN_LIMIT);\n    balances[holder] += value;\n    totalSupply += value;\n    Transfer(0x0, holder, value);\n}",
+        "label": "Integer Overflow",
+        "file_name": "2018-11335.sol",
+        "description": "GVToken Genesis Vision (GVT) is a smart contract running on Ethereum. The mint function has an integer overflow that allows minted tokens to be arbitrarily retrieved by the contract owner."
+    },
+    {
+        "function_name": "setMigrationAgent",
+        "vulnerability": "Privilege escalation via migration agent",
+        "criticism": "The reasoning is accurate. The function centralizes trust in `migrationMaster`, creating a single point of failure. If compromised, an attacker can set a malicious agent to drain user funds during migration. This is a critical vulnerability if `migrationMaster` is an EOA or poorly secured contract. Severity is high due to the potential for total fund loss. Profitability is extreme if the agent steals migrating tokens.",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 9,
+        "reason": "The setMigrationAgent function allows the migrationMaster to set a malicious migration agent contract once. If the migrationMaster's account is compromised, an attacker can set a malicious agent. Users who call migrate() will have their tokens transferred to the attacker's contract via MigrationAgent.migrateFrom, resulting in loss of funds. This centralizes trust in migrationMaster, creating a single point of failure.",
+        "code": "function setMigrationAgent(address _agent) external {\n    require(migrationAgent == 0);\n    require(msg.sender == migrationMaster);\n    migrationAgent = _agent;\n}",
+        "label": "Integer Overflow",
+        "file_name": "2018-11335.sol",
+        "description": "GVToken Genesis Vision (GVT) is a smart contract running on Ethereum. The mint function has an integer overflow that allows minted tokens to be arbitrarily retrieved by the contract owner."
+    },
+    {
+        "function_name": "approve",
+        "vulnerability": "ERC20 approve front-running",
+        "criticism": "The reasoning is correct but overstates the risk. The function inherits the standard ERC20 front-running issue, where changing a non-zero allowance requires first resetting to zero. However, this is a well-known limitation of ERC20, not a code flaw. Severity is moderate since it relies on user error (not resetting allowances). Profitability is low unless users recklessly adjust allowances for untrusted spenders.",
+        "correctness": 7,
+        "severity": 3,
+        "profitability": 2,
+        "reason": "The approve function is vulnerable to the ERC20 race condition. If a user changes the approval amount from a non-zero value to another non-zero value, a malicious spender can front-run the transaction, using the old allowance before it's reduced. This can lead to unintended allowance usage. Although increaseApproval/decreaseApproval exist, the standard approve remains risky, especially when users are unaware of the race condition.",
+        "code": "function approve(address _spender, uint _value) public returns (bool) {\n    require(!isFrozen);\n    return super.approve(_spender, _value);\n}",
+        "label": "Integer Overflow",
+        "file_name": "2018-11335.sol",
+        "description": "GVToken Genesis Vision (GVT) is a smart contract running on Ethereum. The mint function has an integer overflow that allows minted tokens to be arbitrarily retrieved by the contract owner."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-12025.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-12025.json
new file mode 100644
index 00000000..78e9ded5
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-12025.json
@@ -0,0 +1,41 @@
+[
+    {
+        "function_name": "transferFrom",
+        "vulnerability": "Inverted Allowance Check & Underflow",
+        "criticism": "The reasoning is correct. The inverted check allows transfers when allowance is insufficient, and the underflow (due to Solidity 0.4.2) sets the allowance to a massive value. This allows attackers to drain the victim's balance after one underflow. The severity is critical (direct theft) and profitability is extremely high. The code flaw is unambiguous and exploitable.",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 9,
+        "reason": "The condition `if( allowed[from][msg.sender] >= value ) return false;` is inverted. This allows transfers when the allowance is **insufficient** (allowed < value) instead of enforcing it. Furthermore, when `allowed[from][msg.sender]` is less than `value`, the line `allowed[from][msg.sender] -= value;` underflows (due to Solidity 0.4.2's lack of overflow checks), setting the allowance to a massive value (2^256 - X). Attackers can exploit this to gain infinite approval after one underflow, enabling unlimited token transfers from the victim's account.",
+        "code": "function transferFrom(address from, address to, uint value) returns (bool success) { if (frozenAccount[msg.sender]) return false; if(balances[from] < value) return false; if( allowed[from][msg.sender] >= value ) return false; if(balances[to] + value < balances[to]) return false; balances[from] -= value; allowed[from][msg.sender] -= value; balances[to] += value; Transfer(from, to, value); return true; }",
+        "label": "Wrong Logic",
+        "file_name": "2018-12025.sol",
+        "description": "The transferFrom function of a smart contract implementation for FuturXE (FXE), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized transfer of digital assets because of a logic error. The developer messed up with the boolean judgment - if the input value is smaller than or equal to allowed value, the transfer session would stop execution by returning false. This makes no sense, because the transferFrom() function should require the transferring value to not exceed the allowed value in the first place. Suppose this function asks for the allowed value to be smaller than the input. Then, the attacker could easily ignore the allowance: after this condition, the `allowed[from][msg.sender] -= value;` would cause an underflow because the allowed part is smaller than the value. The attacker could transfer any amount of FuturXe tokens of any accounts to an appointed account (the `_to` address) because the allowed value is initialized to 0, and the attacker could bypass this restriction even without the victim's private key."
+    },
+    {
+        "function_name": "transferFrom",
+        "vulnerability": "Incorrect Frozen Account Check",
+        "criticism": "The reasoning is accurate. The check on `msg.sender` (spender) instead of `from` (token owner) allows transfers from frozen accounts via approved spenders. Severity is high if freezing is meant to block all transfers. Profitability depends on attackers having prior approval, but it violates core security assumptions.",
+        "correctness": 9,
+        "severity": 8,
+        "profitability": 7,
+        "reason": "The function checks `frozenAccount[msg.sender]` (spender's status) instead of `frozenAccount[from]` (token owner's status). A frozen account (from) can still have its tokens transferred via an approved spender (msg.sender) as long as the spender is not frozen. This violates the intended freezing logic, allowing attackers to bypass account freezes by using approved addresses.",
+        "code": "function transferFrom(address from, address to, uint value) returns (bool success) { if (frozenAccount[msg.sender]) return false; if(balances[from] < value) return false; if( allowed[from][msg.sender] >= value ) return false; if(balances[to] + value < balances[to]) return false; balances[from] -= value; allowed[from][msg.sender] -= value; balances[to] += value; Transfer(from, to, value); return true; }",
+        "label": "Wrong Logic",
+        "file_name": "2018-12025.sol",
+        "description": "The transferFrom function of a smart contract implementation for FuturXE (FXE), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized transfer of digital assets because of a logic error. The developer messed up with the boolean judgment - if the input value is smaller than or equal to allowed value, the transfer session would stop execution by returning false. This makes no sense, because the transferFrom() function should require the transferring value to not exceed the allowed value in the first place. Suppose this function asks for the allowed value to be smaller than the input. Then, the attacker could easily ignore the allowance: after this condition, the `allowed[from][msg.sender] -= value;` would cause an underflow because the allowed part is smaller than the value. The attacker could transfer any amount of FuturXe tokens of any accounts to an appointed account (the `_to` address) because the allowed value is initialized to 0, and the attacker could bypass this restriction even without the victim's private key."
+    },
+    {
+        "function_name": "approve",
+        "vulnerability": "Unsafe ERC20 Approve",
+        "criticism": "The reasoning is valid but overstates severity. The lack of a zero-reset check enables front-running, but this is a known ERC20 design flaw, not a code-specific bug. Severity is moderate (requires user error) and profitability is medium (depends on user behavior).",
+        "correctness": 7,
+        "severity": 5,
+        "profitability": 5,
+        "reason": "The `approve` function does not include a check for the front-running race condition. If a user changes their approval from a non-zero value to another non-zero value, an attacker can front-run the transaction to use the old approval before it is reset. While this is a known ERC20 design flaw, its presence here allows attackers to steal funds if users naively adjust approvals without first setting them to zero.",
+        "code": "function approve(address _spender, uint256 _amount) returns (bool success) { allowed[msg.sender][_spender] = _amount; Approval(msg.sender, _spender, _amount); return true; }",
+        "label": "Wrong Logic",
+        "file_name": "2018-12025.sol",
+        "description": "The transferFrom function of a smart contract implementation for FuturXE (FXE), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized transfer of digital assets because of a logic error. The developer messed up with the boolean judgment - if the input value is smaller than or equal to allowed value, the transfer session would stop execution by returning false. This makes no sense, because the transferFrom() function should require the transferring value to not exceed the allowed value in the first place. Suppose this function asks for the allowed value to be smaller than the input. Then, the attacker could easily ignore the allowance: after this condition, the `allowed[from][msg.sender] -= value;` would cause an underflow because the allowed part is smaller than the value. The attacker could transfer any amount of FuturXe tokens of any accounts to an appointed account (the `_to` address) because the allowed value is initialized to 0, and the attacker could bypass this restriction even without the victim's private key."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-13836.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-13836.json
new file mode 100644
index 00000000..2dcedde3
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-13836.json
@@ -0,0 +1,41 @@
+[
+    {
+        "function_name": "multiTransfer",
+        "vulnerability": "Integer Overflow in Token Transfer",
+        "criticism": "The reasoning is correct. In Solidity <0.8.0, integer overflow is not automatically checked. The summation of `_amounts` in a loop can overflow, allowing an attacker to bypass the balance check and mint tokens. This directly violates the token's integrity, enabling theft. Severity is critical as it breaks the core token economics. Profitability is high because attackers can create tokens arbitrarily and drain value.",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 9,
+        "reason": "The `multiTransfer` function calculates `totalAmount` by summing all `_amounts` without overflow checks. Using Solidity 0.4.18 (which lacks automatic overflow protection), an attacker can craft `_amounts` values that overflow `totalAmount`, bypassing the `balances[msg.sender] >= totalAmount` check. For example, if the sum overflows to a small value, the attacker's balance is reduced minimally, but recipients receive large amounts, effectively stealing tokens from the contract.",
+        "code": "function multiTransfer(address[] _addresses, uint[] _amounts) public returns (bool success) { require(_addresses.length <= 100 && _addresses.length == _amounts.length); uint totalAmount; for (uint a = 0; a < _amounts.length; a++) { totalAmount += _amounts[a]; } require(totalAmount > 0 && balances[msg.sender] >= totalAmount); balances[msg.sender] -= totalAmount; for (uint b = 0; b < _addresses.length; b++) { if (_amounts[b] > 0) { balances[_addresses[b]] += _amounts[b]; Transfer(msg.sender, _addresses[b], _amounts[b]); } } return true; }",
+        "label": "Integer Overflow",
+        "file_name": "2018-13836.sol",
+        "description": "An integer overflow vulnerability exists in the function multiTransfer of Rocket Coin (XRC), an Ethereum token smart contract. An attacker could use it to set any user's balance."
+    },
+    {
+        "function_name": "approve",
+        "vulnerability": "Front-Runnable Approval",
+        "criticism": "The reasoning is valid. The absence of a zero-reset in `approve` allows front-running when reducing allowances. However, this is a known ERC-20 design limitation, not a code flaw. Severity is moderate as it depends on user behavior (e.g., reducing allowances). Profitability is context-dependent but possible if allowances are large. The vulnerability is real but inherent to the standard pattern.",
+        "correctness": 8,
+        "severity": 6,
+        "profitability": 7,
+        "reason": "The `approve` function allows a user to set a new allowance without first resetting it to zero. An attacker can front-run a user's approval reduction (e.g., from 5 to 3) by observing the transaction in the mempool and executing a `transferFrom` with the old allowance (5) before it is reduced. This enables double-spending of the originally approved amount, violating the user's intended authorization limits.",
+        "code": "function approve(address _spender, uint256 _amount) public returns (bool success) { allowed[msg.sender][_spender] = _amount; Approval(msg.sender, _spender, _amount); return true; }",
+        "label": "Integer Overflow",
+        "file_name": "2018-13836.sol",
+        "description": "An integer overflow vulnerability exists in the function multiTransfer of Rocket Coin (XRC), an Ethereum token smart contract. An attacker could use it to set any user's balance."
+    },
+    {
+        "function_name": "fallback function",
+        "vulnerability": "Trapped ETH with No Handling",
+        "criticism": "The reasoning is accurate. The `payable` fallback function does not handle incoming ETH, leading to permanent loss. Severity is high for users but low for the contract itself. Profitability is zero for attackers, but user funds are irrecoverable. The flaw is a design oversight, making it critical for user experience but not directly exploitable for profit.",
+        "correctness": 9,
+        "severity": 7,
+        "profitability": 0,
+        "reason": "The fallback function is `payable` but does not process incoming ETH. Users may mistakenly send ETH (e.g., assuming it's required for the airdrop), which becomes permanently locked in the contract. While the airdrop itself does not require ETH, the contract's design misleads users into sending funds that are never used or returned, resulting in accidental financial loss.",
+        "code": "function() public payable { require(airDropStatus && balances[owner] >= airDropAmount && !participants[msg.sender] && tx.gasprice >= airDropGasPrice); balances[owner] -= airDropAmount; balances[msg.sender] += airDropAmount; Transfer(owner, msg.sender, airDropAmount); participants[msg.sender] = true; }",
+        "label": "Integer Overflow",
+        "file_name": "2018-13836.sol",
+        "description": "An integer overflow vulnerability exists in the function multiTransfer of Rocket Coin (XRC), an Ethereum token smart contract. An attacker could use it to set any user's balance."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-15552.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-15552.json
new file mode 100644
index 00000000..491a2d09
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-15552.json
@@ -0,0 +1,41 @@
+[
+    {
+        "function_name": "withdraw",
+        "vulnerability": "Owner can steal funds mid-lottery",
+        "criticism": "The reasoning is accurate. The withdraw() function allows the owner to drain the contract balance and reset state variables at any time, even mid-lottery. This is a critical centralization risk. Correctness is 9 because the code explicitly enables this. Severity is 9 because it directly enables fund theft. Profitability is 9 for the owner (though not an external attacker), but since the vulnerability centers on owner abuse, the exploit potential is maximal.",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 9,
+        "reason": "The withdraw() function allows the owner to reset the lottery state (numtickets, totalBounty) and transfer the entire contract balance to themselves at any time, including during an active round. This enables the owner to steal all accumulated ticket funds from participants before the lottery completes. Participants who already bought tickets would lose their ETH without any reward distribution.",
+        "code": "function withdraw() public { require(worldOwner == msg.sender); lottoIndex += 1; numtickets = 0; totalBounty = 0; worldOwner.transfer(this.balance); }",
+        "label": "Bad Randomness",
+        "file_name": "2018-15552.sol",
+        "description": "The \"PayWinner\" function of a simplelottery smart contract implementation for The Ethereum Lottery, an Ethereum gambling game, generates a random value with publicly readable variable \"maxTickets\" (which is private, yet predictable and readable by the eth.getStorageAt function). Therefore, it allows attackers to always win and get rewards."
+    },
+    {
+        "function_name": "PayWinner",
+        "vulnerability": "DoS via failed winner transfer",
+        "criticism": "The analysis is correct. Using transfer() without handling failures can permanently brick the contract. If the winner is a non-payable contract, the transfer reverts, leaving numtickets == maxTickets and blocking AddTicket() indefinitely. Correctness is 9 (code uses unsafe transfer). Severity is 8 (permanent DoS), but profitability is 2: attackers can disrupt the contract but gain little unless they sabotage for ideological reasons. The vulnerability is severe for system availability but offers limited direct profit.",
+        "correctness": 9,
+        "severity": 8,
+        "profitability": 2,
+        "reason": "PayWinner uses transfer() to send funds to the winner. If the winner is a contract without a payable fallback function, the transfer will fail, reverting the entire transaction. This leaves the contract state (numtickets == maxTickets) unchanged, permanently blocking the AddTicket function (due to its numtickets < maxTickets check). Attackers can exploit this by purchasing the last ticket with a non-payable address to intentionally brick the contract.",
+        "code": "function PayWinner( address winner ) private { require(numtickets == maxTickets); uint ownerTax = 6 * totalBounty / 100; uint winnerPrice = totalBounty - ownerTax; LottoComplete(msg.sender, lottoIndex, winnerPrice); lottoIndex += 1; numtickets = 0; totalBounty = 0; if(_direction == 0 && maxTickets < 20) maxTickets += 1; if(_direction == 1 && maxTickets > 10) maxTickets -= 1; if(_direction == 0 && maxTickets == 20) _direction = 1; if(_direction == 1 && maxTickets == 10) _direction = 0; worldOwner.transfer(ownerTax); winner.transfer(winnerPrice); }",
+        "label": "Bad Randomness",
+        "file_name": "2018-15552.sol",
+        "description": "The \"PayWinner\" function of a simplelottery smart contract implementation for The Ethereum Lottery, an Ethereum gambling game, generates a random value with publicly readable variable \"maxTickets\" (which is private, yet predictable and readable by the eth.getStorageAt function). Therefore, it allows attackers to always win and get rewards."
+    },
+    {
+        "function_name": "AddTicket",
+        "vulnerability": "Predictable last-ticket winner selection",
+        "criticism": "The reasoning is valid. The winner is deterministically the last ticket purchaser, enabling MEV bots to front-run the final transaction. Correctness is 9 (code enforces this logic). Severity is 7 (violates fairness but doesn\u2019t directly drain funds). Profitability is 8 for attackers with MEV capabilities, as they can guarantee wins. However, this is more a design flaw than a traditional vulnerability; it assumes malicious actors can manipulate transaction ordering, which is inherent to Ethereum\u2019s mechanics.",
+        "correctness": 9,
+        "severity": 7,
+        "profitability": 8,
+        "reason": "The winner is deterministically set to the last address that submits a ticket when maxTickets is reached. Attackers can monitor the blockchain for pending transactions and front-run the final ticket purchase to guarantee they become the winner. This violates fair lottery mechanics and allows centralized exploitation by bots/MEV searchers.",
+        "code": "function AddTicket() public payable { require(msg.value == ticketPrice); require(numtickets < maxTickets); lastTicketTime = now; numtickets += 1; totalBounty += ticketPrice; bool success = numtickets == maxTickets; NewTicket(msg.sender, success); if(success) { PayWinner(msg.sender); } }",
+        "label": "Bad Randomness",
+        "file_name": "2018-15552.sol",
+        "description": "The \"PayWinner\" function of a simplelottery smart contract implementation for The Ethereum Lottery, an Ethereum gambling game, generates a random value with publicly readable variable \"maxTickets\" (which is private, yet predictable and readable by the eth.getStorageAt function). Therefore, it allows attackers to always win and get rewards."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-17877.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-17877.json
new file mode 100644
index 00000000..7751f68f
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-17877.json
@@ -0,0 +1,41 @@
+[
+    {
+        "function_name": "luckyBuy",
+        "vulnerability": "Insecure Pseudo-Randomness",
+        "criticism": "The reasoning is correct. The function relies entirely on predictable/miner-manipulable variables (block.timestamp, block.difficulty, etc.) to generate randomness. This allows miners or attackers to precompute favorable seeds and game the system. The severity is high as it directly undermines the fairness of the 'lucky' mechanism. Profitability is also high since attackers could systematically exploit this to win prizes. However, the impact depends on the value of the prize pool, which is not specified here.",
+        "correctness": 9,
+        "severity": 8,
+        "profitability": 8,
+        "reason": "The 'luckyBuy' function uses block.timestamp, block.difficulty, block.coinbase, and other predictable on-chain data to generate randomness. Miners can manipulate these values to influence the outcome, allowing attackers to increase their chances of winning the Luckybuy prize. This makes the randomness exploitable and not truly random.",
+        "code": "function luckyBuy() private view returns(bool) { uint256 seed = uint256(keccak256(abi.encodePacked( (block.timestamp).add (block.difficulty).add ((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add (block.gaslimit).add ((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add (block.number) ))); if((seed - ((seed / 1000) * 1000)) < luckybuyTracker_) return(true); else return(false); }",
+        "label": "Bad Randomness",
+        "file_name": "2018-17877.sol",
+        "description": "A lottery smart contract implementation for Greedy 599, an Ethereum gambling game, generates a random value that is predictable via an external contract call. The developer used the extcodesize() function to prevent a malicious contract from being called, but the attacker can bypass it by writing the core code in the constructor of their exploit code. Therefore, it allows attackers to always win and get rewards."
+    },
+    {
+        "function_name": "win",
+        "vulnerability": "DoS via Failed Transfer",
+        "criticism": "The reasoning is accurate. The use of transfer() without handling revert scenarios creates a critical DoS risk. If RoundLastGreedyMan[Round] is a contract with a non-payable fallback (e.g., gas-intensive or intentionally malicious), the transfer fails, blocking Round++ and freezing contract progression. Severity is extreme (9) since the entire protocol halts. Profitability is moderate (5) only if attackers can intentionally become RoundLastGreedyMan and trigger this to block competitors, but this requires specific preconditions.",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 5,
+        "reason": "The 'win' function uses transfer() to send ETH to RoundLastGreedyMan without handling potential failures. If the winner is a contract with a fallback function that reverts (e.g., due to gas limits or intentional sabotage), the transfer will fail, causing the entire transaction to revert. This prevents the round from incrementing, halting the contract indefinitely.",
+        "code": "function win() public { require(now > RoundTime[Round] && RoundTime[Round] != 0); RoundLastGreedyMan[Round].transfer(RoundETH[Round]); emit winnerEvent(RoundLastGreedyMan[Round], RoundETH[Round], Round); Round++; }",
+        "label": "Bad Randomness",
+        "file_name": "2018-17877.sol",
+        "description": "A lottery smart contract implementation for Greedy 599, an Ethereum gambling game, generates a random value that is predictable via an external contract call. The developer used the extcodesize() function to prevent a malicious contract from being called, but the attacker can bypass it by writing the core code in the constructor of their exploit code. Therefore, it allows attackers to always win and get rewards."
+    },
+    {
+        "function_name": "buyHeart",
+        "vulnerability": "Contract Call Bypass",
+        "criticism": "The reasoning is correct. The extcodesize check is ineffective during contract construction (constructor phase), allowing malicious contracts to bypass the 'humans only' restriction. Severity is high (7) if the contract relies on human exclusivity for anti-botting or fairness. Profitability is high (8) if automated contract interactions provide unfair advantages (e.g., sniping limited resources). The vulnerability is well-known but remains critical in contexts requiring human participation.",
+        "correctness": 9,
+        "severity": 7,
+        "profitability": 8,
+        "reason": "The 'buyHeart' function checks if the sender is a contract by checking extcodesize. However, during contract construction (constructor), extcodesize returns 0, allowing malicious contracts to bypass this check. Attackers can exploit this to automate purchases or manipulate the game logic, violating the 'humans only' requirement.",
+        "code": "function buyHeart(address referred) public payable { ... address _addr = msg.sender; uint256 _codeLength; assembly {_codeLength := extcodesize(_addr)} require(_codeLength == 0, \"sorry humans only\"); ... }",
+        "label": "Bad Randomness",
+        "file_name": "2018-17877.sol",
+        "description": "A lottery smart contract implementation for Greedy 599, an Ethereum gambling game, generates a random value that is predictable via an external contract call. The developer used the extcodesize() function to prevent a malicious contract from being called, but the attacker can bypass it by writing the core code in the constructor of their exploit code. Therefore, it allows attackers to always win and get rewards."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-17882.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-17882.json
new file mode 100644
index 00000000..5a02b3aa
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-17882.json
@@ -0,0 +1,41 @@
+[
+    {
+        "function_name": "transferFrom",
+        "vulnerability": "Unauthorized transfers to 'fights' address",
+        "criticism": "The reasoning correctly identifies that transfers to the 'fights' address bypass allowance checks. However, the severity depends on whether 'fights' is attacker-controlled. If 'fights' is immutable or non-malicious, the impact is limited to forced token burns or disruptions. If 'fights' can be set by the attacker (e.g., via compromised owner), severity increases. Profitability is moderate only if the attacker can extract value from 'fights'.",
+        "correctness": 9,
+        "severity": 7,
+        "profitability": 5,
+        "reason": "The transferFrom function does not check or deduct the allowance when transferring to the 'fights' address. This allows any user to transfer tokens from any account to the 'fights' address without requiring approval. An attacker can exploit this by setting 'fights' to a controlled address (if owner is compromised) or leveraging existing 'fights' access to drain funds from arbitrary accounts.",
+        "code": "function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {\n    balances[_to] = safeAdd(balances[_to], _value);\n    balances[_from] = safeSub(balances[_from], _value);\n    if (_to != fights) {\n        allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value);\n    }\n    Transfer(_from, _to, _value);\n    return true;\n}",
+        "label": "Integer Overflow",
+        "file_name": "2018-17882.sol",
+        "description": "An Integer overflow vulnerability exists in the batchTransfer function of a smart contract implementation for CryptoBotsBattle (CBTB), an Ethereum token. This vulnerability could be used by an attacker to create an arbitrary amount of tokens for any user."
+    },
+    {
+        "function_name": "batchTransfer",
+        "vulnerability": "Integer overflow in multiplication",
+        "criticism": "The reasoning is accurate. The lack of a safeMul check allows an attacker to force an overflow, deduct negligible tokens from their balance, and credit recipients with large amounts. This directly enables token inflation, making severity and profitability extremely high. The use of safeSub does not mitigate the unchecked multiplication.",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 9,
+        "reason": "The multiplication '_to.length * _value' in batchTransfer is vulnerable to integer overflow. An attacker can craft a large '_to.length' and '_value' such that the product overflows to a small value (e.g., 0). This allows them to bypass balance checks, deduct little/no tokens from their balance, while still crediting all recipients with '_value' tokens. This effectively mints tokens out of thin air.",
+        "code": "function batchTransfer(address[] _to, uint _value) public {\n    balances[msg.sender] = safeSub(\n        balances[msg.sender],\n        _to.length * _value\n    );\n    for (uint i = 0; i < _to.length; i++) {\n        balances[_to[i]] = safeAdd(balances[_to[i]], _value);\n        Transfer(msg.sender, _to[i], _value);\n    }\n}",
+        "label": "Integer Overflow",
+        "file_name": "2018-17882.sol",
+        "description": "An Integer overflow vulnerability exists in the batchTransfer function of a smart contract implementation for CryptoBotsBattle (CBTB), an Ethereum token. This vulnerability could be used by an attacker to create an arbitrary amount of tokens for any user."
+    },
+    {
+        "function_name": "transferFrom",
+        "vulnerability": "Incorrect allowance handling order",
+        "criticism": "The code does update balances before allowances, but safeSub ensures allowance underflow reverts the transaction, preventing direct exploitation. While violating checks-effects-interactions, there are no external calls to enable reentrancy. The reasoning overstates the risk; this is a code-style issue, not an active vulnerability. Severity and profitability are negligible.",
+        "correctness": 3,
+        "severity": 1,
+        "profitability": 0,
+        "reason": "The transferFrom function updates balances before modifying allowances. While safe for non-fights addresses (due to revert on underflow), this violates the checks-effects-interactions pattern. If external calls were present, this could enable reentrancy. Though not directly exploitable here, it reflects poor security practices and increases risk if contract logic evolves.",
+        "code": "function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {\n    balances[_to] = safeAdd(balances[_to], _value);\n    balances[_from] = safeSub(balances[_from], _value);\n    if (_to != fights) {\n        allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value);\n    }\n    Transfer(_from, _to], _value);\n    return true;\n}",
+        "label": "Integer Overflow",
+        "file_name": "2018-17882.sol",
+        "description": "An Integer overflow vulnerability exists in the batchTransfer function of a smart contract implementation for CryptoBotsBattle (CBTB), an Ethereum token. This vulnerability could be used by an attacker to create an arbitrary amount of tokens for any user."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-18425.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-18425.json
new file mode 100644
index 00000000..79be611a
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-18425.json
@@ -0,0 +1,41 @@
+[
+    {
+        "function_name": "approve",
+        "vulnerability": "Non-standard ERC20 allowance freeze",
+        "criticism": "The reasoning is correct. The function enforces a non-standard ERC20 behavior by blocking non-zero allowance updates, requiring users to reset to zero first. This creates a front-running risk during allowance adjustments. However, the severity is moderate because it primarily affects compatibility with standard contracts rather than enabling direct theft. Profitability for attackers is low, as exploitation requires specific user actions (allowance changes) and only allows stealing up to the original allowance amount.",
+        "correctness": 9,
+        "severity": 6,
+        "profitability": 3,
+        "reason": "The approve function prevents updating an existing non-zero allowance to another non-zero value. This violates ERC20 standards and forces users to reset their allowance to zero first, creating a race condition vulnerable to front-running attacks. Contracts/DEXs expecting standard behavior will fail when users try to adjust allowances, breaking compatibility and potentially locking funds.",
+        "code": "function approve(address _spender, uint256 _value) public returns (bool success) { if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; } allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; }",
+        "label": "Token Devalue",
+        "file_name": "2018-18425.sol",
+        "description": "The doAirdrop function of a smart contract implementation for Primeo (PEO), an Ethereum token, does not check the numerical relationship between the amount of the air drop and the token's total supply, which lets the owner of the contract issue an arbitrary amount of currency. (Increasing the total supply by using 'doAirdrop' ignores the hard cap written in the contract and devalues the token.)"
+    },
+    {
+        "function_name": "withdraw",
+        "vulnerability": "Owner ETH drain",
+        "criticism": "The reasoning is accurate. The function allows immediate full ETH extraction by the owner with no safeguards. This is a critical centralization risk and direct scam vector. Severity is extreme (9) as it enables total fund loss. However, profitability scores 0 under the assumption that scoring reflects external attacker profit potential - this is strictly owner abuse. From a system impact perspective, this is a 9/9 vulnerability, but following prior example conventions for privileged roles, external attackers cannot exploit it.",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 0,
+        "reason": "The withdraw function allows the owner to drain all ETH from the contract at any time. Users sending ETH during token distribution have no guarantee their funds will be used as intended. This creates a direct financial scam vector where the owner can collect ETH and disappear without distributing proper token value.",
+        "code": "function withdraw() onlyOwner public { address myAddress = this; uint256 etherBalance = myAddress.balance; owner.transfer(etherBalance); }",
+        "label": "Token Devalue",
+        "file_name": "2018-18425.sol",
+        "description": "The doAirdrop function of a smart contract implementation for Primeo (PEO), an Ethereum token, does not check the numerical relationship between the amount of the air drop and the token's total supply, which lets the owner of the contract issue an arbitrary amount of currency. (Increasing the total supply by using 'doAirdrop' ignores the hard cap written in the contract and devalues the token.)"
+    },
+    {
+        "function_name": "doAirdrop",
+        "vulnerability": "Supply cap bypass",
+        "criticism": "The analysis is fully correct. The pre-addition check allows minting beyond totalSupply when totalDistributed is near the cap. This completely breaks the token's supply guarantee, enabling hyperinflation. Severity is catastrophic (9) as it undermines the token's fundamental economics. Profitability scores 0 for external attackers (assuming internal/owner-only access), but the owner could theoretically profit by minting unlimited tokens. Following example conventions for owner privileges, we score profitability 0 despite massive owner abuse potential.",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 0,
+        "reason": "The doAirdrop function only checks if totalDistributed < totalSupply BEFORE adding new tokens. If totalDistributed is 1 unit less than totalSupply, the owner can airdrop any amount (e.g., 1B tokens), causing totalDistributed to exceed totalSupply. This breaks the token's supply cap, enabling infinite inflation and total devaluation of the token.",
+        "code": "function doAirdrop(address _participant, uint _amount) internal { require( _amount > 0 ); require( totalDistributed < totalSupply ); balances[_participant] = balances[_participant].add(_amount); totalDistributed = totalDistributed.add(_amount); if (totalDistributed >= totalSupply) { distributionFinished = true; } emit Airdrop(_participant, _amount, balances[_participant]); emit Transfer(address(0), _participant, _amount); }",
+        "label": "Token Devalue",
+        "file_name": "2018-18425.sol",
+        "description": "The doAirdrop function of a smart contract implementation for Primeo (PEO), an Ethereum token, does not check the numerical relationship between the amount of the air drop and the token's total supply, which lets the owner of the contract issue an arbitrary amount of currency. (Increasing the total supply by using 'doAirdrop' ignores the hard cap written in the contract and devalues the token.)"
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-19830.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-19830.json
new file mode 100644
index 00000000..b0cbb5df
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2018-19830.json
@@ -0,0 +1,41 @@
+[
+    {
+        "function_name": "UBSexToken",
+        "vulnerability": "Insecure Initialization via Public Function",
+        "criticism": "The reasoning assumes the function is public due to a mismatched constructor name. However, if the contract is named 'UBSexToken', this is a valid constructor (pre-Solidity 0.4.22) and cannot be called post-deployment. The vulnerability only exists if the contract name differs, which is not confirmed here. Thus, the analysis is contextually flawed. If correct (contract name mismatch), severity would be catastrophic, but the assumption is unverified.",
+        "correctness": 2,
+        "severity": 0,
+        "profitability": 0,
+        "reason": "The function UBSexToken() is not a constructor (mismatched contract name) and is publicly callable. Attackers can invoke it post-deployment to reset the owner, totalSupply, and balances, effectively hijacking the contract. This allows an attacker to mint the entire token supply to themselves and gain ownership, leading to total control over the contract.",
+        "code": "function UBSexToken() { owner = msg.sender; totalSupply = 1.9 * 10 ** 26; balances[owner] = totalSupply; }",
+        "label": "Access Control",
+        "file_name": "2018-19830.sol",
+        "description": "The UBSexToken() function of a smart contract implementation for Business Alliance Financial Circle (BAFC), an tradable Ethereum ERC20 token, allows attackers to change the owner of the contract, because the function is public (by default) and does not check the caller's identity."
+    },
+    {
+        "function_name": "transfer",
+        "vulnerability": "Missing ERC20 Return Value",
+        "criticism": "The reasoning is accurate: the function lacks a boolean return value, violating ERC20 standards. This breaks interoperability with ERC20-reliant systems, causing transactions to fail. However, the severity is high for contract usability but low for direct exploitation. Attackers cannot profit from this flaw, but it critically impacts the token's functionality.",
+        "correctness": 9,
+        "severity": 8,
+        "profitability": 2,
+        "reason": "The transfer function does not return a boolean as required by the ERC20 standard. Contracts/Wallets expecting ERC20 compliance will treat the missing return value as a failure, causing transactions to revert. This breaks interoperability with exchanges, DeFi protocols, and other ERC20-reliant systems.",
+        "code": "function transfer(address _to, uint _value) onlyPayloadSize(2 * 32) unFrozenAccount onlyTransferable { if (frozenAccount[_to]) { InvalidAccount(_to, \"The receiver account is frozen\"); } else { balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); } }",
+        "label": "Access Control",
+        "file_name": "2018-19830.sol",
+        "description": "The UBSexToken() function of a smart contract implementation for Business Alliance Financial Circle (BAFC), an tradable Ethereum ERC20 token, allows attackers to change the owner of the contract, because the function is public (by default) and does not check the caller's identity."
+    },
+    {
+        "function_name": "approve",
+        "vulnerability": "Unsafe Allowance Update",
+        "criticism": "The reasoning is correct. By enforcing a zero-reset before updating allowances, the function introduces a race condition. Attackers can front-run the reset transaction to exploit the old allowance. This is a well-documented ERC20 flaw with high severity and profitability, as malicious spenders can drain funds during the approval window.",
+        "correctness": 9,
+        "severity": 8,
+        "profitability": 8,
+        "reason": "The approve function throws when updating a non-zero allowance to another non-zero value. This forces users to reset allowance to zero first, creating a race condition where a spender can use the old allowance before it is updated. Attackers can front-run the second approval transaction to drain funds using the outdated allowance.",
+        "code": "function approve(address _spender, uint _value) unFrozenAccount { if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw; allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); }",
+        "label": "Access Control",
+        "file_name": "2018-19830.sol",
+        "description": "The UBSexToken() function of a smart contract implementation for Business Alliance Financial Circle (BAFC), an tradable Ethereum ERC20 token, allows attackers to change the owner of the contract, because the function is public (by default) and does not check the caller's identity."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2019-15078.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2019-15078.json
new file mode 100644
index 00000000..c8a4b515
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2019-15078.json
@@ -0,0 +1,41 @@
+[
+    {
+        "function_name": "approve",
+        "vulnerability": "Non-standard ERC20 approve",
+        "criticism": "The reasoning correctly identifies the ERC20 standard violation. By returning false when attempting to update a non-zero allowance, the function deviates from the ERC20 specification, which allows adjusting allowances from any value. This creates compatibility issues with contracts expecting standard behavior, enabling front-running attacks to lock approvals. However, the severity is reduced because modern UIs often handle allowance resets, and profitability depends on attacker ability to exploit front-running, which is situational. The direct financial impact is limited unless combined with other attack vectors.",
+        "correctness": 8,
+        "severity": 6,
+        "profitability": 4,
+        "reason": "The approve function returns false if attempting to update a non-zero allowance to another non-zero value, violating ERC20 standards. This prevents users from adjusting existing allowances without first resetting them to zero. Attackers can exploit this by front-running approval changes, causing transactions to fail or funds to be locked. Contracts expecting standard ERC20 behavior will misinterpret the false return value, leading to operational failures.",
+        "code": "function approve(address _spender, uint256 _value) public returns (bool success) {\n    if (_value != 0 && allowed[msg.sender][_spender] != 0) {\n        return false;\n    }\n    allowed[msg.sender][_spender] = _value;\n    emit Approval(msg.sender, _spender, _value);\n    return true;\n}",
+        "label": "Typo Constructor",
+        "file_name": "2019-15078.sol",
+        "description": "An issue was discovered in a smart contract implementation for AIRDROPX BORN through 2019-05-29, an Ethereum token. The name of the constructor has a typo (wrong case: XBornID versus XBORNID) that allows an attacker to change the owner of the contract and obtain cryptocurrency for free."
+    },
+    {
+        "function_name": "onlyPayloadSize",
+        "vulnerability": "Gas exhaustion via assert()",
+        "criticism": "The analysis is accurate. Using assert() instead of require() creates gas-draining potential, as failed assertions consume all transaction gas. This could be weaponized in short-address attacks or malformed payloads. Severity is high due to the irreversible gas loss, but profitability requires attackers to trick users into initiating the transactions (e.g., via phishing). While dangerous, real-world exploitation requires social engineering, making direct profitability moderate. The correctness score is high as the code flaw is unambiguous.",
+        "correctness": 9,
+        "severity": 8,
+        "profitability": 6,
+        "reason": "The onlyPayloadSize modifier uses assert() to validate transaction payload size. Unlike require(), assert() consumes all gas on failure. Attackers can craft malformed transactions (e.g., short-address attacks) to trigger this assertion, forcing victims to waste all gas. This enables gas-draining attacks and disrupts user transactions, directly benefiting attackers by increasing operational costs.",
+        "code": "modifier onlyPayloadSize(uint size) {\n    assert(msg.data.length >= size + 4);\n    _;\n}",
+        "label": "Typo Constructor",
+        "file_name": "2019-15078.sol",
+        "description": "An issue was discovered in a smart contract implementation for AIRDROPX BORN through 2019-05-29, an Ethereum token. The name of the constructor has a typo (wrong case: XBornID versus XBORNID) that allows an attacker to change the owner of the contract and obtain cryptocurrency for free."
+    },
+    {
+        "function_name": "getTokens",
+        "vulnerability": "ETH trapping with owner withdrawal",
+        "criticism": "The reasoning is partially correct. While the function accepts ETH without processing it, the vulnerability assumes the existence of a withdraw() function (not shown). If withdrawal logic exists, trapped ETH could be stolen by the owner. Severity depends on the contract's ETH balance size and user awareness. Profitability requires active social engineering to trick users into sending ETH. The code flaw itself (payable without value handling) is severe, but exploitation requires external factors, lowering immediate risk.",
+        "correctness": 7,
+        "severity": 7,
+        "profitability": 5,
+        "reason": "The getTokens function is payable but does not process or validate msg.value. Users can accidentally send ETH, which remains trapped in the contract. The owner can withdraw these funds via withdraw(), creating a risk of financial loss for users. Attackers can also social-engineer victims into sending ETH, effectively stealing funds through the owner's withdrawal capability.",
+        "code": "function getTokens() payable canDistr onlyWhitelist public {\n    if (value > totalRemaining) {\n        value = totalRemaining;\n    }\n    require(value <= totalRemaining);\n    address investor = msg.sender;\n    uint256 toGive = value;\n    distr(investor, toGive);\n    if (toGive > 0) {\n        blacklist[investor] = true;\n    }\n    if (totalDistributed >= totalSupply) {\n        distributionFinished = true;\n    }\n    value = value.div(100000).mul(99999);\n}",
+        "label": "Typo Constructor",
+        "file_name": "2019-15078.sol",
+        "description": "An issue was discovered in a smart contract implementation for AIRDROPX BORN through 2019-05-29, an Ethereum token. The name of the constructor has a typo (wrong case: XBornID versus XBORNID) that allows an attacker to change the owner of the contract and obtain cryptocurrency for free."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2019-15079.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2019-15079.json
new file mode 100644
index 00000000..92caaa97
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2019-15079.json
@@ -0,0 +1,41 @@
+[
+    {
+        "function_name": "EAI_TokenERC20",
+        "vulnerability": "Reinitialization Attack",
+        "criticism": "The reasoning is correct. The constructor name mismatch (EAI_TokenERC20 vs. contract EAI_TokenERC) makes it a public function. In Solidity versions <0.4.22, this allows anyone to reinitialize the contract, resetting critical state variables (totalSupply, name, symbol) and granting the attacker all tokens. This is a critical vulnerability: correctness is maximized because the exploit is unambiguous, severity is extreme (total contract hijack), and profitability is maximal (attacker gains full token control).",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 9,
+        "reason": "The constructor is incorrectly named (EAI_TokenERC20 vs. contract name EAI_TokenERC), making it a public function callable by anyone. Attackers can reinitialize the contract, resetting totalSupply, name, symbol, and assigning themselves the entire token supply. This allows them to mint unlimited tokens, overwrite the contract's state, and effectively hijack control.",
+        "code": "function EAI_TokenERC20( uint256 initialSupply, string tokenName, string tokenSymbol ) public { totalSupply = initialSupply * 10 ** uint256(decimals); balanceOf[msg.sender] = totalSupply; name = tokenName; symbol = tokenSymbol; }",
+        "label": "Typo Constructor",
+        "file_name": "2019-15079.sol",
+        "description": "A typo exists in the constructor of a smart contract implementation for EAI through 2019-06-05, an Ethereum token. This vulnerability could be used by an attacker to acquire EAI tokens for free."
+    },
+    {
+        "function_name": "_transfer",
+        "vulnerability": "Arithmetic Over/Underflow Risk",
+        "criticism": "The reasoning is partially flawed. While Solidity 0.4.16 lacks native overflow checks, the manual require(balanceOf[_to] + _value >= balanceOf[_to]) effectively prevents overflow by reverting if addition exceeds uint256. The asserted risk of previousBalances overflow is negligible (sum of two balances exceeding 2^256 is practically impossible). The actual vulnerability is minor: correctness is low because manual checks are sufficient, severity is minimal (no realistic exploit path), and profitability is nonexistent.",
+        "correctness": 2,
+        "severity": 1,
+        "profitability": 0,
+        "reason": "While manual overflow checks exist, the contract uses Solidity 0.4.16, which lacks native overflow protection. If edge cases bypass the require(balanceOf[_to] + _value >= balanceOf[_to]) check (e.g., via unexpected overflow wrapping), token balances could be corrupted. The assert may fail to detect overflow in previousBalances if the initial sum exceeds uint256 max, leading to inconsistent states.",
+        "code": "function _transfer(address _from, address _to, uint _value) internal { require(_to != 0x0); require(balanceOf[_from] >= _value); require(balanceOf[_to] + _value >= balanceOf[_to]); uint previousBalances = balanceOf[_from] + balanceOf[_to]; balanceOf[_from] -= _value; balanceOf[_to] += _value; emit Transfer(_from, _to, _value); assert(balanceOf[_from] + balanceOf[_to] == previousBalances); }",
+        "label": "Typo Constructor",
+        "file_name": "2019-15079.sol",
+        "description": "A typo exists in the constructor of a smart contract implementation for EAI through 2019-06-05, an Ethereum token. This vulnerability could be used by an attacker to acquire EAI tokens for free."
+    },
+    {
+        "function_name": "transferFrom",
+        "vulnerability": "Front-Running Allowance Race",
+        "criticism": "The reasoning is incorrect. In Solidity, state changes (allowance decrement) are atomic with the entire transaction. If _transfer reverts (e.g., due to insufficient balance), the allowance reduction is rolled back. There is no scenario where allowance is permanently reduced without a successful transfer. The alleged front-running exploit is invalid. Correctness is 0, as the vulnerability does not exist; severity and profitability are irrelevant.",
+        "correctness": 0,
+        "severity": 0,
+        "profitability": 0,
+        "reason": "The transferFrom function decrements the allowance before performing the transfer. If the transfer fails (e.g., due to a later revert in _transfer), the allowance is permanently reduced. Attackers could exploit this by front-running transactions to cause intentional failures, effectively locking users' allowances and disrupting expected behavior.",
+        "code": "function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) { require(_value <= allowance[_from][msg.sender]); allowance[_from][msg.sender] -= _value; _transfer(_from, _to, _value); return true; }",
+        "label": "Typo Constructor",
+        "file_name": "2019-15079.sol",
+        "description": "A typo exists in the constructor of a smart contract implementation for EAI through 2019-06-05, an Ethereum token. This vulnerability could be used by an attacker to acquire EAI tokens for free."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2019-15080.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2019-15080.json
new file mode 100644
index 00000000..12222dae
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2019-15080.json
@@ -0,0 +1,41 @@
+[
+    {
+        "function_name": "owned",
+        "vulnerability": "Publicly callable ownership takeover",
+        "criticism": "The reasoning is correct. The function 'owned()' is not a constructor (due to Solidity <0.4.22 naming rules) and remains publicly callable post-deployment, allowing anyone to reset ownership. This is a critical vulnerability as it grants full contract control. Severity is extreme (9) since ownership takeover enables all privileged functions. Profitability is high (9) for attackers exploiting this. However, correctness depends on deployment context; if the contract's actual constructor already initialized ownership, this function's existence is a catastrophic oversight.",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 9,
+        "reason": "The function 'owned()' is public and lacks access control, allowing any caller to set themselves as the owner. This is due to the incorrect naming of the constructor (should be 'Owned()' in Solidity <0.4.22). Since the MorphToken constructor sets the owner, this function should not exist, but it remains callable post-deployment, enabling anyone to reset ownership.",
+        "code": "function owned() public { owner = msg.sender; }",
+        "label": "Typo Constructor",
+        "file_name": "2019-15080.sol",
+        "description": "An issue was discovered in a smart contract implementation for MORPH Token through 2019-06-05, an Ethereum token. A typo in the constructor of the Owned contract (which is inherited by MORPH Token) allows attackers to acquire contract ownership. A new owner can subsequently obtain MORPH Tokens for free and can perform a DoS attack."
+    },
+    {
+        "function_name": "transferOwnership",
+        "vulnerability": "Unchecked zero-address ownership transfer",
+        "criticism": "The reasoning is correct. The lack of a zero-address check allows accidental or malicious ownership loss, permanently locking privileged functions. Severity is high (8) because it irreversibly disrupts governance, but profitability is lower (3) since it primarily enables denial-of-service rather than direct profit. Correctness is 9 as the code clearly omits the check.",
+        "correctness": 9,
+        "severity": 8,
+        "profitability": 3,
+        "reason": "The function does not validate if '_newOwner' is a non-zero address. If the owner accidentally transfers ownership to address(0), the contract becomes permanently ownerless, locking all onlyOwner functions (e.g., mintTokens, blacklistAccount) and disrupting protocol governance.",
+        "code": "function transferOwnership(address _newOwner) onlyOwner public { owner = _newOwner; }",
+        "label": "Typo Constructor",
+        "file_name": "2019-15080.sol",
+        "description": "An issue was discovered in a smart contract implementation for MORPH Token through 2019-06-05, an Ethereum token. A typo in the constructor of the Owned contract (which is inherited by MORPH Token) allows attackers to acquire contract ownership. A new owner can subsequently obtain MORPH Tokens for free and can perform a DoS attack."
+    },
+    {
+        "function_name": "approve",
+        "vulnerability": "Front-runnable allowance approval",
+        "criticism": "The reasoning is partially correct. The approve function lacks the standard mitigation (e.g., requiring allowance reset to zero first), making it vulnerable to front-running. However, this is a well-known design flaw in ERC-20, not a code-level bug. Severity is moderate (6) as it depends on user behavior. Profitability is high (7) if attackers exploit users adjusting allowances. Correctness is 8 since the code does not implement safeguards.",
+        "correctness": 8,
+        "severity": 6,
+        "profitability": 7,
+        "reason": "The approve() function does not implement checks for changing allowances (e.g., requiring allowance to be zero first). Attackers can front-run a user's approval change transaction to drain funds using the old allowance before it's updated, leading to double-spending of allowances.",
+        "code": "function approve(address _spender, uint256 _amount) public returns (bool success) { allowed[msg.sender][_spender] = _amount; Approval(msg.sender, _spender, _amount); return true; }",
+        "label": "Typo Constructor",
+        "file_name": "2019-15080.sol",
+        "description": "An issue was discovered in a smart contract implementation for MORPH Token through 2019-06-05, an Ethereum token. A typo in the constructor of the Owned contract (which is inherited by MORPH Token) allows attackers to acquire contract ownership. A new owner can subsequently obtain MORPH Tokens for free and can perform a DoS attack."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2021-3004.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2021-3004.json
new file mode 100644
index 00000000..deffa814
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/CVE-2021-3004.json
@@ -0,0 +1,41 @@
+[
+    {
+        "function_name": "_deposit",
+        "vulnerability": "Oracle Price Manipulation",
+        "criticism": "The reasoning is correct. The _deposit function relies solely on the LINK oracle to calculate collateral value, ignoring the AMM pool's actual price. If the oracle is manipulated (e.g., stale data or centralized control), attackers can deposit undervalued assets and mint overvalued yCREDIT tokens. The severity is critical (9) as this directly compromises the protocol's solvency. Profitability is high (9) because attackers can drain funds by redeeming inflated yCREDIT. However, the code does interact with the AMM pool via _addLiquidity, which uses the pool's reserves to compute liquidity. This partially mitigates the impact, but the collateralCredit is still based on the manipulated oracle value, making the exploit viable.",
+        "correctness": 8,
+        "severity": 9,
+        "profitability": 9,
+        "reason": "The _deposit function calculates the deposited collateral value using a single oracle (LINK.getPriceUSD) without cross-verifying with the actual AMM pool price. If the oracle is manipulated or provides incorrect prices (e.g., due to stale data or centralized control), attackers can deposit undervalued assets to mint inflated yCREDIT tokens. This allows them to steal protocol funds by redeeming overvalued yCREDIT for legitimate collateral. This is a critical vulnerability as it directly affects the protocol's solvency.",
+        "code": "function _deposit(IERC20 token, uint amount) internal {\n    uint _value = LINK.getPriceUSD(address(token)) * amount / uint256(10)**token.decimals();\n    require(_value > 0, \"!value\");\n    (address _pair, uint amountA,) = _addLiquidity(address(token), address(this), amount, _value);\n    token.safeTransferFrom(msg.sender, _pair, amountA);\n    _mint(_pair, _value);\n    uint _liquidity = ISushiswapV2Pair(_pair).mint(address(this));\n    collateral[msg.sender][address(token)] += _liquidity;\n    collateralCredit[msg.sender][address(token)] += _value;\n    uint _fee = _value * FEE / BASE;\n    _mint(msg.sender, _value - _fee);\n    _mint(address(this), _fee);\n    notifyFeeAmount(_fee);\n    emit Deposit(msg.sender, address(token), _value, amount, _value);\n}",
+        "label": "Wrong Logic",
+        "file_name": "2021-3004.sol",
+        "description": "The _deposit function in the smart contract implementation for Stable Yield Credit (yCREDIT), an Ethereum token, has certain incorrect calculations. An attacker can obtain more yCREDIT tokens than they should."
+    },
+    {
+        "function_name": "_addLiquidity",
+        "vulnerability": "Unrestricted Market Creation",
+        "criticism": "The function auto-adds any new Sushiswap pair to the _markets list, enabling attackers to create pairs with malicious tokens (e.g., fake collateral). Combined with oracle manipulation, this allows minting yCREDIT against worthless assets. The severity is high (8) as it undermines collateral integrity. Profitability is high (8) if exploited with oracle flaws. However, the vulnerability\u2019s impact depends on other factors (e.g., oracle trustworthiness), which slightly reduces its standalone severity. The system\u2019s lack of allowlist/denylist for collateral tokens is a critical oversight.",
+        "correctness": 8,
+        "severity": 8,
+        "profitability": 8,
+        "reason": "The _addLiquidity function automatically adds any token to the _markets list when a new Sushiswap pair is created. Attackers can exploit this by creating pairs with malicious tokens (e.g., tokens with manipulated supply or fake collateral). Combined with oracle manipulation, this allows attackers to deposit worthless tokens as collateral, mint yCREDIT, and drain the protocol. The system should restrict which tokens can be used as collateral instead of auto-adding all pairs.",
+        "code": "function _addLiquidity( address tokenA, address tokenB, uint amountADesired, uint amountBDesired ) internal virtual returns (address pair, uint amountA, uint amountB) {\n    pair = FACTORY.getPair(tokenA, tokenB);\n    if (pair == address(0)) {\n        pair = FACTORY.createPair(tokenA, tokenB);\n        pairs[pair] = true;\n        _markets.push(tokenA);\n    } else if (!pairs[pair]) {\n        pairs[pair] = true;\n        _markets.push(tokenA);\n    }\n    (uint reserveA, uint reserveB) = SushiswapV2Library.getReserves(address(FACTORY), tokenA, tokenB);\n    if (reserveA == 0 && reserveB == 0) {\n        (amountA, amountB) = (amountADesired, amountBDesired);\n    } else {\n        uint amountBOptimal = SushiswapV2Library.quote(amountADesired, reserveA, reserveB);\n        if (amountBOptimal <= amountBDesired) {\n            (amountA, amountB) = (amountADesired, amountBOptimal);\n        } else {\n            uint amountAOptimal = SushiswapV2Library.quote(amountBDesired, reserveB, reserveA);\n            assert(amountAOptimal <= amountADesired);\n            (amountA, amountB) = (amountAOptimal, amountBDesired);\n        }\n    }\n}",
+        "label": "Wrong Logic",
+        "file_name": "2021-3004.sol",
+        "description": "The _deposit function in the smart contract implementation for Stable Yield Credit (yCREDIT), an Ethereum token, has certain incorrect calculations. An attacker can obtain more yCREDIT tokens than they should."
+    },
+    {
+        "function_name": "_transferTokens",
+        "vulnerability": "Fee Handling Flaws",
+        "criticism": "The reasoning contains inaccuracies. First, the fee is calculated as a percentage of the transferred amount, so underflow is impossible unless FEE exceeds 100% (unlikely). Second, the rewardRate manipulation via notifyFeeAmount is speculative since the function\u2019s implementation is not shown. While small fees could distort rewards, the severity is low (2) without evidence of exploitable logic. Profitability is negligible (1) as no direct theft vector is demonstrated. The primary issue is design ambiguity, not a clear vulnerability.",
+        "correctness": 3,
+        "severity": 2,
+        "profitability": 1,
+        "reason": "The fee mechanism applies a transfer tax when tokens are sent from a pair (e.g., during a buy). However, the fee is deducted from the recipient's (buyer's) balance after the initial transfer, which could lead to underflow if the fee rounds to zero or exceeds the received amount. Additionally, notifyFeeAmount recalculates rewardRate without proper validation, allowing attackers to manipulate reward distribution by making small transfers to trigger fee updates, potentially disrupting reward calculations or causing integer overflows/underflows.",
+        "code": "function _transferTokens(address src, address dst, uint amount) internal {\n    balances[src] -= amount;\n    balances[dst] += amount;\n    emit Transfer(src, dst, amount);\n    if (pairs[src]) {\n        uint _fee = amount * FEE / BASE;\n        _transferTokens(dst, address(this), _fee);\n        notifyFeeAmount(_fee);\n    }\n}",
+        "label": "Wrong Logic",
+        "file_name": "2021-3004.sol",
+        "description": "The _deposit function in the smart contract implementation for Stable Yield Credit (yCREDIT), an Ethereum token, has certain incorrect calculations. An attacker can obtain more yCREDIT tokens than they should."
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-10299.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-10299.json
new file mode 100644
index 00000000..d5ba5b65
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-10299.json
@@ -0,0 +1,44 @@
+[
+    {
+        "function_name": "batchTransfer",
+        "vulnerability": "Integer Overflow Leading to Arbitrary Token Minting",
+        "criticism": "The reasoning is correct. The multiplication `cnt * _value` lacks SafeMath checks, enabling integer overflow. If `_value` is crafted such that `cnt * _value` overflows, `amount` becomes a small value, allowing an attacker to bypass the balance check and mint large `_value` tokens for all receivers. The severity is extremely high (9) as this directly enables token supply manipulation. Profitability is also 9, as attackers can mint and sell tokens for profit. The correctness is 9 because the exploit is technically valid if SafeMath is not applied to the multiplication operation.",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 9,
+        "reason": "The multiplication `uint256 amount = uint256(cnt) * _value` does not use SafeMath, allowing integer overflow. If `cnt * _value` exceeds 2^256-1, `amount` wraps around to a small value. The subsequent `balances[msg.sender].sub(amount)` deducts an incorrect small amount, while each receiver gains the original large `_value`, enabling attackers to mint vast amounts of tokens from nothing.",
+        "code": "function batchTransfer(address[] _receivers, uint256 _value) public whenNotPaused returns (bool) { uint cnt = _receivers.length; uint256 amount = uint256(cnt) * _value; require(cnt > 0 && cnt <= 20); require(_value > 0 && balances[msg.sender] >= amount); balances[msg.sender] = balances[msg.sender].sub(amount); for (uint i = 0; i < cnt; i++) { balances[_receivers[i]] = balances[_receivers[i]].add(_value); Transfer(msg.sender, _receivers[i], _value); } return true; }",
+        "label": "Integer Overflow",
+        "file_name": "2018-10299.sol",
+        "description": "An integer overflow in the batchTransfer function of a smart contract implementation for Beauty Ecosystem Coin (BEC), the Ethereum ERC20 token used in the Beauty Chain economic system, allows attackers to accomplish an unauthorized increase of digital assets by providing two _receivers arguments in conjunction with a large _value argument, as exploited in the wild in April 2018, aka the \"batchOverflow\" issue.",
+        "final_score": 9.0
+    },
+    {
+        "function_name": "approve",
+        "vulnerability": "Allowance Race Condition (Front-Running)",
+        "criticism": "The reasoning is partially correct but mischaracterizes the severity. The code follows the ERC20 standard, which inherently has this race condition. The function does not include mitigation (e.g., `increaseAllowance`/`decreaseAllowance`), but this is a protocol-level limitation, not a code vulnerability. Severity is low (2) as it relies on user error (not resetting to zero first). Profitability is moderate (4) only if exploited, but it is not a direct exploit vector. Correctness is 5 because the issue exists but is a known ERC20 design trade-off, not a code flaw.",
+        "correctness": 5,
+        "severity": 2,
+        "profitability": 4,
+        "reason": "The approve function does not mitigate the ERC20 allowance front-running attack. If a user reduces an existing allowance, a spender can front-run the transaction to use the old higher allowance before the reduction takes effect. This violates the intended allowance update and allows unauthorized token transfers.",
+        "code": "function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; }",
+        "label": "Integer Overflow",
+        "file_name": "2018-10299.sol",
+        "description": "An integer overflow in the batchTransfer function of a smart contract implementation for Beauty Ecosystem Coin (BEC), the Ethereum ERC20 token used in the Beauty Chain economic system, allows attackers to accomplish an unauthorized increase of digital assets by providing two _receivers arguments in conjunction with a large _value argument, as exploited in the wild in April 2018, aka the \"batchOverflow\" issue.",
+        "final_score": 4.0
+    },
+    {
+        "function_name": "batchTransfer",
+        "vulnerability": "Unauthorized Token Burning via Zero Address",
+        "criticism": "The reasoning is context-dependent. Sending tokens to `address(0)` is a common way to burn tokens, and ERC20 does not prohibit it. If the contract explicitly forbids burning (e.g., in its `transfer` function), this would be a vulnerability. However, the reasoning assumes unauthorized burning without evidence of such a policy. Severity (1) and profitability (0) are negligible unless burning is disallowed. Correctness is 3 due to insufficient context.",
+        "correctness": 3,
+        "severity": 1,
+        "profitability": 0,
+        "reason": "The batchTransfer function lacks a check for zero addresses in the `_receivers` array. Unlike the transfer function, which blocks sending to `address(0)`, this allows users to send tokens to the zero address via batchTransfer, enabling unauthorized token burning and violating the contract's consistency.",
+        "code": "function batchTransfer(address[] _receivers, uint256 _value) public whenNotPaused returns (bool) { uint cnt = _receivers.length; uint256 amount = uint256(cnt) * _value; require(cnt > 0 && cnt <= 20); require(_value > 0 && balances[msg.sender] >= amount); balances[msg.sender] = balances[msg.sender].sub(amount); for (uint i = 0; i < cnt; i++) { balances[_receivers[i]] = balances[_receivers[i]].add(_value); Transfer(msg.sender, _receivers[i], _value); } return true; }",
+        "label": "Integer Overflow",
+        "file_name": "2018-10299.sol",
+        "description": "An integer overflow in the batchTransfer function of a smart contract implementation for Beauty Ecosystem Coin (BEC), the Ethereum ERC20 token used in the Beauty Chain economic system, allows attackers to accomplish an unauthorized increase of digital assets by providing two _receivers arguments in conjunction with a large _value argument, as exploited in the wild in April 2018, aka the \"batchOverflow\" issue.",
+        "final_score": 1.75
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-10376.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-10376.json
new file mode 100644
index 00000000..befe7dc3
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-10376.json
@@ -0,0 +1,44 @@
+[
+    {
+        "function_name": "transferProxy",
+        "vulnerability": "Integer Overflow in Fee/Value Sum",
+        "criticism": "The reasoning is correct. The function does not account for integer overflow in `_feeSmt + _value`, allowing an attacker to bypass balance checks. This leads to underflow in `balances[_from]`, effectively minting tokens for `_to` and `msg.sender`. The vulnerability is critical because it enables unauthorized token creation and transfer. The severity and profitability are both high due to direct exploitation potential.",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 9,
+        "reason": "The function checks if `_from` has sufficient balance using `balances[_from] < _feeSmt + _value`, but does not account for integer overflow. An attacker can craft `_feeSmt` and `_value` such that their sum overflows to a lower value (e.g., `_feeSmt = 2^256 - 200`, `_value = 200`), causing the check to pass even if `_from` has insufficient balance. This allows the attacker to transfer large amounts of tokens they don't own and mint arbitrary tokens for `msg.sender` via overflow in `balances[msg.sender] += _feeSmt`.",
+        "code": "function transferProxy(address _from, address _to, uint256 _value, uint256 _feeSmt, uint8 _v,bytes32 _r, bytes32 _s) public transferAllowed(_from) returns (bool){ if(balances[_from] < _feeSmt + _value) revert(); uint256 nonce = nonces[_from]; bytes32 h = keccak256(_from,_to,_value,_feeSmt,nonce); if(_from != ecrecover(h,_v,_r,_s)) revert(); if(balances[_to] + _value < balances[_to] || balances[msg.sender] + _feeSmt < balances[msg.sender]) revert(); balances[_to] += _value; Transfer(_from, _to, _value); balances[msg.sender] += _feeSmt; Transfer(_from, msg.sender, _feeSmt); balances[_from] -= _value + _feeSmt; nonces[_from] = nonce + 1; return true; }",
+        "label": "Integer Overflow",
+        "file_name": "2018-10376.sol",
+        "description": "An integer overflow in the transferProxy function of a smart contract implementation for SmartMesh (aka SMT), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized increase of digital assets via crafted _fee and _value parameters, as exploited in the wild in April 2018, aka the \"proxyOverflow\" issue.",
+        "final_score": 9.0
+    },
+    {
+        "function_name": "approveAndCallcode",
+        "vulnerability": "Reentrancy via External Call",
+        "criticism": "The reasoning is accurate. The external call `_spender.call(_extraData)` occurs after setting the allowance, enabling reentrancy. A malicious spender can repeatedly reset the allowance and drain funds. This is a high-severity vulnerability with direct profitability for attackers, akin to classic reentrancy exploits like the DAO hack.",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 9,
+        "reason": "The function performs an external call (`_spender.call(_extraData)`) after setting an allowance. A malicious `_spender` can re-enter the contract (e.g., by calling `transferFrom` or `approveAndCallcode` again) before the allowance is consumed. This allows repeated draining of the allowance, as each reentrant call resets `allowed[msg.sender][_spender]` to `_value`.",
+        "code": "function approveAndCallcode(address _spender, uint256 _value, bytes _extraData) public returns (bool success) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); if(!_spender.call(_extraData)) { revert(); } return true; }",
+        "label": "Integer Overflow",
+        "file_name": "2018-10376.sol",
+        "description": "An integer overflow in the transferProxy function of a smart contract implementation for SmartMesh (aka SMT), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized increase of digital assets via crafted _fee and _value parameters, as exploited in the wild in April 2018, aka the \"proxyOverflow\" issue.",
+        "final_score": 9.0
+    },
+    {
+        "function_name": "allocateTokens",
+        "vulnerability": "Unrestricted Owner Minting",
+        "criticism": "The reasoning is partially correct. While the owner can mint tokens without a cap within the time window, this is a design choice (centralization risk) rather than a technical vulnerability. The overflow checks in the code prevent unintended supply inflation. Severity is moderate (7) as it depends on the owner's intent, and profitability is low (0) for external attackers unless the owner is compromised.",
+        "correctness": 7,
+        "severity": 7,
+        "profitability": 0,
+        "reason": "The `allocateTokens` function allows the owner to mint unlimited tokens within 1 day of deployment. There is no cap on `totalSupply`, so a malicious/compromised owner can inflate the supply indefinitely, devaluing existing tokens. Even though the function is time-limited, the 1-day window is sufficient to cause significant harm if exploited.",
+        "code": "function allocateTokens(address[] _owners, uint256[] _values) public onlyOwner { if(allocateEndTime < now) revert(); if(_owners.length != _values.length) revert(); for(uint256 i = 0; i < _owners.length ; i++){ address to = _owners[i]; uint256 value = _values[i]; if(totalSupply + value <= totalSupply || balances[to] + value <= balances[to]) revert(); totalSupply += value; balances[to] += value; } }",
+        "label": "Integer Overflow",
+        "file_name": "2018-10376.sol",
+        "description": "An integer overflow in the transferProxy function of a smart contract implementation for SmartMesh (aka SMT), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized increase of digital assets via crafted _fee and _value parameters, as exploited in the wild in April 2018, aka the \"proxyOverflow\" issue.",
+        "final_score": 5.25
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-10666.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-10666.json
new file mode 100644
index 00000000..97a66fa5
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-10666.json
@@ -0,0 +1,44 @@
+[
+    {
+        "function_name": "setOwner",
+        "vulnerability": "Missing access control",
+        "criticism": "The reasoning is entirely correct. The absence of an access control modifier (e.g., onlyOwner) allows any caller to arbitrarily set the contract owner. This is a critical vulnerability because ownership control grants access to privileged functions, enabling fund drainage, parameter manipulation, and full contract takeover. The severity and profitability are both maximal, as an attacker can immediately exploit this to steal assets or disrupt operations.",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 9,
+        "reason": "The setOwner function lacks the onlyOwner modifier, allowing any caller to arbitrarily change the contract owner. This enables an attacker to take full control of the contract, including privileged functions like uploadBalances, setExportFee, or unlockToken. Once ownership is hijacked, the attacker can drain funds, manipulate fees, or disrupt the contract's operation.",
+        "code": "function setOwner(address _owner) returns (bool success) { owner = _owner; return true; }",
+        "label": "Access Control",
+        "file_name": "2018-10666.sol",
+        "description": "The Owned smart contract implementation for Aurora IDEX Membership (IDXM), an Ethereum ERC20 token, allows attackers to acquire contract ownership because the setOwner function is declared as public. A new owner can subsequently modify variables.",
+        "final_score": 9.0
+    },
+    {
+        "function_name": "approve",
+        "vulnerability": "Allowance front-running",
+        "criticism": "The reasoning is valid. The approve function lacks a mitigation for the front-running race condition (e.g., requiring allowance reset to zero before non-zero updates). Attackers can exploit this to double-spend allowances if users adjust approvals. However, severity is moderate (7) as exploitation requires specific user behavior (changing existing non-zero allowances) and mempool monitoring. Profitability is high (7) if successful, but contingent on victim actions.",
+        "correctness": 9,
+        "severity": 7,
+        "profitability": 7,
+        "reason": "The approve function does not enforce the check-effects-interaction pattern or require resetting allowances to zero before updating. Attackers can front-run a user\u2019s approval change (e.g., from 100 to 50) by first using the old allowance (100) before it\u2019s reduced. This allows double-spending of allowances, enabling unauthorized token transfers from the victim\u2019s balance.",
+        "code": "function approve(address _spender, uint256 _amount) returns (bool success) { require(!locked); allowance[msg.sender][_spender] = _amount; Approval(msg.sender, _spender, _amount); return true; }",
+        "label": "Access Control",
+        "file_name": "2018-10666.sol",
+        "description": "The Owned smart contract implementation for Aurora IDEX Membership (IDXM), an Ethereum ERC20 token, allows attackers to acquire contract ownership because the setOwner function is declared as public. A new owner can subsequently modify variables.",
+        "final_score": 8.0
+    },
+    {
+        "function_name": "transfer",
+        "vulnerability": "Integer overflow/underflow",
+        "criticism": "The reasoning is incorrect. While the code uses raw arithmetic, the function includes require(balanceOf[msg.sender] >= _amount) and require(balanceOf[_to] + _amount >= balanceOf[_to]), which explicitly prevent underflow (sender balance) and overflow (recipient balance). These checks render the SafeMath argument moot. The vulnerability claim is invalid, as the code already enforces overflow/underflow safety through conditionals. No exploit path exists here.",
+        "correctness": 1,
+        "severity": 0,
+        "profitability": 0,
+        "reason": "The transfer and transferFrom functions use raw arithmetic operations (e.g., balanceOf[msg.sender] -= _amount) without leveraging the inherited SafeMath library. In Solidity <0.8.0, this allows integer underflows/overflows. An attacker can send tokens they don\u2019t own (underflow to max uint256) or overflow a recipient\u2019s balance to near-zero. This directly compromises the token\u2019s integrity and enables theft or denial of service.",
+        "code": "function transfer(address _to, uint256 _amount) returns (bool success) { require(!locked); require(balanceOf[msg.sender] >= _amount); require(balanceOf[_to] + _amount >= balanceOf[_to]); balanceOf[msg.sender] -= _amount; uint256 preBalance = balanceOf[_to]; balanceOf[_to] += _amount; bool alreadyMax = preBalance >= singleIDXMQty; if (!alreadyMax) { if (now >= validAfter[_to].ts + mustHoldFor) validAfter[_to].last = preBalance; validAfter[_to].ts = now; } if (validAfter[msg.sender].last > balanceOf[msg.sender]) validAfter[msg.sender].last = balanceOf[msg.sender]; Transfer(msg.sender, _to, _amount); return true; }",
+        "label": "Access Control",
+        "file_name": "2018-10666.sol",
+        "description": "The Owned smart contract implementation for Aurora IDEX Membership (IDXM), an Ethereum ERC20 token, allows attackers to acquire contract ownership because the setOwner function is declared as public. A new owner can subsequently modify variables.",
+        "final_score": 0.5
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-10705.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-10705.json
new file mode 100644
index 00000000..ee626070
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-10705.json
@@ -0,0 +1,44 @@
+[
+    {
+        "function_name": "setOwner",
+        "vulnerability": "Unrestricted Ownership Transfer",
+        "criticism": "The reasoning is entirely correct. The absence of an onlyOwner modifier allows any address to change the owner, leading to full contract control. This is a critical vulnerability because ownership privileges often include fund control and administrative functions. The severity and profitability are maximized since an attacker can immediately drain funds or disrupt the contract. The exploit requires no preconditions and is trivially executable.",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 9,
+        "reason": "The setOwner function lacks the onlyOwner modifier, allowing any address to arbitrarily change the contract owner. This enables an attacker to immediately take full control of the contract, including privileged functions like unlockToken and uploadBalances, leading to fund theft or contract destruction.",
+        "code": "function setOwner(address _owner) returns (bool success) { owner = _owner; return true; }",
+        "label": "Access Control",
+        "file_name": "2018-10705.sol",
+        "description": "The Owned smart contract implementation for Aurora DAO (AURA), an Ethereum ERC20 token, allows attackers to acquire contract ownership because the setOwner function is declared as public. An attacker can then conduct a lockBalances() denial of service attack.",
+        "final_score": 9.0
+    },
+    {
+        "function_name": "approve",
+        "vulnerability": "Allowance Race Condition",
+        "criticism": "The reasoning correctly identifies the ERC20 front-running risk, but this is a protocol-level limitation, not a code flaw. The function follows the ERC20 standard, which does not mandate allowance resetting. The severity is moderate because exploitation depends on user behavior (e.g., not resetting allowances). Profitability is context-dependent: if high-value allowances exist, attackers could profit by front-running reduction attempts. However, this is a known ERC20 trade-off, not a unique contract vulnerability.",
+        "correctness": 5,
+        "severity": 4,
+        "profitability": 6,
+        "reason": "The approve function does not mitigate the ERC20 allowance front-running attack. If a user reduces their approval for a spender, the spender can front-run the transaction to use the old allowance before the reduction. This allows attackers to drain funds up to the previous higher allowance, especially impactful once the contract is unlocked.",
+        "code": "function approve(address _spender, uint256 _value) public returns (bool success) { require(!locked); allowance[msg.sender][_spender] = _value; return true; }",
+        "label": "Access Control",
+        "file_name": "2018-10705.sol",
+        "description": "The Owned smart contract implementation for Aurora DAO (AURA), an Ethereum ERC20 token, allows attackers to acquire contract ownership because the setOwner function is declared as public. An attacker can then conduct a lockBalances() denial of service attack.",
+        "final_score": 5.0
+    },
+    {
+        "function_name": "uploadBalances",
+        "vulnerability": "Array Length Mismatch Token Loss",
+        "criticism": "The reasoning is partially correct but misses critical context. While unequal array lengths can cause out-of-bounds reads (returning 0 in legacy Solidity versions), the actual token loss occurs only if recipients.length > balances.length. In such cases, the owner's balance is reduced by the sum of the valid balances array, but excess recipients receive 0 tokens, effectively burning the sum. However, this requires the owner to mistakenly call the function with mismatched arrays. Since the function is onlyOwner, external attackers cannot trigger this. Severity is moderate (owner-induced error), and profitability is negligible for attackers.",
+        "correctness": 6,
+        "severity": 5,
+        "profitability": 0,
+        "reason": "The uploadBalances function does not enforce equal lengths for recipients and balances arrays. If recipients.length > balances.length, balances[i] returns 0 beyond the balances array's end, causing the owner's balance to be reduced by the sum of the valid balances while recipients receive incorrect (often zero) amounts. This permanently burns the sum from the owner's balance, leading to irreversible token loss.",
+        "code": "function uploadBalances(address[] recipients, uint256[] balances) onlyOwner { require(!balancesUploaded); uint256 sum = 0; for (uint256 i = 0; i < recipients.length; i++) { balanceOf[recipients[i]] = safeAdd(balanceOf[recipients[i]], balances[i]); sum = safeAdd(sum, balances[i]); } balanceOf[owner] = safeSub(balanceOf[owner], sum); }",
+        "label": "Access Control",
+        "file_name": "2018-10705.sol",
+        "description": "The Owned smart contract implementation for Aurora DAO (AURA), an Ethereum ERC20 token, allows attackers to acquire contract ownership because the setOwner function is declared as public. An attacker can then conduct a lockBalances() denial of service attack.",
+        "final_score": 4.25
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-11335.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-11335.json
new file mode 100644
index 00000000..a1a335ca
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-11335.json
@@ -0,0 +1,44 @@
+[
+    {
+        "function_name": "setMigrationAgent",
+        "vulnerability": "Privilege escalation via migration agent",
+        "criticism": "The reasoning is accurate. The function centralizes trust in `migrationMaster`, creating a single point of failure. If compromised, an attacker can set a malicious agent to drain user funds during migration. This is a critical vulnerability if `migrationMaster` is an EOA or poorly secured contract. Severity is high due to the potential for total fund loss. Profitability is extreme if the agent steals migrating tokens.",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 9,
+        "reason": "The setMigrationAgent function allows the migrationMaster to set a malicious migration agent contract once. If the migrationMaster's account is compromised, an attacker can set a malicious agent. Users who call migrate() will have their tokens transferred to the attacker's contract via MigrationAgent.migrateFrom, resulting in loss of funds. This centralizes trust in migrationMaster, creating a single point of failure.",
+        "code": "function setMigrationAgent(address _agent) external {\n    require(migrationAgent == 0);\n    require(msg.sender == migrationMaster);\n    migrationAgent = _agent;\n}",
+        "label": "Integer Overflow",
+        "file_name": "2018-11335.sol",
+        "description": "GVToken Genesis Vision (GVT) is a smart contract running on Ethereum. The mint function has an integer overflow that allows minted tokens to be arbitrarily retrieved by the contract owner.",
+        "final_score": 9.0
+    },
+    {
+        "function_name": "mint",
+        "vulnerability": "Integer overflow in minting",
+        "criticism": "The reasoning is partially correct. While the absence of SafeMath could theoretically allow overflows, Solidity \u22650.8.0 automatically checks for overflows. If the contract uses an older compiler, the require(totalSupply + value <= TOKEN_LIMIT) check is vulnerable to overflow bypass (e.g., wrapping to 0). However, the attacker must control the `ico` address to exploit this, which limits exploitability. Severity is high only if `ico` is compromised. Profitability depends on the attacker's ability to mint beyond TOKEN_LIMIT and dump tokens.",
+        "correctness": 8,
+        "severity": 7,
+        "profitability": 6,
+        "reason": "The mint function does not use SafeMath for addition, allowing integer overflows. The require statement 'totalSupply + value <= TOKEN_LIMIT' can be bypassed if totalSupply + value overflows, resulting in a wrapped value that is within the limit. Additionally, 'balances[holder] += value' and 'totalSupply += value' can overflow, leading to incorrect token balances and total supply. An attacker with control over the ico address could exploit this to mint tokens beyond the intended TOKEN_LIMIT or corrupt balances.",
+        "code": "function mint(address holder, uint value) public {\n    require(msg.sender == ico);\n    require(value > 0);\n    require(totalSupply + value <= TOKEN_LIMIT);\n    balances[holder] += value;\n    totalSupply += value;\n    Transfer(0x0, holder, value);\n}",
+        "label": "Integer Overflow",
+        "file_name": "2018-11335.sol",
+        "description": "GVToken Genesis Vision (GVT) is a smart contract running on Ethereum. The mint function has an integer overflow that allows minted tokens to be arbitrarily retrieved by the contract owner.",
+        "final_score": 7.25
+    },
+    {
+        "function_name": "approve",
+        "vulnerability": "ERC20 approve front-running",
+        "criticism": "The reasoning is correct but overstates the risk. The function inherits the standard ERC20 front-running issue, where changing a non-zero allowance requires first resetting to zero. However, this is a well-known limitation of ERC20, not a code flaw. Severity is moderate since it relies on user error (not resetting allowances). Profitability is low unless users recklessly adjust allowances for untrusted spenders.",
+        "correctness": 7,
+        "severity": 3,
+        "profitability": 2,
+        "reason": "The approve function is vulnerable to the ERC20 race condition. If a user changes the approval amount from a non-zero value to another non-zero value, a malicious spender can front-run the transaction, using the old allowance before it's reduced. This can lead to unintended allowance usage. Although increaseApproval/decreaseApproval exist, the standard approve remains risky, especially when users are unaware of the race condition.",
+        "code": "function approve(address _spender, uint _value) public returns (bool) {\n    require(!isFrozen);\n    return super.approve(_spender, _value);\n}",
+        "label": "Integer Overflow",
+        "file_name": "2018-11335.sol",
+        "description": "GVToken Genesis Vision (GVT) is a smart contract running on Ethereum. The mint function has an integer overflow that allows minted tokens to be arbitrarily retrieved by the contract owner.",
+        "final_score": 4.75
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-12025.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-12025.json
new file mode 100644
index 00000000..82b39b96
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-12025.json
@@ -0,0 +1,44 @@
+[
+    {
+        "function_name": "transferFrom",
+        "vulnerability": "Inverted Allowance Check & Underflow",
+        "criticism": "The reasoning is correct. The inverted check allows transfers when allowance is insufficient, and the underflow (due to Solidity 0.4.2) sets the allowance to a massive value. This allows attackers to drain the victim's balance after one underflow. The severity is critical (direct theft) and profitability is extremely high. The code flaw is unambiguous and exploitable.",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 9,
+        "reason": "The condition `if( allowed[from][msg.sender] >= value ) return false;` is inverted. This allows transfers when the allowance is **insufficient** (allowed < value) instead of enforcing it. Furthermore, when `allowed[from][msg.sender]` is less than `value`, the line `allowed[from][msg.sender] -= value;` underflows (due to Solidity 0.4.2's lack of overflow checks), setting the allowance to a massive value (2^256 - X). Attackers can exploit this to gain infinite approval after one underflow, enabling unlimited token transfers from the victim's account.",
+        "code": "function transferFrom(address from, address to, uint value) returns (bool success) { if (frozenAccount[msg.sender]) return false; if(balances[from] < value) return false; if( allowed[from][msg.sender] >= value ) return false; if(balances[to] + value < balances[to]) return false; balances[from] -= value; allowed[from][msg.sender] -= value; balances[to] += value; Transfer(from, to, value); return true; }",
+        "label": "Wrong Logic",
+        "file_name": "2018-12025.sol",
+        "description": "The transferFrom function of a smart contract implementation for FuturXE (FXE), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized transfer of digital assets because of a logic error. The developer messed up with the boolean judgment - if the input value is smaller than or equal to allowed value, the transfer session would stop execution by returning false. This makes no sense, because the transferFrom() function should require the transferring value to not exceed the allowed value in the first place. Suppose this function asks for the allowed value to be smaller than the input. Then, the attacker could easily ignore the allowance: after this condition, the `allowed[from][msg.sender] -= value;` would cause an underflow because the allowed part is smaller than the value. The attacker could transfer any amount of FuturXe tokens of any accounts to an appointed account (the `_to` address) because the allowed value is initialized to 0, and the attacker could bypass this restriction even without the victim's private key.",
+        "final_score": 9.0
+    },
+    {
+        "function_name": "transferFrom",
+        "vulnerability": "Incorrect Frozen Account Check",
+        "criticism": "The reasoning is accurate. The check on `msg.sender` (spender) instead of `from` (token owner) allows transfers from frozen accounts via approved spenders. Severity is high if freezing is meant to block all transfers. Profitability depends on attackers having prior approval, but it violates core security assumptions.",
+        "correctness": 9,
+        "severity": 8,
+        "profitability": 7,
+        "reason": "The function checks `frozenAccount[msg.sender]` (spender's status) instead of `frozenAccount[from]` (token owner's status). A frozen account (from) can still have its tokens transferred via an approved spender (msg.sender) as long as the spender is not frozen. This violates the intended freezing logic, allowing attackers to bypass account freezes by using approved addresses.",
+        "code": "function transferFrom(address from, address to, uint value) returns (bool success) { if (frozenAccount[msg.sender]) return false; if(balances[from] < value) return false; if( allowed[from][msg.sender] >= value ) return false; if(balances[to] + value < balances[to]) return false; balances[from] -= value; allowed[from][msg.sender] -= value; balances[to] += value; Transfer(from, to, value); return true; }",
+        "label": "Wrong Logic",
+        "file_name": "2018-12025.sol",
+        "description": "The transferFrom function of a smart contract implementation for FuturXE (FXE), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized transfer of digital assets because of a logic error. The developer messed up with the boolean judgment - if the input value is smaller than or equal to allowed value, the transfer session would stop execution by returning false. This makes no sense, because the transferFrom() function should require the transferring value to not exceed the allowed value in the first place. Suppose this function asks for the allowed value to be smaller than the input. Then, the attacker could easily ignore the allowance: after this condition, the `allowed[from][msg.sender] -= value;` would cause an underflow because the allowed part is smaller than the value. The attacker could transfer any amount of FuturXe tokens of any accounts to an appointed account (the `_to` address) because the allowed value is initialized to 0, and the attacker could bypass this restriction even without the victim's private key.",
+        "final_score": 8.25
+    },
+    {
+        "function_name": "approve",
+        "vulnerability": "Unsafe ERC20 Approve",
+        "criticism": "The reasoning is valid but overstates severity. The lack of a zero-reset check enables front-running, but this is a known ERC20 design flaw, not a code-specific bug. Severity is moderate (requires user error) and profitability is medium (depends on user behavior).",
+        "correctness": 7,
+        "severity": 5,
+        "profitability": 5,
+        "reason": "The `approve` function does not include a check for the front-running race condition. If a user changes their approval from a non-zero value to another non-zero value, an attacker can front-run the transaction to use the old approval before it is reset. While this is a known ERC20 design flaw, its presence here allows attackers to steal funds if users naively adjust approvals without first setting them to zero.",
+        "code": "function approve(address _spender, uint256 _amount) returns (bool success) { allowed[msg.sender][_spender] = _amount; Approval(msg.sender, _spender, _amount); return true; }",
+        "label": "Wrong Logic",
+        "file_name": "2018-12025.sol",
+        "description": "The transferFrom function of a smart contract implementation for FuturXE (FXE), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized transfer of digital assets because of a logic error. The developer messed up with the boolean judgment - if the input value is smaller than or equal to allowed value, the transfer session would stop execution by returning false. This makes no sense, because the transferFrom() function should require the transferring value to not exceed the allowed value in the first place. Suppose this function asks for the allowed value to be smaller than the input. Then, the attacker could easily ignore the allowance: after this condition, the `allowed[from][msg.sender] -= value;` would cause an underflow because the allowed part is smaller than the value. The attacker could transfer any amount of FuturXe tokens of any accounts to an appointed account (the `_to` address) because the allowed value is initialized to 0, and the attacker could bypass this restriction even without the victim's private key.",
+        "final_score": 6.0
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-13836.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-13836.json
new file mode 100644
index 00000000..b458d20e
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-13836.json
@@ -0,0 +1,44 @@
+[
+    {
+        "function_name": "multiTransfer",
+        "vulnerability": "Integer Overflow in Token Transfer",
+        "criticism": "The reasoning is correct. In Solidity <0.8.0, integer overflow is not automatically checked. The summation of `_amounts` in a loop can overflow, allowing an attacker to bypass the balance check and mint tokens. This directly violates the token's integrity, enabling theft. Severity is critical as it breaks the core token economics. Profitability is high because attackers can create tokens arbitrarily and drain value.",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 9,
+        "reason": "The `multiTransfer` function calculates `totalAmount` by summing all `_amounts` without overflow checks. Using Solidity 0.4.18 (which lacks automatic overflow protection), an attacker can craft `_amounts` values that overflow `totalAmount`, bypassing the `balances[msg.sender] >= totalAmount` check. For example, if the sum overflows to a small value, the attacker's balance is reduced minimally, but recipients receive large amounts, effectively stealing tokens from the contract.",
+        "code": "function multiTransfer(address[] _addresses, uint[] _amounts) public returns (bool success) { require(_addresses.length <= 100 && _addresses.length == _amounts.length); uint totalAmount; for (uint a = 0; a < _amounts.length; a++) { totalAmount += _amounts[a]; } require(totalAmount > 0 && balances[msg.sender] >= totalAmount); balances[msg.sender] -= totalAmount; for (uint b = 0; b < _addresses.length; b++) { if (_amounts[b] > 0) { balances[_addresses[b]] += _amounts[b]; Transfer(msg.sender, _addresses[b], _amounts[b]); } } return true; }",
+        "label": "Integer Overflow",
+        "file_name": "2018-13836.sol",
+        "description": "An integer overflow vulnerability exists in the function multiTransfer of Rocket Coin (XRC), an Ethereum token smart contract. An attacker could use it to set any user's balance.",
+        "final_score": 9.0
+    },
+    {
+        "function_name": "approve",
+        "vulnerability": "Front-Runnable Approval",
+        "criticism": "The reasoning is valid. The absence of a zero-reset in `approve` allows front-running when reducing allowances. However, this is a known ERC-20 design limitation, not a code flaw. Severity is moderate as it depends on user behavior (e.g., reducing allowances). Profitability is context-dependent but possible if allowances are large. The vulnerability is real but inherent to the standard pattern.",
+        "correctness": 8,
+        "severity": 6,
+        "profitability": 7,
+        "reason": "The `approve` function allows a user to set a new allowance without first resetting it to zero. An attacker can front-run a user's approval reduction (e.g., from 5 to 3) by observing the transaction in the mempool and executing a `transferFrom` with the old allowance (5) before it is reduced. This enables double-spending of the originally approved amount, violating the user's intended authorization limits.",
+        "code": "function approve(address _spender, uint256 _amount) public returns (bool success) { allowed[msg.sender][_spender] = _amount; Approval(msg.sender, _spender, _amount); return true; }",
+        "label": "Integer Overflow",
+        "file_name": "2018-13836.sol",
+        "description": "An integer overflow vulnerability exists in the function multiTransfer of Rocket Coin (XRC), an Ethereum token smart contract. An attacker could use it to set any user's balance.",
+        "final_score": 7.25
+    },
+    {
+        "function_name": "fallback function",
+        "vulnerability": "Trapped ETH with No Handling",
+        "criticism": "The reasoning is accurate. The `payable` fallback function does not handle incoming ETH, leading to permanent loss. Severity is high for users but low for the contract itself. Profitability is zero for attackers, but user funds are irrecoverable. The flaw is a design oversight, making it critical for user experience but not directly exploitable for profit.",
+        "correctness": 9,
+        "severity": 7,
+        "profitability": 0,
+        "reason": "The fallback function is `payable` but does not process incoming ETH. Users may mistakenly send ETH (e.g., assuming it's required for the airdrop), which becomes permanently locked in the contract. While the airdrop itself does not require ETH, the contract's design misleads users into sending funds that are never used or returned, resulting in accidental financial loss.",
+        "code": "function() public payable { require(airDropStatus && balances[owner] >= airDropAmount && !participants[msg.sender] && tx.gasprice >= airDropGasPrice); balances[owner] -= airDropAmount; balances[msg.sender] += airDropAmount; Transfer(owner, msg.sender, airDropAmount); participants[msg.sender] = true; }",
+        "label": "Integer Overflow",
+        "file_name": "2018-13836.sol",
+        "description": "An integer overflow vulnerability exists in the function multiTransfer of Rocket Coin (XRC), an Ethereum token smart contract. An attacker could use it to set any user's balance.",
+        "final_score": 6.25
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-15552.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-15552.json
new file mode 100644
index 00000000..28888325
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-15552.json
@@ -0,0 +1,44 @@
+[
+    {
+        "function_name": "withdraw",
+        "vulnerability": "Owner can steal funds mid-lottery",
+        "criticism": "The reasoning is accurate. The withdraw() function allows the owner to drain the contract balance and reset state variables at any time, even mid-lottery. This is a critical centralization risk. Correctness is 9 because the code explicitly enables this. Severity is 9 because it directly enables fund theft. Profitability is 9 for the owner (though not an external attacker), but since the vulnerability centers on owner abuse, the exploit potential is maximal.",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 9,
+        "reason": "The withdraw() function allows the owner to reset the lottery state (numtickets, totalBounty) and transfer the entire contract balance to themselves at any time, including during an active round. This enables the owner to steal all accumulated ticket funds from participants before the lottery completes. Participants who already bought tickets would lose their ETH without any reward distribution.",
+        "code": "function withdraw() public { require(worldOwner == msg.sender); lottoIndex += 1; numtickets = 0; totalBounty = 0; worldOwner.transfer(this.balance); }",
+        "label": "Bad Randomness",
+        "file_name": "2018-15552.sol",
+        "description": "The \"PayWinner\" function of a simplelottery smart contract implementation for The Ethereum Lottery, an Ethereum gambling game, generates a random value with publicly readable variable \"maxTickets\" (which is private, yet predictable and readable by the eth.getStorageAt function). Therefore, it allows attackers to always win and get rewards.",
+        "final_score": 9.0
+    },
+    {
+        "function_name": "AddTicket",
+        "vulnerability": "Predictable last-ticket winner selection",
+        "criticism": "The reasoning is valid. The winner is deterministically the last ticket purchaser, enabling MEV bots to front-run the final transaction. Correctness is 9 (code enforces this logic). Severity is 7 (violates fairness but doesn\u2019t directly drain funds). Profitability is 8 for attackers with MEV capabilities, as they can guarantee wins. However, this is more a design flaw than a traditional vulnerability; it assumes malicious actors can manipulate transaction ordering, which is inherent to Ethereum\u2019s mechanics.",
+        "correctness": 9,
+        "severity": 7,
+        "profitability": 8,
+        "reason": "The winner is deterministically set to the last address that submits a ticket when maxTickets is reached. Attackers can monitor the blockchain for pending transactions and front-run the final ticket purchase to guarantee they become the winner. This violates fair lottery mechanics and allows centralized exploitation by bots/MEV searchers.",
+        "code": "function AddTicket() public payable { require(msg.value == ticketPrice); require(numtickets < maxTickets); lastTicketTime = now; numtickets += 1; totalBounty += ticketPrice; bool success = numtickets == maxTickets; NewTicket(msg.sender, success); if(success) { PayWinner(msg.sender); } }",
+        "label": "Bad Randomness",
+        "file_name": "2018-15552.sol",
+        "description": "The \"PayWinner\" function of a simplelottery smart contract implementation for The Ethereum Lottery, an Ethereum gambling game, generates a random value with publicly readable variable \"maxTickets\" (which is private, yet predictable and readable by the eth.getStorageAt function). Therefore, it allows attackers to always win and get rewards.",
+        "final_score": 8.25
+    },
+    {
+        "function_name": "PayWinner",
+        "vulnerability": "DoS via failed winner transfer",
+        "criticism": "The analysis is correct. Using transfer() without handling failures can permanently brick the contract. If the winner is a non-payable contract, the transfer reverts, leaving numtickets == maxTickets and blocking AddTicket() indefinitely. Correctness is 9 (code uses unsafe transfer). Severity is 8 (permanent DoS), but profitability is 2: attackers can disrupt the contract but gain little unless they sabotage for ideological reasons. The vulnerability is severe for system availability but offers limited direct profit.",
+        "correctness": 9,
+        "severity": 8,
+        "profitability": 2,
+        "reason": "PayWinner uses transfer() to send funds to the winner. If the winner is a contract without a payable fallback function, the transfer will fail, reverting the entire transaction. This leaves the contract state (numtickets == maxTickets) unchanged, permanently blocking the AddTicket function (due to its numtickets < maxTickets check). Attackers can exploit this by purchasing the last ticket with a non-payable address to intentionally brick the contract.",
+        "code": "function PayWinner( address winner ) private { require(numtickets == maxTickets); uint ownerTax = 6 * totalBounty / 100; uint winnerPrice = totalBounty - ownerTax; LottoComplete(msg.sender, lottoIndex, winnerPrice); lottoIndex += 1; numtickets = 0; totalBounty = 0; if(_direction == 0 && maxTickets < 20) maxTickets += 1; if(_direction == 1 && maxTickets > 10) maxTickets -= 1; if(_direction == 0 && maxTickets == 20) _direction = 1; if(_direction == 1 && maxTickets == 10) _direction = 0; worldOwner.transfer(ownerTax); winner.transfer(winnerPrice); }",
+        "label": "Bad Randomness",
+        "file_name": "2018-15552.sol",
+        "description": "The \"PayWinner\" function of a simplelottery smart contract implementation for The Ethereum Lottery, an Ethereum gambling game, generates a random value with publicly readable variable \"maxTickets\" (which is private, yet predictable and readable by the eth.getStorageAt function). Therefore, it allows attackers to always win and get rewards.",
+        "final_score": 7.0
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-17877.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-17877.json
new file mode 100644
index 00000000..1a06423d
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-17877.json
@@ -0,0 +1,44 @@
+[
+    {
+        "function_name": "luckyBuy",
+        "vulnerability": "Insecure Pseudo-Randomness",
+        "criticism": "The reasoning is correct. The function relies entirely on predictable/miner-manipulable variables (block.timestamp, block.difficulty, etc.) to generate randomness. This allows miners or attackers to precompute favorable seeds and game the system. The severity is high as it directly undermines the fairness of the 'lucky' mechanism. Profitability is also high since attackers could systematically exploit this to win prizes. However, the impact depends on the value of the prize pool, which is not specified here.",
+        "correctness": 9,
+        "severity": 8,
+        "profitability": 8,
+        "reason": "The 'luckyBuy' function uses block.timestamp, block.difficulty, block.coinbase, and other predictable on-chain data to generate randomness. Miners can manipulate these values to influence the outcome, allowing attackers to increase their chances of winning the Luckybuy prize. This makes the randomness exploitable and not truly random.",
+        "code": "function luckyBuy() private view returns(bool) { uint256 seed = uint256(keccak256(abi.encodePacked( (block.timestamp).add (block.difficulty).add ((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add (block.gaslimit).add ((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add (block.number) ))); if((seed - ((seed / 1000) * 1000)) < luckybuyTracker_) return(true); else return(false); }",
+        "label": "Bad Randomness",
+        "file_name": "2018-17877.sol",
+        "description": "A lottery smart contract implementation for Greedy 599, an Ethereum gambling game, generates a random value that is predictable via an external contract call. The developer used the extcodesize() function to prevent a malicious contract from being called, but the attacker can bypass it by writing the core code in the constructor of their exploit code. Therefore, it allows attackers to always win and get rewards.",
+        "final_score": 8.5
+    },
+    {
+        "function_name": "buyHeart",
+        "vulnerability": "Contract Call Bypass",
+        "criticism": "The reasoning is correct. The extcodesize check is ineffective during contract construction (constructor phase), allowing malicious contracts to bypass the 'humans only' restriction. Severity is high (7) if the contract relies on human exclusivity for anti-botting or fairness. Profitability is high (8) if automated contract interactions provide unfair advantages (e.g., sniping limited resources). The vulnerability is well-known but remains critical in contexts requiring human participation.",
+        "correctness": 9,
+        "severity": 7,
+        "profitability": 8,
+        "reason": "The 'buyHeart' function checks if the sender is a contract by checking extcodesize. However, during contract construction (constructor), extcodesize returns 0, allowing malicious contracts to bypass this check. Attackers can exploit this to automate purchases or manipulate the game logic, violating the 'humans only' requirement.",
+        "code": "function buyHeart(address referred) public payable { ... address _addr = msg.sender; uint256 _codeLength; assembly {_codeLength := extcodesize(_addr)} require(_codeLength == 0, \"sorry humans only\"); ... }",
+        "label": "Bad Randomness",
+        "file_name": "2018-17877.sol",
+        "description": "A lottery smart contract implementation for Greedy 599, an Ethereum gambling game, generates a random value that is predictable via an external contract call. The developer used the extcodesize() function to prevent a malicious contract from being called, but the attacker can bypass it by writing the core code in the constructor of their exploit code. Therefore, it allows attackers to always win and get rewards.",
+        "final_score": 8.25
+    },
+    {
+        "function_name": "win",
+        "vulnerability": "DoS via Failed Transfer",
+        "criticism": "The reasoning is accurate. The use of transfer() without handling revert scenarios creates a critical DoS risk. If RoundLastGreedyMan[Round] is a contract with a non-payable fallback (e.g., gas-intensive or intentionally malicious), the transfer fails, blocking Round++ and freezing contract progression. Severity is extreme (9) since the entire protocol halts. Profitability is moderate (5) only if attackers can intentionally become RoundLastGreedyMan and trigger this to block competitors, but this requires specific preconditions.",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 5,
+        "reason": "The 'win' function uses transfer() to send ETH to RoundLastGreedyMan without handling potential failures. If the winner is a contract with a fallback function that reverts (e.g., due to gas limits or intentional sabotage), the transfer will fail, causing the entire transaction to revert. This prevents the round from incrementing, halting the contract indefinitely.",
+        "code": "function win() public { require(now > RoundTime[Round] && RoundTime[Round] != 0); RoundLastGreedyMan[Round].transfer(RoundETH[Round]); emit winnerEvent(RoundLastGreedyMan[Round], RoundETH[Round], Round); Round++; }",
+        "label": "Bad Randomness",
+        "file_name": "2018-17877.sol",
+        "description": "A lottery smart contract implementation for Greedy 599, an Ethereum gambling game, generates a random value that is predictable via an external contract call. The developer used the extcodesize() function to prevent a malicious contract from being called, but the attacker can bypass it by writing the core code in the constructor of their exploit code. Therefore, it allows attackers to always win and get rewards.",
+        "final_score": 8.0
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-17882.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-17882.json
new file mode 100644
index 00000000..55950c84
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-17882.json
@@ -0,0 +1,44 @@
+[
+    {
+        "function_name": "batchTransfer",
+        "vulnerability": "Integer overflow in multiplication",
+        "criticism": "The reasoning is accurate. The lack of a safeMul check allows an attacker to force an overflow, deduct negligible tokens from their balance, and credit recipients with large amounts. This directly enables token inflation, making severity and profitability extremely high. The use of safeSub does not mitigate the unchecked multiplication.",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 9,
+        "reason": "The multiplication '_to.length * _value' in batchTransfer is vulnerable to integer overflow. An attacker can craft a large '_to.length' and '_value' such that the product overflows to a small value (e.g., 0). This allows them to bypass balance checks, deduct little/no tokens from their balance, while still crediting all recipients with '_value' tokens. This effectively mints tokens out of thin air.",
+        "code": "function batchTransfer(address[] _to, uint _value) public {\n    balances[msg.sender] = safeSub(\n        balances[msg.sender],\n        _to.length * _value\n    );\n    for (uint i = 0; i < _to.length; i++) {\n        balances[_to[i]] = safeAdd(balances[_to[i]], _value);\n        Transfer(msg.sender, _to[i], _value);\n    }\n}",
+        "label": "Integer Overflow",
+        "file_name": "2018-17882.sol",
+        "description": "An Integer overflow vulnerability exists in the batchTransfer function of a smart contract implementation for CryptoBotsBattle (CBTB), an Ethereum token. This vulnerability could be used by an attacker to create an arbitrary amount of tokens for any user.",
+        "final_score": 9.0
+    },
+    {
+        "function_name": "transferFrom",
+        "vulnerability": "Unauthorized transfers to 'fights' address",
+        "criticism": "The reasoning correctly identifies that transfers to the 'fights' address bypass allowance checks. However, the severity depends on whether 'fights' is attacker-controlled. If 'fights' is immutable or non-malicious, the impact is limited to forced token burns or disruptions. If 'fights' can be set by the attacker (e.g., via compromised owner), severity increases. Profitability is moderate only if the attacker can extract value from 'fights'.",
+        "correctness": 9,
+        "severity": 7,
+        "profitability": 5,
+        "reason": "The transferFrom function does not check or deduct the allowance when transferring to the 'fights' address. This allows any user to transfer tokens from any account to the 'fights' address without requiring approval. An attacker can exploit this by setting 'fights' to a controlled address (if owner is compromised) or leveraging existing 'fights' access to drain funds from arbitrary accounts.",
+        "code": "function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {\n    balances[_to] = safeAdd(balances[_to], _value);\n    balances[_from] = safeSub(balances[_from], _value);\n    if (_to != fights) {\n        allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value);\n    }\n    Transfer(_from, _to, _value);\n    return true;\n}",
+        "label": "Integer Overflow",
+        "file_name": "2018-17882.sol",
+        "description": "An Integer overflow vulnerability exists in the batchTransfer function of a smart contract implementation for CryptoBotsBattle (CBTB), an Ethereum token. This vulnerability could be used by an attacker to create an arbitrary amount of tokens for any user.",
+        "final_score": 7.5
+    },
+    {
+        "function_name": "transferFrom",
+        "vulnerability": "Incorrect allowance handling order",
+        "criticism": "The code does update balances before allowances, but safeSub ensures allowance underflow reverts the transaction, preventing direct exploitation. While violating checks-effects-interactions, there are no external calls to enable reentrancy. The reasoning overstates the risk; this is a code-style issue, not an active vulnerability. Severity and profitability are negligible.",
+        "correctness": 3,
+        "severity": 1,
+        "profitability": 0,
+        "reason": "The transferFrom function updates balances before modifying allowances. While safe for non-fights addresses (due to revert on underflow), this violates the checks-effects-interactions pattern. If external calls were present, this could enable reentrancy. Though not directly exploitable here, it reflects poor security practices and increases risk if contract logic evolves.",
+        "code": "function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {\n    balances[_to] = safeAdd(balances[_to], _value);\n    balances[_from] = safeSub(balances[_from], _value);\n    if (_to != fights) {\n        allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value);\n    }\n    Transfer(_from, _to], _value);\n    return true;\n}",
+        "label": "Integer Overflow",
+        "file_name": "2018-17882.sol",
+        "description": "An Integer overflow vulnerability exists in the batchTransfer function of a smart contract implementation for CryptoBotsBattle (CBTB), an Ethereum token. This vulnerability could be used by an attacker to create an arbitrary amount of tokens for any user.",
+        "final_score": 1.75
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-18425.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-18425.json
new file mode 100644
index 00000000..98034b12
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-18425.json
@@ -0,0 +1,44 @@
+[
+    {
+        "function_name": "approve",
+        "vulnerability": "Non-standard ERC20 allowance freeze",
+        "criticism": "The reasoning is correct. The function enforces a non-standard ERC20 behavior by blocking non-zero allowance updates, requiring users to reset to zero first. This creates a front-running risk during allowance adjustments. However, the severity is moderate because it primarily affects compatibility with standard contracts rather than enabling direct theft. Profitability for attackers is low, as exploitation requires specific user actions (allowance changes) and only allows stealing up to the original allowance amount.",
+        "correctness": 9,
+        "severity": 6,
+        "profitability": 3,
+        "reason": "The approve function prevents updating an existing non-zero allowance to another non-zero value. This violates ERC20 standards and forces users to reset their allowance to zero first, creating a race condition vulnerable to front-running attacks. Contracts/DEXs expecting standard behavior will fail when users try to adjust allowances, breaking compatibility and potentially locking funds.",
+        "code": "function approve(address _spender, uint256 _value) public returns (bool success) { if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; } allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; }",
+        "label": "Token Devalue",
+        "file_name": "2018-18425.sol",
+        "description": "The doAirdrop function of a smart contract implementation for Primeo (PEO), an Ethereum token, does not check the numerical relationship between the amount of the air drop and the token's total supply, which lets the owner of the contract issue an arbitrary amount of currency. (Increasing the total supply by using 'doAirdrop' ignores the hard cap written in the contract and devalues the token.)",
+        "final_score": 6.75
+    },
+    {
+        "function_name": "withdraw",
+        "vulnerability": "Owner ETH drain",
+        "criticism": "The reasoning is accurate. The function allows immediate full ETH extraction by the owner with no safeguards. This is a critical centralization risk and direct scam vector. Severity is extreme (9) as it enables total fund loss. However, profitability scores 0 under the assumption that scoring reflects external attacker profit potential - this is strictly owner abuse. From a system impact perspective, this is a 9/9 vulnerability, but following prior example conventions for privileged roles, external attackers cannot exploit it.",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 0,
+        "reason": "The withdraw function allows the owner to drain all ETH from the contract at any time. Users sending ETH during token distribution have no guarantee their funds will be used as intended. This creates a direct financial scam vector where the owner can collect ETH and disappear without distributing proper token value.",
+        "code": "function withdraw() onlyOwner public { address myAddress = this; uint256 etherBalance = myAddress.balance; owner.transfer(etherBalance); }",
+        "label": "Token Devalue",
+        "file_name": "2018-18425.sol",
+        "description": "The doAirdrop function of a smart contract implementation for Primeo (PEO), an Ethereum token, does not check the numerical relationship between the amount of the air drop and the token's total supply, which lets the owner of the contract issue an arbitrary amount of currency. (Increasing the total supply by using 'doAirdrop' ignores the hard cap written in the contract and devalues the token.)",
+        "final_score": 6.75
+    },
+    {
+        "function_name": "doAirdrop",
+        "vulnerability": "Supply cap bypass",
+        "criticism": "The analysis is fully correct. The pre-addition check allows minting beyond totalSupply when totalDistributed is near the cap. This completely breaks the token's supply guarantee, enabling hyperinflation. Severity is catastrophic (9) as it undermines the token's fundamental economics. Profitability scores 0 for external attackers (assuming internal/owner-only access), but the owner could theoretically profit by minting unlimited tokens. Following example conventions for owner privileges, we score profitability 0 despite massive owner abuse potential.",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 0,
+        "reason": "The doAirdrop function only checks if totalDistributed < totalSupply BEFORE adding new tokens. If totalDistributed is 1 unit less than totalSupply, the owner can airdrop any amount (e.g., 1B tokens), causing totalDistributed to exceed totalSupply. This breaks the token's supply cap, enabling infinite inflation and total devaluation of the token.",
+        "code": "function doAirdrop(address _participant, uint _amount) internal { require( _amount > 0 ); require( totalDistributed < totalSupply ); balances[_participant] = balances[_participant].add(_amount); totalDistributed = totalDistributed.add(_amount); if (totalDistributed >= totalSupply) { distributionFinished = true; } emit Airdrop(_participant, _amount, balances[_participant]); emit Transfer(address(0), _participant, _amount); }",
+        "label": "Token Devalue",
+        "file_name": "2018-18425.sol",
+        "description": "The doAirdrop function of a smart contract implementation for Primeo (PEO), an Ethereum token, does not check the numerical relationship between the amount of the air drop and the token's total supply, which lets the owner of the contract issue an arbitrary amount of currency. (Increasing the total supply by using 'doAirdrop' ignores the hard cap written in the contract and devalues the token.)",
+        "final_score": 6.75
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-19830.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-19830.json
new file mode 100644
index 00000000..25972352
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2018-19830.json
@@ -0,0 +1,44 @@
+[
+    {
+        "function_name": "approve",
+        "vulnerability": "Unsafe Allowance Update",
+        "criticism": "The reasoning is correct. By enforcing a zero-reset before updating allowances, the function introduces a race condition. Attackers can front-run the reset transaction to exploit the old allowance. This is a well-documented ERC20 flaw with high severity and profitability, as malicious spenders can drain funds during the approval window.",
+        "correctness": 9,
+        "severity": 8,
+        "profitability": 8,
+        "reason": "The approve function throws when updating a non-zero allowance to another non-zero value. This forces users to reset allowance to zero first, creating a race condition where a spender can use the old allowance before it is updated. Attackers can front-run the second approval transaction to drain funds using the outdated allowance.",
+        "code": "function approve(address _spender, uint _value) unFrozenAccount { if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw; allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); }",
+        "label": "Access Control",
+        "file_name": "2018-19830.sol",
+        "description": "The UBSexToken() function of a smart contract implementation for Business Alliance Financial Circle (BAFC), an tradable Ethereum ERC20 token, allows attackers to change the owner of the contract, because the function is public (by default) and does not check the caller's identity.",
+        "final_score": 8.5
+    },
+    {
+        "function_name": "transfer",
+        "vulnerability": "Missing ERC20 Return Value",
+        "criticism": "The reasoning is accurate: the function lacks a boolean return value, violating ERC20 standards. This breaks interoperability with ERC20-reliant systems, causing transactions to fail. However, the severity is high for contract usability but low for direct exploitation. Attackers cannot profit from this flaw, but it critically impacts the token's functionality.",
+        "correctness": 9,
+        "severity": 8,
+        "profitability": 2,
+        "reason": "The transfer function does not return a boolean as required by the ERC20 standard. Contracts/Wallets expecting ERC20 compliance will treat the missing return value as a failure, causing transactions to revert. This breaks interoperability with exchanges, DeFi protocols, and other ERC20-reliant systems.",
+        "code": "function transfer(address _to, uint _value) onlyPayloadSize(2 * 32) unFrozenAccount onlyTransferable { if (frozenAccount[_to]) { InvalidAccount(_to, \"The receiver account is frozen\"); } else { balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); } }",
+        "label": "Access Control",
+        "file_name": "2018-19830.sol",
+        "description": "The UBSexToken() function of a smart contract implementation for Business Alliance Financial Circle (BAFC), an tradable Ethereum ERC20 token, allows attackers to change the owner of the contract, because the function is public (by default) and does not check the caller's identity.",
+        "final_score": 7.0
+    },
+    {
+        "function_name": "UBSexToken",
+        "vulnerability": "Insecure Initialization via Public Function",
+        "criticism": "The reasoning assumes the function is public due to a mismatched constructor name. However, if the contract is named 'UBSexToken', this is a valid constructor (pre-Solidity 0.4.22) and cannot be called post-deployment. The vulnerability only exists if the contract name differs, which is not confirmed here. Thus, the analysis is contextually flawed. If correct (contract name mismatch), severity would be catastrophic, but the assumption is unverified.",
+        "correctness": 2,
+        "severity": 0,
+        "profitability": 0,
+        "reason": "The function UBSexToken() is not a constructor (mismatched contract name) and is publicly callable. Attackers can invoke it post-deployment to reset the owner, totalSupply, and balances, effectively hijacking the contract. This allows an attacker to mint the entire token supply to themselves and gain ownership, leading to total control over the contract.",
+        "code": "function UBSexToken() { owner = msg.sender; totalSupply = 1.9 * 10 ** 26; balances[owner] = totalSupply; }",
+        "label": "Access Control",
+        "file_name": "2018-19830.sol",
+        "description": "The UBSexToken() function of a smart contract implementation for Business Alliance Financial Circle (BAFC), an tradable Ethereum ERC20 token, allows attackers to change the owner of the contract, because the function is public (by default) and does not check the caller's identity.",
+        "final_score": 1.0
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2019-15078.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2019-15078.json
new file mode 100644
index 00000000..1730b00d
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2019-15078.json
@@ -0,0 +1,44 @@
+[
+    {
+        "function_name": "onlyPayloadSize",
+        "vulnerability": "Gas exhaustion via assert()",
+        "criticism": "The analysis is accurate. Using assert() instead of require() creates gas-draining potential, as failed assertions consume all transaction gas. This could be weaponized in short-address attacks or malformed payloads. Severity is high due to the irreversible gas loss, but profitability requires attackers to trick users into initiating the transactions (e.g., via phishing). While dangerous, real-world exploitation requires social engineering, making direct profitability moderate. The correctness score is high as the code flaw is unambiguous.",
+        "correctness": 9,
+        "severity": 8,
+        "profitability": 6,
+        "reason": "The onlyPayloadSize modifier uses assert() to validate transaction payload size. Unlike require(), assert() consumes all gas on failure. Attackers can craft malformed transactions (e.g., short-address attacks) to trigger this assertion, forcing victims to waste all gas. This enables gas-draining attacks and disrupts user transactions, directly benefiting attackers by increasing operational costs.",
+        "code": "modifier onlyPayloadSize(uint size) {\n    assert(msg.data.length >= size + 4);\n    _;\n}",
+        "label": "Typo Constructor",
+        "file_name": "2019-15078.sol",
+        "description": "An issue was discovered in a smart contract implementation for AIRDROPX BORN through 2019-05-29, an Ethereum token. The name of the constructor has a typo (wrong case: XBornID versus XBORNID) that allows an attacker to change the owner of the contract and obtain cryptocurrency for free.",
+        "final_score": 8.0
+    },
+    {
+        "function_name": "approve",
+        "vulnerability": "Non-standard ERC20 approve",
+        "criticism": "The reasoning correctly identifies the ERC20 standard violation. By returning false when attempting to update a non-zero allowance, the function deviates from the ERC20 specification, which allows adjusting allowances from any value. This creates compatibility issues with contracts expecting standard behavior, enabling front-running attacks to lock approvals. However, the severity is reduced because modern UIs often handle allowance resets, and profitability depends on attacker ability to exploit front-running, which is situational. The direct financial impact is limited unless combined with other attack vectors.",
+        "correctness": 8,
+        "severity": 6,
+        "profitability": 4,
+        "reason": "The approve function returns false if attempting to update a non-zero allowance to another non-zero value, violating ERC20 standards. This prevents users from adjusting existing allowances without first resetting them to zero. Attackers can exploit this by front-running approval changes, causing transactions to fail or funds to be locked. Contracts expecting standard ERC20 behavior will misinterpret the false return value, leading to operational failures.",
+        "code": "function approve(address _spender, uint256 _value) public returns (bool success) {\n    if (_value != 0 && allowed[msg.sender][_spender] != 0) {\n        return false;\n    }\n    allowed[msg.sender][_spender] = _value;\n    emit Approval(msg.sender, _spender, _value);\n    return true;\n}",
+        "label": "Typo Constructor",
+        "file_name": "2019-15078.sol",
+        "description": "An issue was discovered in a smart contract implementation for AIRDROPX BORN through 2019-05-29, an Ethereum token. The name of the constructor has a typo (wrong case: XBornID versus XBORNID) that allows an attacker to change the owner of the contract and obtain cryptocurrency for free.",
+        "final_score": 6.5
+    },
+    {
+        "function_name": "getTokens",
+        "vulnerability": "ETH trapping with owner withdrawal",
+        "criticism": "The reasoning is partially correct. While the function accepts ETH without processing it, the vulnerability assumes the existence of a withdraw() function (not shown). If withdrawal logic exists, trapped ETH could be stolen by the owner. Severity depends on the contract's ETH balance size and user awareness. Profitability requires active social engineering to trick users into sending ETH. The code flaw itself (payable without value handling) is severe, but exploitation requires external factors, lowering immediate risk.",
+        "correctness": 7,
+        "severity": 7,
+        "profitability": 5,
+        "reason": "The getTokens function is payable but does not process or validate msg.value. Users can accidentally send ETH, which remains trapped in the contract. The owner can withdraw these funds via withdraw(), creating a risk of financial loss for users. Attackers can also social-engineer victims into sending ETH, effectively stealing funds through the owner's withdrawal capability.",
+        "code": "function getTokens() payable canDistr onlyWhitelist public {\n    if (value > totalRemaining) {\n        value = totalRemaining;\n    }\n    require(value <= totalRemaining);\n    address investor = msg.sender;\n    uint256 toGive = value;\n    distr(investor, toGive);\n    if (toGive > 0) {\n        blacklist[investor] = true;\n    }\n    if (totalDistributed >= totalSupply) {\n        distributionFinished = true;\n    }\n    value = value.div(100000).mul(99999);\n}",
+        "label": "Typo Constructor",
+        "file_name": "2019-15078.sol",
+        "description": "An issue was discovered in a smart contract implementation for AIRDROPX BORN through 2019-05-29, an Ethereum token. The name of the constructor has a typo (wrong case: XBornID versus XBORNID) that allows an attacker to change the owner of the contract and obtain cryptocurrency for free.",
+        "final_score": 6.5
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2019-15079.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2019-15079.json
new file mode 100644
index 00000000..6636d6c9
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2019-15079.json
@@ -0,0 +1,44 @@
+[
+    {
+        "function_name": "EAI_TokenERC20",
+        "vulnerability": "Reinitialization Attack",
+        "criticism": "The reasoning is correct. The constructor name mismatch (EAI_TokenERC20 vs. contract EAI_TokenERC) makes it a public function. In Solidity versions <0.4.22, this allows anyone to reinitialize the contract, resetting critical state variables (totalSupply, name, symbol) and granting the attacker all tokens. This is a critical vulnerability: correctness is maximized because the exploit is unambiguous, severity is extreme (total contract hijack), and profitability is maximal (attacker gains full token control).",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 9,
+        "reason": "The constructor is incorrectly named (EAI_TokenERC20 vs. contract name EAI_TokenERC), making it a public function callable by anyone. Attackers can reinitialize the contract, resetting totalSupply, name, symbol, and assigning themselves the entire token supply. This allows them to mint unlimited tokens, overwrite the contract's state, and effectively hijack control.",
+        "code": "function EAI_TokenERC20( uint256 initialSupply, string tokenName, string tokenSymbol ) public { totalSupply = initialSupply * 10 ** uint256(decimals); balanceOf[msg.sender] = totalSupply; name = tokenName; symbol = tokenSymbol; }",
+        "label": "Typo Constructor",
+        "file_name": "2019-15079.sol",
+        "description": "A typo exists in the constructor of a smart contract implementation for EAI through 2019-06-05, an Ethereum token. This vulnerability could be used by an attacker to acquire EAI tokens for free.",
+        "final_score": 9.0
+    },
+    {
+        "function_name": "_transfer",
+        "vulnerability": "Arithmetic Over/Underflow Risk",
+        "criticism": "The reasoning is partially flawed. While Solidity 0.4.16 lacks native overflow checks, the manual require(balanceOf[_to] + _value >= balanceOf[_to]) effectively prevents overflow by reverting if addition exceeds uint256. The asserted risk of previousBalances overflow is negligible (sum of two balances exceeding 2^256 is practically impossible). The actual vulnerability is minor: correctness is low because manual checks are sufficient, severity is minimal (no realistic exploit path), and profitability is nonexistent.",
+        "correctness": 2,
+        "severity": 1,
+        "profitability": 0,
+        "reason": "While manual overflow checks exist, the contract uses Solidity 0.4.16, which lacks native overflow protection. If edge cases bypass the require(balanceOf[_to] + _value >= balanceOf[_to]) check (e.g., via unexpected overflow wrapping), token balances could be corrupted. The assert may fail to detect overflow in previousBalances if the initial sum exceeds uint256 max, leading to inconsistent states.",
+        "code": "function _transfer(address _from, address _to, uint _value) internal { require(_to != 0x0); require(balanceOf[_from] >= _value); require(balanceOf[_to] + _value >= balanceOf[_to]); uint previousBalances = balanceOf[_from] + balanceOf[_to]; balanceOf[_from] -= _value; balanceOf[_to] += _value; emit Transfer(_from, _to, _value); assert(balanceOf[_from] + balanceOf[_to] == previousBalances); }",
+        "label": "Typo Constructor",
+        "file_name": "2019-15079.sol",
+        "description": "A typo exists in the constructor of a smart contract implementation for EAI through 2019-06-05, an Ethereum token. This vulnerability could be used by an attacker to acquire EAI tokens for free.",
+        "final_score": 1.25
+    },
+    {
+        "function_name": "transferFrom",
+        "vulnerability": "Front-Running Allowance Race",
+        "criticism": "The reasoning is incorrect. In Solidity, state changes (allowance decrement) are atomic with the entire transaction. If _transfer reverts (e.g., due to insufficient balance), the allowance reduction is rolled back. There is no scenario where allowance is permanently reduced without a successful transfer. The alleged front-running exploit is invalid. Correctness is 0, as the vulnerability does not exist; severity and profitability are irrelevant.",
+        "correctness": 0,
+        "severity": 0,
+        "profitability": 0,
+        "reason": "The transferFrom function decrements the allowance before performing the transfer. If the transfer fails (e.g., due to a later revert in _transfer), the allowance is permanently reduced. Attackers could exploit this by front-running transactions to cause intentional failures, effectively locking users' allowances and disrupting expected behavior.",
+        "code": "function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) { require(_value <= allowance[_from][msg.sender]); allowance[_from][msg.sender] -= _value; _transfer(_from, _to, _value); return true; }",
+        "label": "Typo Constructor",
+        "file_name": "2019-15079.sol",
+        "description": "A typo exists in the constructor of a smart contract implementation for EAI through 2019-06-05, an Ethereum token. This vulnerability could be used by an attacker to acquire EAI tokens for free.",
+        "final_score": 0.0
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2019-15080.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2019-15080.json
new file mode 100644
index 00000000..1396411a
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2019-15080.json
@@ -0,0 +1,44 @@
+[
+    {
+        "function_name": "owned",
+        "vulnerability": "Publicly callable ownership takeover",
+        "criticism": "The reasoning is correct. The function 'owned()' is not a constructor (due to Solidity <0.4.22 naming rules) and remains publicly callable post-deployment, allowing anyone to reset ownership. This is a critical vulnerability as it grants full contract control. Severity is extreme (9) since ownership takeover enables all privileged functions. Profitability is high (9) for attackers exploiting this. However, correctness depends on deployment context; if the contract's actual constructor already initialized ownership, this function's existence is a catastrophic oversight.",
+        "correctness": 9,
+        "severity": 9,
+        "profitability": 9,
+        "reason": "The function 'owned()' is public and lacks access control, allowing any caller to set themselves as the owner. This is due to the incorrect naming of the constructor (should be 'Owned()' in Solidity <0.4.22). Since the MorphToken constructor sets the owner, this function should not exist, but it remains callable post-deployment, enabling anyone to reset ownership.",
+        "code": "function owned() public { owner = msg.sender; }",
+        "label": "Typo Constructor",
+        "file_name": "2019-15080.sol",
+        "description": "An issue was discovered in a smart contract implementation for MORPH Token through 2019-06-05, an Ethereum token. A typo in the constructor of the Owned contract (which is inherited by MORPH Token) allows attackers to acquire contract ownership. A new owner can subsequently obtain MORPH Tokens for free and can perform a DoS attack.",
+        "final_score": 9.0
+    },
+    {
+        "function_name": "transferOwnership",
+        "vulnerability": "Unchecked zero-address ownership transfer",
+        "criticism": "The reasoning is correct. The lack of a zero-address check allows accidental or malicious ownership loss, permanently locking privileged functions. Severity is high (8) because it irreversibly disrupts governance, but profitability is lower (3) since it primarily enables denial-of-service rather than direct profit. Correctness is 9 as the code clearly omits the check.",
+        "correctness": 9,
+        "severity": 8,
+        "profitability": 3,
+        "reason": "The function does not validate if '_newOwner' is a non-zero address. If the owner accidentally transfers ownership to address(0), the contract becomes permanently ownerless, locking all onlyOwner functions (e.g., mintTokens, blacklistAccount) and disrupting protocol governance.",
+        "code": "function transferOwnership(address _newOwner) onlyOwner public { owner = _newOwner; }",
+        "label": "Typo Constructor",
+        "file_name": "2019-15080.sol",
+        "description": "An issue was discovered in a smart contract implementation for MORPH Token through 2019-06-05, an Ethereum token. A typo in the constructor of the Owned contract (which is inherited by MORPH Token) allows attackers to acquire contract ownership. A new owner can subsequently obtain MORPH Tokens for free and can perform a DoS attack.",
+        "final_score": 7.25
+    },
+    {
+        "function_name": "approve",
+        "vulnerability": "Front-runnable allowance approval",
+        "criticism": "The reasoning is partially correct. The approve function lacks the standard mitigation (e.g., requiring allowance reset to zero first), making it vulnerable to front-running. However, this is a well-known design flaw in ERC-20, not a code-level bug. Severity is moderate (6) as it depends on user behavior. Profitability is high (7) if attackers exploit users adjusting allowances. Correctness is 8 since the code does not implement safeguards.",
+        "correctness": 8,
+        "severity": 6,
+        "profitability": 7,
+        "reason": "The approve() function does not implement checks for changing allowances (e.g., requiring allowance to be zero first). Attackers can front-run a user's approval change transaction to drain funds using the old allowance before it's updated, leading to double-spending of allowances.",
+        "code": "function approve(address _spender, uint256 _amount) public returns (bool success) { allowed[msg.sender][_spender] = _amount; Approval(msg.sender, _spender, _amount); return true; }",
+        "label": "Typo Constructor",
+        "file_name": "2019-15080.sol",
+        "description": "An issue was discovered in a smart contract implementation for MORPH Token through 2019-06-05, an Ethereum token. A typo in the constructor of the Owned contract (which is inherited by MORPH Token) allows attackers to acquire contract ownership. A new owner can subsequently obtain MORPH Tokens for free and can perform a DoS attack.",
+        "final_score": 7.25
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2021-3004.json b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2021-3004.json
new file mode 100644
index 00000000..7451ef92
--- /dev/null
+++ b/src/logs/auditor_deepseek-r1_0.7_top3_1/critic_deepseek-r1_0.0_1_few/ranker_default/CVE-2021-3004.json
@@ -0,0 +1,44 @@
+[
+    {
+        "function_name": "_deposit",
+        "vulnerability": "Oracle Price Manipulation",
+        "criticism": "The reasoning is correct. The _deposit function relies solely on the LINK oracle to calculate collateral value, ignoring the AMM pool's actual price. If the oracle is manipulated (e.g., stale data or centralized control), attackers can deposit undervalued assets and mint overvalued yCREDIT tokens. The severity is critical (9) as this directly compromises the protocol's solvency. Profitability is high (9) because attackers can drain funds by redeeming inflated yCREDIT. However, the code does interact with the AMM pool via _addLiquidity, which uses the pool's reserves to compute liquidity. This partially mitigates the impact, but the collateralCredit is still based on the manipulated oracle value, making the exploit viable.",
+        "correctness": 8,
+        "severity": 9,
+        "profitability": 9,
+        "reason": "The _deposit function calculates the deposited collateral value using a single oracle (LINK.getPriceUSD) without cross-verifying with the actual AMM pool price. If the oracle is manipulated or provides incorrect prices (e.g., due to stale data or centralized control), attackers can deposit undervalued assets to mint inflated yCREDIT tokens. This allows them to steal protocol funds by redeeming overvalued yCREDIT for legitimate collateral. This is a critical vulnerability as it directly affects the protocol's solvency.",
+        "code": "function _deposit(IERC20 token, uint amount) internal {\n    uint _value = LINK.getPriceUSD(address(token)) * amount / uint256(10)**token.decimals();\n    require(_value > 0, \"!value\");\n    (address _pair, uint amountA,) = _addLiquidity(address(token), address(this), amount, _value);\n    token.safeTransferFrom(msg.sender, _pair, amountA);\n    _mint(_pair, _value);\n    uint _liquidity = ISushiswapV2Pair(_pair).mint(address(this));\n    collateral[msg.sender][address(token)] += _liquidity;\n    collateralCredit[msg.sender][address(token)] += _value;\n    uint _fee = _value * FEE / BASE;\n    _mint(msg.sender, _value - _fee);\n    _mint(address(this), _fee);\n    notifyFeeAmount(_fee);\n    emit Deposit(msg.sender, address(token), _value, amount, _value);\n}",
+        "label": "Wrong Logic",
+        "file_name": "2021-3004.sol",
+        "description": "The _deposit function in the smart contract implementation for Stable Yield Credit (yCREDIT), an Ethereum token, has certain incorrect calculations. An attacker can obtain more yCREDIT tokens than they should.",
+        "final_score": 8.5
+    },
+    {
+        "function_name": "_addLiquidity",
+        "vulnerability": "Unrestricted Market Creation",
+        "criticism": "The function auto-adds any new Sushiswap pair to the _markets list, enabling attackers to create pairs with malicious tokens (e.g., fake collateral). Combined with oracle manipulation, this allows minting yCREDIT against worthless assets. The severity is high (8) as it undermines collateral integrity. Profitability is high (8) if exploited with oracle flaws. However, the vulnerability\u2019s impact depends on other factors (e.g., oracle trustworthiness), which slightly reduces its standalone severity. The system\u2019s lack of allowlist/denylist for collateral tokens is a critical oversight.",
+        "correctness": 8,
+        "severity": 8,
+        "profitability": 8,
+        "reason": "The _addLiquidity function automatically adds any token to the _markets list when a new Sushiswap pair is created. Attackers can exploit this by creating pairs with malicious tokens (e.g., tokens with manipulated supply or fake collateral). Combined with oracle manipulation, this allows attackers to deposit worthless tokens as collateral, mint yCREDIT, and drain the protocol. The system should restrict which tokens can be used as collateral instead of auto-adding all pairs.",
+        "code": "function _addLiquidity( address tokenA, address tokenB, uint amountADesired, uint amountBDesired ) internal virtual returns (address pair, uint amountA, uint amountB) {\n    pair = FACTORY.getPair(tokenA, tokenB);\n    if (pair == address(0)) {\n        pair = FACTORY.createPair(tokenA, tokenB);\n        pairs[pair] = true;\n        _markets.push(tokenA);\n    } else if (!pairs[pair]) {\n        pairs[pair] = true;\n        _markets.push(tokenA);\n    }\n    (uint reserveA, uint reserveB) = SushiswapV2Library.getReserves(address(FACTORY), tokenA, tokenB);\n    if (reserveA == 0 && reserveB == 0) {\n        (amountA, amountB) = (amountADesired, amountBDesired);\n    } else {\n        uint amountBOptimal = SushiswapV2Library.quote(amountADesired, reserveA, reserveB);\n        if (amountBOptimal <= amountBDesired) {\n            (amountA, amountB) = (amountADesired, amountBOptimal);\n        } else {\n            uint amountAOptimal = SushiswapV2Library.quote(amountBDesired, reserveB, reserveA);\n            assert(amountAOptimal <= amountADesired);\n            (amountA, amountB) = (amountAOptimal, amountBDesired);\n        }\n    }\n}",
+        "label": "Wrong Logic",
+        "file_name": "2021-3004.sol",
+        "description": "The _deposit function in the smart contract implementation for Stable Yield Credit (yCREDIT), an Ethereum token, has certain incorrect calculations. An attacker can obtain more yCREDIT tokens than they should.",
+        "final_score": 8.0
+    },
+    {
+        "function_name": "_transferTokens",
+        "vulnerability": "Fee Handling Flaws",
+        "criticism": "The reasoning contains inaccuracies. First, the fee is calculated as a percentage of the transferred amount, so underflow is impossible unless FEE exceeds 100% (unlikely). Second, the rewardRate manipulation via notifyFeeAmount is speculative since the function\u2019s implementation is not shown. While small fees could distort rewards, the severity is low (2) without evidence of exploitable logic. Profitability is negligible (1) as no direct theft vector is demonstrated. The primary issue is design ambiguity, not a clear vulnerability.",
+        "correctness": 3,
+        "severity": 2,
+        "profitability": 1,
+        "reason": "The fee mechanism applies a transfer tax when tokens are sent from a pair (e.g., during a buy). However, the fee is deducted from the recipient's (buyer's) balance after the initial transfer, which could lead to underflow if the fee rounds to zero or exceeds the received amount. Additionally, notifyFeeAmount recalculates rewardRate without proper validation, allowing attackers to manipulate reward distribution by making small transfers to trigger fee updates, potentially disrupting reward calculations or causing integer overflows/underflows.",
+        "code": "function _transferTokens(address src, address dst, uint amount) internal {\n    balances[src] -= amount;\n    balances[dst] += amount;\n    emit Transfer(src, dst, amount);\n    if (pairs[src]) {\n        uint _fee = amount * FEE / BASE;\n        _transferTokens(dst, address(this), _fee);\n        notifyFeeAmount(_fee);\n    }\n}",
+        "label": "Wrong Logic",
+        "file_name": "2021-3004.sol",
+        "description": "The _deposit function in the smart contract implementation for Stable Yield Credit (yCREDIT), an Ethereum token, has certain incorrect calculations. An attacker can obtain more yCREDIT tokens than they should.",
+        "final_score": 2.25
+    }
+]
\ No newline at end of file
diff --git a/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/2018-10706.json b/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/2018-10706.json
index a4da62b2..6a6ce56b 100644
--- a/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/2018-10706.json
+++ b/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/2018-10706.json
@@ -1,23 +1,23 @@
-[
-    {
-        "function_name": "approveAndCall",
-        "code": "function approveAndCall(address _spender, uint256 _amount, bytes _extraData) public returns (bool success) { require(approve(_spender, _amount)); ApproveAndCallReceiver(_spender).receiveApproval( msg.sender, _amount, this, _extraData ); return true; }",
-        "vulnerability": "Reentrancy",
-        "reason": "This function approves tokens for a spender and then calls an external contract (ApproveAndCallReceiver). If the external contract is malicious, it can call back into this contract and exploit its state before the initial operation is complete, potentially leading to unexpected behavior or loss of funds.",
-        "file_name": "2018-10706.sol"
-    },
-    {
-        "function_name": "transferFrom",
-        "code": "function transferFrom(address _from, address _to, uint256 _value) realUser(_from) realUser(_to) moreThanZero(_value) public returns (bool success) { require(balanceOf[_from] >= _value); require(balanceOf[_to] + _value > balanceOf[_to]); require(_value <= allowance[_from][msg.sender]); balanceOf[_from] = balanceOf[_from] - _value; balanceOf[_to] = balanceOf[_to] + _value; allowance[_from][msg.sender] = allowance[_from][msg.sender] + _value; emit Transfer(_from, _to, _value); return true; }",
-        "vulnerability": "Integer Overflow",
-        "reason": "The line 'allowance[_from][msg.sender] = allowance[_from][msg.sender] + _value;' can potentially overflow if '_value' is chosen such that the sum exceeds the maximum representable uint256 value. This could allow an attacker to wrap the allowance around and exploit the contract by transferring more tokens than intended.",
-        "file_name": "2018-10706.sol"
-    },
-    {
-        "function_name": "generateTokens",
-        "code": "function generateTokens(address _user, uint _amount) onlyController public returns (bool) { _amount=_amount*10**uint256(decimals); return _generateTokens(_user,_amount); }",
-        "vulnerability": "Unchecked Math",
-        "reason": "The function multiplies '_amount' by '10**uint256(decimals)' without checking for overflow. In Solidity versions before 0.8.0, arithmetic operations do not automatically check for overflows. If '_amount' is large enough, this multiplication could overflow, allowing an attacker to mint an arbitrary number of tokens.",
-        "file_name": "2018-10706.sol"
-    }
+[
+    {
+        "function_name": "approveAndCall",
+        "code": "function approveAndCall(address _spender, uint256 _amount, bytes _extraData) public returns (bool success) { require(approve(_spender, _amount)); ApproveAndCallReceiver(_spender).receiveApproval( msg.sender, _amount, this, _extraData ); return true; }",
+        "vulnerability": "Reentrancy",
+        "reason": "This function approves tokens for a spender and then calls an external contract (ApproveAndCallReceiver). If the external contract is malicious, it can call back into this contract and exploit its state before the initial operation is complete, potentially leading to unexpected behavior or loss of funds.",
+        "file_name": "2018-10706.sol"
+    },
+    {
+        "function_name": "transferFrom",
+        "code": "function transferFrom(address _from, address _to, uint256 _value) realUser(_from) realUser(_to) moreThanZero(_value) public returns (bool success) { require(balanceOf[_from] >= _value); require(balanceOf[_to] + _value > balanceOf[_to]); require(_value <= allowance[_from][msg.sender]); balanceOf[_from] = balanceOf[_from] - _value; balanceOf[_to] = balanceOf[_to] + _value; allowance[_from][msg.sender] = allowance[_from][msg.sender] + _value; emit Transfer(_from, _to, _value); return true; }",
+        "vulnerability": "Integer Overflow",
+        "reason": "The line 'allowance[_from][msg.sender] = allowance[_from][msg.sender] + _value;' can potentially overflow if '_value' is chosen such that the sum exceeds the maximum representable uint256 value. This could allow an attacker to wrap the allowance around and exploit the contract by transferring more tokens than intended.",
+        "file_name": "2018-10706.sol"
+    },
+    {
+        "function_name": "generateTokens",
+        "code": "function generateTokens(address _user, uint _amount) onlyController public returns (bool) { _amount=_amount*10**uint256(decimals); return _generateTokens(_user,_amount); }",
+        "vulnerability": "Unchecked Math",
+        "reason": "The function multiplies '_amount' by '10**uint256(decimals)' without checking for overflow. In Solidity versions before 0.8.0, arithmetic operations do not automatically check for overflows. If '_amount' is large enough, this multiplication could overflow, allowing an attacker to mint an arbitrary number of tokens.",
+        "file_name": "2018-10706.sol"
+    }
 ]
\ No newline at end of file
diff --git a/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/2018-10944.json b/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/2018-10944.json
index dd92d378..ce540530 100644
--- a/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/2018-10944.json
+++ b/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/2018-10944.json
@@ -1,23 +1,23 @@
-[
-    {
-        "function_name": "transferFrom",
-        "code": "function transferFrom( address _from, address _to, uint256 _amount ) returns (bool success) { if (balances[_from] >= _amount && allowed[_from][msg.sender] >= _amount && _amount > 0 && balances[_to] + _amount > balances[_to]) { balances[_from] -= _amount; allowed[_from][msg.sender] -= _amount; balances[_to] += _amount; Transfer(_from, _to, _amount); return true; } else { return false; } }",
-        "vulnerability": "Reentrancy",
-        "reason": "The 'transferFrom' function transfers tokens on behalf of another address after allowance is given, but does not implement reentrancy guards. This could allow an attacker to perform a reentrancy attack if the recipient contract is malicious and has a fallback function designed to call back into this contract.",
-        "file_name": "2018-10944.sol"
-    },
-    {
-        "function_name": "request_dividend",
-        "code": "function request_dividend(address token_holder) payable { holder_token_balance = balanceOf(token_holder)/10000000000; Message(holder_token_balance); holder_profit = holder_token_balance * profit_per_token; Message(holder_profit); Transfer(owner, token_holder , (holder_profit/10**18)); token_holder.send(holder_profit); }",
-        "vulnerability": "Reentrancy",
-        "reason": "In the 'request_dividend' function, ether is sent using 'send' without a reentrancy guard. This could allow an attacker to re-enter the contract if the caller is a contract with a fallback function.",
-        "file_name": "2018-10944.sol"
-    },
-    {
-        "function_name": "drain",
-        "code": "function drain() onlyOwner { if (!owner.send(this.balance)) throw; }",
-        "vulnerability": "Unchecked CALL return value",
-        "reason": "The 'drain' function uses '.send()' to transfer ether and checks the return value with a 'throw', which is deprecated and should be replaced with 'require()' for better error handling. It's also susceptible to gas limitations of '.send()', potentially leading to failed transactions without proper notification or handling.",
-        "file_name": "2018-10944.sol"
-    }
+[
+    {
+        "function_name": "transferFrom",
+        "code": "function transferFrom( address _from, address _to, uint256 _amount ) returns (bool success) { if (balances[_from] >= _amount && allowed[_from][msg.sender] >= _amount && _amount > 0 && balances[_to] + _amount > balances[_to]) { balances[_from] -= _amount; allowed[_from][msg.sender] -= _amount; balances[_to] += _amount; Transfer(_from, _to, _amount); return true; } else { return false; } }",
+        "vulnerability": "Reentrancy",
+        "reason": "The 'transferFrom' function transfers tokens on behalf of another address after allowance is given, but does not implement reentrancy guards. This could allow an attacker to perform a reentrancy attack if the recipient contract is malicious and has a fallback function designed to call back into this contract.",
+        "file_name": "2018-10944.sol"
+    },
+    {
+        "function_name": "request_dividend",
+        "code": "function request_dividend(address token_holder) payable { holder_token_balance = balanceOf(token_holder)/10000000000; Message(holder_token_balance); holder_profit = holder_token_balance * profit_per_token; Message(holder_profit); Transfer(owner, token_holder , (holder_profit/10**18)); token_holder.send(holder_profit); }",
+        "vulnerability": "Reentrancy",
+        "reason": "In the 'request_dividend' function, ether is sent using 'send' without a reentrancy guard. This could allow an attacker to re-enter the contract if the caller is a contract with a fallback function.",
+        "file_name": "2018-10944.sol"
+    },
+    {
+        "function_name": "drain",
+        "code": "function drain() onlyOwner { if (!owner.send(this.balance)) throw; }",
+        "vulnerability": "Unchecked CALL return value",
+        "reason": "The 'drain' function uses '.send()' to transfer ether and checks the return value with a 'throw', which is deprecated and should be replaced with 'require()' for better error handling. It's also susceptible to gas limitations of '.send()', potentially leading to failed transactions without proper notification or handling.",
+        "file_name": "2018-10944.sol"
+    }
 ]
\ No newline at end of file
diff --git a/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/2018-11239.json b/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/2018-11239.json
index 0b586e20..60d389aa 100644
--- a/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/2018-11239.json
+++ b/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/2018-11239.json
@@ -1,23 +1,23 @@
-[
-    {
-        "function_name": "approve",
-        "code": "function approve(address _spender, uint256 _value) public returns (bool success) { require(_value == 0 || allowance[msg.sender][_spender] == 0); allowance[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; }",
-        "vulnerability": "ERC20 Approve/Allowance Race Condition",
-        "reason": "This vulnerability occurs because the function does not handle the case where changing an allowance from a non-zero value to another non-zero value could be exploited by an attacker who is able to call transferFrom multiple times. The require condition only checks for changes from zero to non-zero or vice versa, which means an attacker can exploit the race condition by requesting a change in allowance while executing transferFrom, potentially draining the owner's funds.",
-        "file_name": "2018-11239.sol"
-    },
-    {
-        "function_name": "_transfer",
-        "code": "function _transfer(address _from, address _to, uint _value) internal { require (_to != 0x0); require (balanceOf[_from] >= _value + burnPerTransaction); require (balanceOf[_to] + _value > balanceOf[_to]); balanceOf[_from] -= _value + burnPerTransaction; balanceOf[_to] += _value; balanceOf[0x0] += burnPerTransaction; currentSupply -= burnPerTransaction; Burn(_from, burnPerTransaction); Transfer(_from, _to, _value); }",
-        "vulnerability": "Integer Overflow and Underflow",
-        "reason": "The function does not adequately check for integer overflows or underflows when calculating balances after a transfer and burn operation. Solidity versions prior to 0.8.0 do not automatically check for arithmetic overflows/underflows. An attacker might exploit this by sending a value that, when added to the recipient's balance, overflows the balance, potentially allowing for theft of tokens.",
-        "file_name": "2018-11239.sol"
-    },
-    {
-        "function_name": "burn",
-        "code": "function burn(uint256 _value) public returns (bool success) { require(balanceOf[msg.sender] >= _value); balanceOf[msg.sender] -= _value; balanceOf[0x0] += _value; currentSupply -= _value; Burn(msg.sender, _value); return true; }",
-        "vulnerability": "Burning Tokens to 0x0 Address",
-        "reason": "Directly burning tokens by sending them to the 0x0 address can lead to a permanent loss of those tokens, decreasing the total supply potentially in an undesirable manner. While this is somewhat intentional as described by the function, it can be problematic if there's a mistake in the amount to be burned. It also does not follow the best practice of burning tokens, which is to reduce the total supply without transferring to the 0x0 address.",
-        "file_name": "2018-11239.sol"
-    }
+[
+    {
+        "function_name": "approve",
+        "code": "function approve(address _spender, uint256 _value) public returns (bool success) { require(_value == 0 || allowance[msg.sender][_spender] == 0); allowance[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; }",
+        "vulnerability": "ERC20 Approve/Allowance Race Condition",
+        "reason": "This vulnerability occurs because the function does not handle the case where changing an allowance from a non-zero value to another non-zero value could be exploited by an attacker who is able to call transferFrom multiple times. The require condition only checks for changes from zero to non-zero or vice versa, which means an attacker can exploit the race condition by requesting a change in allowance while executing transferFrom, potentially draining the owner's funds.",
+        "file_name": "2018-11239.sol"
+    },
+    {
+        "function_name": "_transfer",
+        "code": "function _transfer(address _from, address _to, uint _value) internal { require (_to != 0x0); require (balanceOf[_from] >= _value + burnPerTransaction); require (balanceOf[_to] + _value > balanceOf[_to]); balanceOf[_from] -= _value + burnPerTransaction; balanceOf[_to] += _value; balanceOf[0x0] += burnPerTransaction; currentSupply -= burnPerTransaction; Burn(_from, burnPerTransaction); Transfer(_from, _to, _value); }",
+        "vulnerability": "Integer Overflow and Underflow",
+        "reason": "The function does not adequately check for integer overflows or underflows when calculating balances after a transfer and burn operation. Solidity versions prior to 0.8.0 do not automatically check for arithmetic overflows/underflows. An attacker might exploit this by sending a value that, when added to the recipient's balance, overflows the balance, potentially allowing for theft of tokens.",
+        "file_name": "2018-11239.sol"
+    },
+    {
+        "function_name": "burn",
+        "code": "function burn(uint256 _value) public returns (bool success) { require(balanceOf[msg.sender] >= _value); balanceOf[msg.sender] -= _value; balanceOf[0x0] += _value; currentSupply -= _value; Burn(msg.sender, _value); return true; }",
+        "vulnerability": "Burning Tokens to 0x0 Address",
+        "reason": "Directly burning tokens by sending them to the 0x0 address can lead to a permanent loss of those tokens, decreasing the total supply potentially in an undesirable manner. While this is somewhat intentional as described by the function, it can be problematic if there's a mistake in the amount to be burned. It also does not follow the best practice of burning tokens, which is to reduce the total supply without transferring to the 0x0 address.",
+        "file_name": "2018-11239.sol"
+    }
 ]
\ No newline at end of file
diff --git a/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/2018-10706.json b/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/2018-10706.json
index a78b9026..12b6cacd 100644
--- a/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/2018-10706.json
+++ b/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/2018-10706.json
@@ -1,35 +1,35 @@
-[
-    {
-        "function_name": "approveAndCall",
-        "vulnerability": "Reentrancy",
-        "criticism": "The reasoning identifies a legitimate concern with calling external contracts, which could potentially exploit reentrancy vulnerabilities. However, the severity and profitability of this vulnerability depend on the implementation of the external contract and the state of this contract. If proper reentrancy guards are in place or if the state changes are managed correctly, the risk could be mitigated. The criticism lacks a detailed analysis of how the external contract's behavior could specifically exploit the state of this contract, making the assessment somewhat superficial.",
-        "correctness": 6,
-        "severity": 5,
-        "profitability": 4,
-        "reason": "This function approves tokens for a spender and then calls an external contract (ApproveAndCallReceiver). If the external contract is malicious, it can call back into this contract and exploit its state before the initial operation is complete, potentially leading to unexpected behavior or loss of funds.",
-        "code": "function approveAndCall(address _spender, uint256 _amount, bytes _extraData) public returns (bool success) { require(approve(_spender, _amount)); ApproveAndCallReceiver(_spender).receiveApproval( msg.sender, _amount, this, _extraData ); return true; }",
-        "file_name": "2018-10706.sol"
-    },
-    {
-        "function_name": "transferFrom",
-        "vulnerability": "Integer Overflow",
-        "criticism": "The criticism correctly identifies a potential integer overflow vulnerability in the allowance update line. However, it fails to consider the context of the Solidity version and the presence of SafeMath library or similar overflow protections. Modern Solidity versions (0.8.0 and above) and the use of SafeMath in older versions inherently protect against such overflows. Therefore, without specifying the Solidity version or the absence of overflow protection, the assessment might overstate the risk. Additionally, the practical exploitation of this vulnerability requires specific conditions that are not detailed, affecting the accuracy of the severity and profitability ratings.",
-        "correctness": 5,
-        "severity": 3,
-        "profitability": 2,
-        "reason": "The line 'allowance[_from][msg.sender] = allowance[_from][msg.sender] + _value;' can potentially overflow if '_value' is chosen such that the sum exceeds the maximum representable uint256 value. This could allow an attacker to wrap the allowance around and exploit the contract by transferring more tokens than intended.",
-        "code": "function transferFrom(address _from, address _to, uint256 _value) realUser(_from) realUser(_to) moreThanZero(_value) public returns (bool success) { require(balanceOf[_from] >= _value); require(balanceOf[_to] + _value > balanceOf[_to]); require(_value <= allowance[_from][msg.sender]); balanceOf[_from] = balanceOf[_from] - _value; balanceOf[_to] = balanceOf[_to] + _value; allowance[_from][msg.sender] = allowance[_from][msg.sender] + _value; emit Transfer(_from, _to, _value); return true; }",
-        "file_name": "2018-10706.sol"
-    },
-    {
-        "function_name": "generateTokens",
-        "vulnerability": "Unchecked Math",
-        "criticism": "The reasoning correctly points out the risk of unchecked arithmetic operations leading to overflow vulnerabilities, particularly in Solidity versions before 0.8.0. However, the criticism lacks depth in evaluating the context, such as the contract's Solidity version or the use of libraries like SafeMath to mitigate such risks. Moreover, the practical implications of exploiting this vulnerability, such as the ability to mint an arbitrary number of tokens, depend on additional factors like the contract's overall logic and security measures. The assessment could benefit from a more nuanced analysis of these aspects to accurately determine the severity and profitability.",
-        "correctness": 6,
-        "severity": 6,
-        "profitability": 5,
-        "reason": "The function multiplies '_amount' by '10**uint256(decimals)' without checking for overflow. In Solidity versions before 0.8.0, arithmetic operations do not automatically check for overflows. If '_amount' is large enough, this multiplication could overflow, allowing an attacker to mint an arbitrary number of tokens.",
-        "code": "function generateTokens(address _user, uint _amount) onlyController public returns (bool) { _amount=_amount*10**uint256(decimals); return _generateTokens(_user,_amount); }",
-        "file_name": "2018-10706.sol"
-    }
+[
+    {
+        "function_name": "approveAndCall",
+        "vulnerability": "Reentrancy",
+        "criticism": "The reasoning identifies a legitimate concern with calling external contracts, which could potentially exploit reentrancy vulnerabilities. However, the severity and profitability of this vulnerability depend on the implementation of the external contract and the state of this contract. If proper reentrancy guards are in place or if the state changes are managed correctly, the risk could be mitigated. The criticism lacks a detailed analysis of how the external contract's behavior could specifically exploit the state of this contract, making the assessment somewhat superficial.",
+        "correctness": 6,
+        "severity": 5,
+        "profitability": 4,
+        "reason": "This function approves tokens for a spender and then calls an external contract (ApproveAndCallReceiver). If the external contract is malicious, it can call back into this contract and exploit its state before the initial operation is complete, potentially leading to unexpected behavior or loss of funds.",
+        "code": "function approveAndCall(address _spender, uint256 _amount, bytes _extraData) public returns (bool success) { require(approve(_spender, _amount)); ApproveAndCallReceiver(_spender).receiveApproval( msg.sender, _amount, this, _extraData ); return true; }",
+        "file_name": "2018-10706.sol"
+    },
+    {
+        "function_name": "transferFrom",
+        "vulnerability": "Integer Overflow",
+        "criticism": "The criticism correctly identifies a potential integer overflow vulnerability in the allowance update line. However, it fails to consider the context of the Solidity version and the presence of SafeMath library or similar overflow protections. Modern Solidity versions (0.8.0 and above) and the use of SafeMath in older versions inherently protect against such overflows. Therefore, without specifying the Solidity version or the absence of overflow protection, the assessment might overstate the risk. Additionally, the practical exploitation of this vulnerability requires specific conditions that are not detailed, affecting the accuracy of the severity and profitability ratings.",
+        "correctness": 5,
+        "severity": 3,
+        "profitability": 2,
+        "reason": "The line 'allowance[_from][msg.sender] = allowance[_from][msg.sender] + _value;' can potentially overflow if '_value' is chosen such that the sum exceeds the maximum representable uint256 value. This could allow an attacker to wrap the allowance around and exploit the contract by transferring more tokens than intended.",
+        "code": "function transferFrom(address _from, address _to, uint256 _value) realUser(_from) realUser(_to) moreThanZero(_value) public returns (bool success) { require(balanceOf[_from] >= _value); require(balanceOf[_to] + _value > balanceOf[_to]); require(_value <= allowance[_from][msg.sender]); balanceOf[_from] = balanceOf[_from] - _value; balanceOf[_to] = balanceOf[_to] + _value; allowance[_from][msg.sender] = allowance[_from][msg.sender] + _value; emit Transfer(_from, _to, _value); return true; }",
+        "file_name": "2018-10706.sol"
+    },
+    {
+        "function_name": "generateTokens",
+        "vulnerability": "Unchecked Math",
+        "criticism": "The reasoning correctly points out the risk of unchecked arithmetic operations leading to overflow vulnerabilities, particularly in Solidity versions before 0.8.0. However, the criticism lacks depth in evaluating the context, such as the contract's Solidity version or the use of libraries like SafeMath to mitigate such risks. Moreover, the practical implications of exploiting this vulnerability, such as the ability to mint an arbitrary number of tokens, depend on additional factors like the contract's overall logic and security measures. The assessment could benefit from a more nuanced analysis of these aspects to accurately determine the severity and profitability.",
+        "correctness": 6,
+        "severity": 6,
+        "profitability": 5,
+        "reason": "The function multiplies '_amount' by '10**uint256(decimals)' without checking for overflow. In Solidity versions before 0.8.0, arithmetic operations do not automatically check for overflows. If '_amount' is large enough, this multiplication could overflow, allowing an attacker to mint an arbitrary number of tokens.",
+        "code": "function generateTokens(address _user, uint _amount) onlyController public returns (bool) { _amount=_amount*10**uint256(decimals); return _generateTokens(_user,_amount); }",
+        "file_name": "2018-10706.sol"
+    }
 ]
\ No newline at end of file
diff --git a/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/2018-10944.json b/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/2018-10944.json
index c7606ae3..a2d34115 100644
--- a/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/2018-10944.json
+++ b/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/2018-10944.json
@@ -1,35 +1,35 @@
-[
-    {
-        "function_name": "transferFrom",
-        "vulnerability": "Reentrancy",
-        "criticism": "The criticism of the 'transferFrom' function for reentrancy vulnerability is misplaced. Reentrancy is a concern when a contract makes an external call to an untrusted contract before it resolves its internal state. However, 'transferFrom' primarily deals with token transfers and updates balances and allowances before making any external calls. There are no external calls within 'transferFrom' that would allow for reentrancy in the provided code snippet. Therefore, the identification of reentrancy as a vulnerability in this context is incorrect, leading to a low correctness score. The severity and profitability are also rated low because the described vulnerability does not exist in this scenario.",
-        "correctness": 1,
-        "severity": 0,
-        "profitability": 0,
-        "reason": "The 'transferFrom' function transfers tokens on behalf of another address after allowance is given, but does not implement reentrancy guards. This could allow an attacker to perform a reentrancy attack if the recipient contract is malicious and has a fallback function designed to call back into this contract.",
-        "code": "function transferFrom( address _from, address _to, uint256 _amount ) returns (bool success) { if (balances[_from] >= _amount && allowed[_from][msg.sender] >= _amount && _amount > 0 && balances[_to] + _amount > balances[_to]) { balances[_from] -= _amount; allowed[_from][msg.sender] -= _amount; balances[_to] += _amount; Transfer(_from, _to, _amount); return true; } else { return false; } }",
-        "file_name": "2018-10944.sol"
-    },
-    {
-        "function_name": "request_dividend",
-        "vulnerability": "Reentrancy",
-        "criticism": "The identification of reentrancy vulnerability in the 'request_dividend' function is accurate due to the use of 'send' without a reentrancy guard. However, the severity and profitability might not be as high as implied. While 'send' is indeed susceptible to reentrancy attacks, it only forwards 2300 gas, limiting the actions an attacker can perform in a fallback function. Nonetheless, the risk of reentrancy should not be underestimated, especially in functions involving financial transactions. The criticism could have been more nuanced by acknowledging the gas limit but still emphasizing the importance of reentrancy guards. The correctness is rated moderately high due to accurate identification, but severity and profitability are adjusted to reflect the nuanced risk.",
-        "correctness": 7,
-        "severity": 5,
-        "profitability": 4,
-        "reason": "In the 'request_dividend' function, ether is sent using 'send' without a reentrancy guard. This could allow an attacker to re-enter the contract if the caller is a contract with a fallback function.",
-        "code": "function request_dividend(address token_holder) payable { holder_token_balance = balanceOf(token_holder)/10000000000; Message(holder_token_balance); holder_profit = holder_token_balance * profit_per_token; Message(holder_profit); Transfer(owner, token_holder , (holder_profit/10**18)); token_holder.send(holder_profit); }",
-        "file_name": "2018-10944.sol"
-    },
-    {
-        "function_name": "drain",
-        "vulnerability": "Unchecked CALL return value",
-        "criticism": "The criticism correctly identifies the use of '.send()' and the deprecated 'throw' for error handling in the 'drain' function as problematic. However, it conflates two separate issues: the deprecated error handling and the potential for gas-related failures with '.send()'. The severity of using 'throw' is relatively high due to the potential for unexpected contract behavior and the inefficiency of gas usage. The profitability of exploiting this vulnerability is low, as it primarily affects the contract owner's ability to withdraw funds. A more accurate critique would separate these concerns, emphasizing the need for updated error handling practices and the limitations of '.send()' for transferring ether. Correctness is rated moderately for identifying relevant issues, but the explanation lacks clarity in distinguishing between them.",
-        "correctness": 6,
-        "severity": 4,
-        "profitability": 1,
-        "reason": "The 'drain' function uses '.send()' to transfer ether and checks the return value with a 'throw', which is deprecated and should be replaced with 'require()' for better error handling. It's also susceptible to gas limitations of '.send()', potentially leading to failed transactions without proper notification or handling.",
-        "code": "function drain() onlyOwner { if (!owner.send(this.balance)) throw; }",
-        "file_name": "2018-10944.sol"
-    }
+[
+    {
+        "function_name": "transferFrom",
+        "vulnerability": "Reentrancy",
+        "criticism": "The criticism of the 'transferFrom' function for reentrancy vulnerability is misplaced. Reentrancy is a concern when a contract makes an external call to an untrusted contract before it resolves its internal state. However, 'transferFrom' primarily deals with token transfers and updates balances and allowances before making any external calls. There are no external calls within 'transferFrom' that would allow for reentrancy in the provided code snippet. Therefore, the identification of reentrancy as a vulnerability in this context is incorrect, leading to a low correctness score. The severity and profitability are also rated low because the described vulnerability does not exist in this scenario.",
+        "correctness": 1,
+        "severity": 0,
+        "profitability": 0,
+        "reason": "The 'transferFrom' function transfers tokens on behalf of another address after allowance is given, but does not implement reentrancy guards. This could allow an attacker to perform a reentrancy attack if the recipient contract is malicious and has a fallback function designed to call back into this contract.",
+        "code": "function transferFrom( address _from, address _to, uint256 _amount ) returns (bool success) { if (balances[_from] >= _amount && allowed[_from][msg.sender] >= _amount && _amount > 0 && balances[_to] + _amount > balances[_to]) { balances[_from] -= _amount; allowed[_from][msg.sender] -= _amount; balances[_to] += _amount; Transfer(_from, _to, _amount); return true; } else { return false; } }",
+        "file_name": "2018-10944.sol"
+    },
+    {
+        "function_name": "request_dividend",
+        "vulnerability": "Reentrancy",
+        "criticism": "The identification of reentrancy vulnerability in the 'request_dividend' function is accurate due to the use of 'send' without a reentrancy guard. However, the severity and profitability might not be as high as implied. While 'send' is indeed susceptible to reentrancy attacks, it only forwards 2300 gas, limiting the actions an attacker can perform in a fallback function. Nonetheless, the risk of reentrancy should not be underestimated, especially in functions involving financial transactions. The criticism could have been more nuanced by acknowledging the gas limit but still emphasizing the importance of reentrancy guards. The correctness is rated moderately high due to accurate identification, but severity and profitability are adjusted to reflect the nuanced risk.",
+        "correctness": 7,
+        "severity": 5,
+        "profitability": 4,
+        "reason": "In the 'request_dividend' function, ether is sent using 'send' without a reentrancy guard. This could allow an attacker to re-enter the contract if the caller is a contract with a fallback function.",
+        "code": "function request_dividend(address token_holder) payable { holder_token_balance = balanceOf(token_holder)/10000000000; Message(holder_token_balance); holder_profit = holder_token_balance * profit_per_token; Message(holder_profit); Transfer(owner, token_holder , (holder_profit/10**18)); token_holder.send(holder_profit); }",
+        "file_name": "2018-10944.sol"
+    },
+    {
+        "function_name": "drain",
+        "vulnerability": "Unchecked CALL return value",
+        "criticism": "The criticism correctly identifies the use of '.send()' and the deprecated 'throw' for error handling in the 'drain' function as problematic. However, it conflates two separate issues: the deprecated error handling and the potential for gas-related failures with '.send()'. The severity of using 'throw' is relatively high due to the potential for unexpected contract behavior and the inefficiency of gas usage. The profitability of exploiting this vulnerability is low, as it primarily affects the contract owner's ability to withdraw funds. A more accurate critique would separate these concerns, emphasizing the need for updated error handling practices and the limitations of '.send()' for transferring ether. Correctness is rated moderately for identifying relevant issues, but the explanation lacks clarity in distinguishing between them.",
+        "correctness": 6,
+        "severity": 4,
+        "profitability": 1,
+        "reason": "The 'drain' function uses '.send()' to transfer ether and checks the return value with a 'throw', which is deprecated and should be replaced with 'require()' for better error handling. It's also susceptible to gas limitations of '.send()', potentially leading to failed transactions without proper notification or handling.",
+        "code": "function drain() onlyOwner { if (!owner.send(this.balance)) throw; }",
+        "file_name": "2018-10944.sol"
+    }
 ]
\ No newline at end of file
diff --git a/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/2018-11239.json b/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/2018-11239.json
index 9c6f9c41..a7c5980c 100644
--- a/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/2018-11239.json
+++ b/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/2018-11239.json
@@ -1,35 +1,35 @@
-[
-    {
-        "function_name": "approve",
-        "vulnerability": "ERC20 Approve/Allowance Race Condition",
-        "criticism": "The criticism of the approve function's vulnerability to a race condition is somewhat overstated. The function's requirement that either the current allowance is zero or the new value is zero mitigates the risk of an attacker exploiting the race condition to a significant extent. However, the scenario described does indeed represent a potential vulnerability in cases where allowances are being changed from one non-zero value to another without first setting them to zero. This could lead to unexpected behavior if not properly managed by the user or the interface interacting with the contract. The correctness of identifying a vulnerability is there, but the severity is overestimated due to the mitigating conditions in the code. Profitability for an attacker is also limited, as it requires specific conditions and timing to exploit successfully.",
-        "correctness": 6,
-        "severity": 3,
-        "profitability": 2,
-        "reason": "This vulnerability occurs because the function does not handle the case where changing an allowance from a non-zero value to another non-zero value could be exploited by an attacker who is able to call transferFrom multiple times. The require condition only checks for changes from zero to non-zero or vice versa, which means an attacker can exploit the race condition by requesting a change in allowance while executing transferFrom, potentially draining the owner's funds.",
-        "code": "function approve(address _spender, uint256 _value) public returns (bool success) { require(_value == 0 || allowance[msg.sender][_spender] == 0); allowance[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; }",
-        "file_name": "2018-11239.sol"
-    },
-    {
-        "function_name": "_transfer",
-        "vulnerability": "Integer Overflow and Underflow",
-        "criticism": "The criticism regarding the potential for integer overflow and underflow in the _transfer function is valid, especially for Solidity versions prior to 0.8.0 which do not automatically handle these issues. The function's arithmetic operations without explicit checks for overflows or underflows could indeed lead to vulnerabilities where token balances are manipulated in unintended ways. This could potentially allow an attacker to exploit the contract by creating conditions under which these arithmetic errors occur, leading to the theft of tokens or other unintended outcomes. The severity of this vulnerability is high due to the potential impact on token balances and the integrity of the contract. Profitability for an attacker is also high, as exploiting these vulnerabilities could lead to significant gains at the expense of other users.",
-        "correctness": 8,
-        "severity": 7,
-        "profitability": 7,
-        "reason": "The function does not adequately check for integer overflows or underflows when calculating balances after a transfer and burn operation. Solidity versions prior to 0.8.0 do not automatically check for arithmetic overflows/underflows. An attacker might exploit this by sending a value that, when added to the recipient's balance, overflows the balance, potentially allowing for theft of tokens.",
-        "code": "function _transfer(address _from, address _to, uint _value) internal { require (_to != 0x0); require (balanceOf[_from] >= _value + burnPerTransaction); require (balanceOf[_to] + _value > balanceOf[_to]); balanceOf[_from] -= _value + burnPerTransaction; balanceOf[_to] += _value; balanceOf[0x0] += burnPerTransaction; currentSupply -= burnPerTransaction; Burn(_from, burnPerTransaction); Transfer(_from, _to, _value); }",
-        "file_name": "2018-11239.sol"
-    },
-    {
-        "function_name": "burn",
-        "vulnerability": "Burning Tokens to 0x0 Address",
-        "criticism": "The criticism of burning tokens by sending them to the 0x0 address overlooks the intentional design choice behind such a mechanism. While it is true that burning tokens in this manner permanently removes them from circulation, thereby reducing the total supply, this is often a desired outcome in token economics to create scarcity or to fulfill specific tokenomics models. The criticism fails to acknowledge the potential benefits of such a design decision. However, caution should indeed be exercised to avoid burning tokens unintentionally. The practice of burning tokens is not inherently problematic but requires clear documentation and user understanding to prevent mistakes. The severity of this issue is low, as it aligns with the intended functionality, and profitability for an attacker is non-existent, as this action does not inherently provide a means for profit.",
-        "correctness": 5,
-        "severity": 1,
-        "profitability": 0,
-        "reason": "Directly burning tokens by sending them to the 0x0 address can lead to a permanent loss of those tokens, decreasing the total supply potentially in an undesirable manner. While this is somewhat intentional as described by the function, it can be problematic if there's a mistake in the amount to be burned. It also does not follow the best practice of burning tokens, which is to reduce the total supply without transferring to the 0x0 address.",
-        "code": "function burn(uint256 _value) public returns (bool success) { require(balanceOf[msg.sender] >= _value); balanceOf[msg.sender] -= _value; balanceOf[0x0] += _value; currentSupply -= _value; Burn(msg.sender, _value); return true; }",
-        "file_name": "2018-11239.sol"
-    }
+[
+    {
+        "function_name": "approve",
+        "vulnerability": "ERC20 Approve/Allowance Race Condition",
+        "criticism": "The criticism of the approve function's vulnerability to a race condition is somewhat overstated. The function's requirement that either the current allowance is zero or the new value is zero mitigates the risk of an attacker exploiting the race condition to a significant extent. However, the scenario described does indeed represent a potential vulnerability in cases where allowances are being changed from one non-zero value to another without first setting them to zero. This could lead to unexpected behavior if not properly managed by the user or the interface interacting with the contract. The correctness of identifying a vulnerability is there, but the severity is overestimated due to the mitigating conditions in the code. Profitability for an attacker is also limited, as it requires specific conditions and timing to exploit successfully.",
+        "correctness": 6,
+        "severity": 3,
+        "profitability": 2,
+        "reason": "This vulnerability occurs because the function does not handle the case where changing an allowance from a non-zero value to another non-zero value could be exploited by an attacker who is able to call transferFrom multiple times. The require condition only checks for changes from zero to non-zero or vice versa, which means an attacker can exploit the race condition by requesting a change in allowance while executing transferFrom, potentially draining the owner's funds.",
+        "code": "function approve(address _spender, uint256 _value) public returns (bool success) { require(_value == 0 || allowance[msg.sender][_spender] == 0); allowance[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; }",
+        "file_name": "2018-11239.sol"
+    },
+    {
+        "function_name": "_transfer",
+        "vulnerability": "Integer Overflow and Underflow",
+        "criticism": "The criticism regarding the potential for integer overflow and underflow in the _transfer function is valid, especially for Solidity versions prior to 0.8.0 which do not automatically handle these issues. The function's arithmetic operations without explicit checks for overflows or underflows could indeed lead to vulnerabilities where token balances are manipulated in unintended ways. This could potentially allow an attacker to exploit the contract by creating conditions under which these arithmetic errors occur, leading to the theft of tokens or other unintended outcomes. The severity of this vulnerability is high due to the potential impact on token balances and the integrity of the contract. Profitability for an attacker is also high, as exploiting these vulnerabilities could lead to significant gains at the expense of other users.",
+        "correctness": 8,
+        "severity": 7,
+        "profitability": 7,
+        "reason": "The function does not adequately check for integer overflows or underflows when calculating balances after a transfer and burn operation. Solidity versions prior to 0.8.0 do not automatically check for arithmetic overflows/underflows. An attacker might exploit this by sending a value that, when added to the recipient's balance, overflows the balance, potentially allowing for theft of tokens.",
+        "code": "function _transfer(address _from, address _to, uint _value) internal { require (_to != 0x0); require (balanceOf[_from] >= _value + burnPerTransaction); require (balanceOf[_to] + _value > balanceOf[_to]); balanceOf[_from] -= _value + burnPerTransaction; balanceOf[_to] += _value; balanceOf[0x0] += burnPerTransaction; currentSupply -= burnPerTransaction; Burn(_from, burnPerTransaction); Transfer(_from, _to, _value); }",
+        "file_name": "2018-11239.sol"
+    },
+    {
+        "function_name": "burn",
+        "vulnerability": "Burning Tokens to 0x0 Address",
+        "criticism": "The criticism of burning tokens by sending them to the 0x0 address overlooks the intentional design choice behind such a mechanism. While it is true that burning tokens in this manner permanently removes them from circulation, thereby reducing the total supply, this is often a desired outcome in token economics to create scarcity or to fulfill specific tokenomics models. The criticism fails to acknowledge the potential benefits of such a design decision. However, caution should indeed be exercised to avoid burning tokens unintentionally. The practice of burning tokens is not inherently problematic but requires clear documentation and user understanding to prevent mistakes. The severity of this issue is low, as it aligns with the intended functionality, and profitability for an attacker is non-existent, as this action does not inherently provide a means for profit.",
+        "correctness": 5,
+        "severity": 1,
+        "profitability": 0,
+        "reason": "Directly burning tokens by sending them to the 0x0 address can lead to a permanent loss of those tokens, decreasing the total supply potentially in an undesirable manner. While this is somewhat intentional as described by the function, it can be problematic if there's a mistake in the amount to be burned. It also does not follow the best practice of burning tokens, which is to reduce the total supply without transferring to the 0x0 address.",
+        "code": "function burn(uint256 _value) public returns (bool success) { require(balanceOf[msg.sender] >= _value); balanceOf[msg.sender] -= _value; balanceOf[0x0] += _value; currentSupply -= _value; Burn(msg.sender, _value); return true; }",
+        "file_name": "2018-11239.sol"
+    }
 ]
\ No newline at end of file
diff --git a/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/ranker_default/2018-10706.json b/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/ranker_default/2018-10706.json
index 3cd9e77f..15e433ce 100644
--- a/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/ranker_default/2018-10706.json
+++ b/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/ranker_default/2018-10706.json
@@ -1,38 +1,38 @@
-[
-    {
-        "function_name": "generateTokens",
-        "vulnerability": "Unchecked Math",
-        "criticism": "The reasoning correctly points out the risk of unchecked arithmetic operations leading to overflow vulnerabilities, particularly in Solidity versions before 0.8.0. However, the criticism lacks depth in evaluating the context, such as the contract's Solidity version or the use of libraries like SafeMath to mitigate such risks. Moreover, the practical implications of exploiting this vulnerability, such as the ability to mint an arbitrary number of tokens, depend on additional factors like the contract's overall logic and security measures. The assessment could benefit from a more nuanced analysis of these aspects to accurately determine the severity and profitability.",
-        "correctness": 6,
-        "severity": 6,
-        "profitability": 5,
-        "reason": "The function multiplies '_amount' by '10**uint256(decimals)' without checking for overflow. In Solidity versions before 0.8.0, arithmetic operations do not automatically check for overflows. If '_amount' is large enough, this multiplication could overflow, allowing an attacker to mint an arbitrary number of tokens.",
-        "code": "function generateTokens(address _user, uint _amount) onlyController public returns (bool) { _amount=_amount*10**uint256(decimals); return _generateTokens(_user,_amount); }",
-        "file_name": "2018-10706.sol",
-        "final_score": 5.75
-    },
-    {
-        "function_name": "approveAndCall",
-        "vulnerability": "Reentrancy",
-        "criticism": "The reasoning identifies a legitimate concern with calling external contracts, which could potentially exploit reentrancy vulnerabilities. However, the severity and profitability of this vulnerability depend on the implementation of the external contract and the state of this contract. If proper reentrancy guards are in place or if the state changes are managed correctly, the risk could be mitigated. The criticism lacks a detailed analysis of how the external contract's behavior could specifically exploit the state of this contract, making the assessment somewhat superficial.",
-        "correctness": 6,
-        "severity": 5,
-        "profitability": 4,
-        "reason": "This function approves tokens for a spender and then calls an external contract (ApproveAndCallReceiver). If the external contract is malicious, it can call back into this contract and exploit its state before the initial operation is complete, potentially leading to unexpected behavior or loss of funds.",
-        "code": "function approveAndCall(address _spender, uint256 _amount, bytes _extraData) public returns (bool success) { require(approve(_spender, _amount)); ApproveAndCallReceiver(_spender).receiveApproval( msg.sender, _amount, this, _extraData ); return true; }",
-        "file_name": "2018-10706.sol",
-        "final_score": 5.25
-    },
-    {
-        "function_name": "transferFrom",
-        "vulnerability": "Integer Overflow",
-        "criticism": "The criticism correctly identifies a potential integer overflow vulnerability in the allowance update line. However, it fails to consider the context of the Solidity version and the presence of SafeMath library or similar overflow protections. Modern Solidity versions (0.8.0 and above) and the use of SafeMath in older versions inherently protect against such overflows. Therefore, without specifying the Solidity version or the absence of overflow protection, the assessment might overstate the risk. Additionally, the practical exploitation of this vulnerability requires specific conditions that are not detailed, affecting the accuracy of the severity and profitability ratings.",
-        "correctness": 5,
-        "severity": 3,
-        "profitability": 2,
-        "reason": "The line 'allowance[_from][msg.sender] = allowance[_from][msg.sender] + _value;' can potentially overflow if '_value' is chosen such that the sum exceeds the maximum representable uint256 value. This could allow an attacker to wrap the allowance around and exploit the contract by transferring more tokens than intended.",
-        "code": "function transferFrom(address _from, address _to, uint256 _value) realUser(_from) realUser(_to) moreThanZero(_value) public returns (bool success) { require(balanceOf[_from] >= _value); require(balanceOf[_to] + _value > balanceOf[_to]); require(_value <= allowance[_from][msg.sender]); balanceOf[_from] = balanceOf[_from] - _value; balanceOf[_to] = balanceOf[_to] + _value; allowance[_from][msg.sender] = allowance[_from][msg.sender] + _value; emit Transfer(_from, _to, _value); return true; }",
-        "file_name": "2018-10706.sol",
-        "final_score": 3.75
-    }
+[
+    {
+        "function_name": "generateTokens",
+        "vulnerability": "Unchecked Math",
+        "criticism": "The reasoning correctly points out the risk of unchecked arithmetic operations leading to overflow vulnerabilities, particularly in Solidity versions before 0.8.0. However, the criticism lacks depth in evaluating the context, such as the contract's Solidity version or the use of libraries like SafeMath to mitigate such risks. Moreover, the practical implications of exploiting this vulnerability, such as the ability to mint an arbitrary number of tokens, depend on additional factors like the contract's overall logic and security measures. The assessment could benefit from a more nuanced analysis of these aspects to accurately determine the severity and profitability.",
+        "correctness": 6,
+        "severity": 6,
+        "profitability": 5,
+        "reason": "The function multiplies '_amount' by '10**uint256(decimals)' without checking for overflow. In Solidity versions before 0.8.0, arithmetic operations do not automatically check for overflows. If '_amount' is large enough, this multiplication could overflow, allowing an attacker to mint an arbitrary number of tokens.",
+        "code": "function generateTokens(address _user, uint _amount) onlyController public returns (bool) { _amount=_amount*10**uint256(decimals); return _generateTokens(_user,_amount); }",
+        "file_name": "2018-10706.sol",
+        "final_score": 5.75
+    },
+    {
+        "function_name": "approveAndCall",
+        "vulnerability": "Reentrancy",
+        "criticism": "The reasoning identifies a legitimate concern with calling external contracts, which could potentially exploit reentrancy vulnerabilities. However, the severity and profitability of this vulnerability depend on the implementation of the external contract and the state of this contract. If proper reentrancy guards are in place or if the state changes are managed correctly, the risk could be mitigated. The criticism lacks a detailed analysis of how the external contract's behavior could specifically exploit the state of this contract, making the assessment somewhat superficial.",
+        "correctness": 6,
+        "severity": 5,
+        "profitability": 4,
+        "reason": "This function approves tokens for a spender and then calls an external contract (ApproveAndCallReceiver). If the external contract is malicious, it can call back into this contract and exploit its state before the initial operation is complete, potentially leading to unexpected behavior or loss of funds.",
+        "code": "function approveAndCall(address _spender, uint256 _amount, bytes _extraData) public returns (bool success) { require(approve(_spender, _amount)); ApproveAndCallReceiver(_spender).receiveApproval( msg.sender, _amount, this, _extraData ); return true; }",
+        "file_name": "2018-10706.sol",
+        "final_score": 5.25
+    },
+    {
+        "function_name": "transferFrom",
+        "vulnerability": "Integer Overflow",
+        "criticism": "The criticism correctly identifies a potential integer overflow vulnerability in the allowance update line. However, it fails to consider the context of the Solidity version and the presence of SafeMath library or similar overflow protections. Modern Solidity versions (0.8.0 and above) and the use of SafeMath in older versions inherently protect against such overflows. Therefore, without specifying the Solidity version or the absence of overflow protection, the assessment might overstate the risk. Additionally, the practical exploitation of this vulnerability requires specific conditions that are not detailed, affecting the accuracy of the severity and profitability ratings.",
+        "correctness": 5,
+        "severity": 3,
+        "profitability": 2,
+        "reason": "The line 'allowance[_from][msg.sender] = allowance[_from][msg.sender] + _value;' can potentially overflow if '_value' is chosen such that the sum exceeds the maximum representable uint256 value. This could allow an attacker to wrap the allowance around and exploit the contract by transferring more tokens than intended.",
+        "code": "function transferFrom(address _from, address _to, uint256 _value) realUser(_from) realUser(_to) moreThanZero(_value) public returns (bool success) { require(balanceOf[_from] >= _value); require(balanceOf[_to] + _value > balanceOf[_to]); require(_value <= allowance[_from][msg.sender]); balanceOf[_from] = balanceOf[_from] - _value; balanceOf[_to] = balanceOf[_to] + _value; allowance[_from][msg.sender] = allowance[_from][msg.sender] + _value; emit Transfer(_from, _to, _value); return true; }",
+        "file_name": "2018-10706.sol",
+        "final_score": 3.75
+    }
 ]
\ No newline at end of file
diff --git a/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/ranker_default/2018-10944.json b/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/ranker_default/2018-10944.json
index 81837ec3..14450d77 100644
--- a/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/ranker_default/2018-10944.json
+++ b/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/ranker_default/2018-10944.json
@@ -1,38 +1,38 @@
-[
-    {
-        "function_name": "request_dividend",
-        "vulnerability": "Reentrancy",
-        "criticism": "The identification of reentrancy vulnerability in the 'request_dividend' function is accurate due to the use of 'send' without a reentrancy guard. However, the severity and profitability might not be as high as implied. While 'send' is indeed susceptible to reentrancy attacks, it only forwards 2300 gas, limiting the actions an attacker can perform in a fallback function. Nonetheless, the risk of reentrancy should not be underestimated, especially in functions involving financial transactions. The criticism could have been more nuanced by acknowledging the gas limit but still emphasizing the importance of reentrancy guards. The correctness is rated moderately high due to accurate identification, but severity and profitability are adjusted to reflect the nuanced risk.",
-        "correctness": 7,
-        "severity": 5,
-        "profitability": 4,
-        "reason": "In the 'request_dividend' function, ether is sent using 'send' without a reentrancy guard. This could allow an attacker to re-enter the contract if the caller is a contract with a fallback function.",
-        "code": "function request_dividend(address token_holder) payable { holder_token_balance = balanceOf(token_holder)/10000000000; Message(holder_token_balance); holder_profit = holder_token_balance * profit_per_token; Message(holder_profit); Transfer(owner, token_holder , (holder_profit/10**18)); token_holder.send(holder_profit); }",
-        "file_name": "2018-10944.sol",
-        "final_score": 5.75
-    },
-    {
-        "function_name": "drain",
-        "vulnerability": "Unchecked CALL return value",
-        "criticism": "The criticism correctly identifies the use of '.send()' and the deprecated 'throw' for error handling in the 'drain' function as problematic. However, it conflates two separate issues: the deprecated error handling and the potential for gas-related failures with '.send()'. The severity of using 'throw' is relatively high due to the potential for unexpected contract behavior and the inefficiency of gas usage. The profitability of exploiting this vulnerability is low, as it primarily affects the contract owner's ability to withdraw funds. A more accurate critique would separate these concerns, emphasizing the need for updated error handling practices and the limitations of '.send()' for transferring ether. Correctness is rated moderately for identifying relevant issues, but the explanation lacks clarity in distinguishing between them.",
-        "correctness": 6,
-        "severity": 4,
-        "profitability": 1,
-        "reason": "The 'drain' function uses '.send()' to transfer ether and checks the return value with a 'throw', which is deprecated and should be replaced with 'require()' for better error handling. It's also susceptible to gas limitations of '.send()', potentially leading to failed transactions without proper notification or handling.",
-        "code": "function drain() onlyOwner { if (!owner.send(this.balance)) throw; }",
-        "file_name": "2018-10944.sol",
-        "final_score": 4.25
-    },
-    {
-        "function_name": "transferFrom",
-        "vulnerability": "Reentrancy",
-        "criticism": "The criticism of the 'transferFrom' function for reentrancy vulnerability is misplaced. Reentrancy is a concern when a contract makes an external call to an untrusted contract before it resolves its internal state. However, 'transferFrom' primarily deals with token transfers and updates balances and allowances before making any external calls. There are no external calls within 'transferFrom' that would allow for reentrancy in the provided code snippet. Therefore, the identification of reentrancy as a vulnerability in this context is incorrect, leading to a low correctness score. The severity and profitability are also rated low because the described vulnerability does not exist in this scenario.",
-        "correctness": 1,
-        "severity": 0,
-        "profitability": 0,
-        "reason": "The 'transferFrom' function transfers tokens on behalf of another address after allowance is given, but does not implement reentrancy guards. This could allow an attacker to perform a reentrancy attack if the recipient contract is malicious and has a fallback function designed to call back into this contract.",
-        "code": "function transferFrom( address _from, address _to, uint256 _amount ) returns (bool success) { if (balances[_from] >= _amount && allowed[_from][msg.sender] >= _amount && _amount > 0 && balances[_to] + _amount > balances[_to]) { balances[_from] -= _amount; allowed[_from][msg.sender] -= _amount; balances[_to] += _amount; Transfer(_from, _to, _amount); return true; } else { return false; } }",
-        "file_name": "2018-10944.sol",
-        "final_score": 0.5
-    }
+[
+    {
+        "function_name": "request_dividend",
+        "vulnerability": "Reentrancy",
+        "criticism": "The identification of reentrancy vulnerability in the 'request_dividend' function is accurate due to the use of 'send' without a reentrancy guard. However, the severity and profitability might not be as high as implied. While 'send' is indeed susceptible to reentrancy attacks, it only forwards 2300 gas, limiting the actions an attacker can perform in a fallback function. Nonetheless, the risk of reentrancy should not be underestimated, especially in functions involving financial transactions. The criticism could have been more nuanced by acknowledging the gas limit but still emphasizing the importance of reentrancy guards. The correctness is rated moderately high due to accurate identification, but severity and profitability are adjusted to reflect the nuanced risk.",
+        "correctness": 7,
+        "severity": 5,
+        "profitability": 4,
+        "reason": "In the 'request_dividend' function, ether is sent using 'send' without a reentrancy guard. This could allow an attacker to re-enter the contract if the caller is a contract with a fallback function.",
+        "code": "function request_dividend(address token_holder) payable { holder_token_balance = balanceOf(token_holder)/10000000000; Message(holder_token_balance); holder_profit = holder_token_balance * profit_per_token; Message(holder_profit); Transfer(owner, token_holder , (holder_profit/10**18)); token_holder.send(holder_profit); }",
+        "file_name": "2018-10944.sol",
+        "final_score": 5.75
+    },
+    {
+        "function_name": "drain",
+        "vulnerability": "Unchecked CALL return value",
+        "criticism": "The criticism correctly identifies the use of '.send()' and the deprecated 'throw' for error handling in the 'drain' function as problematic. However, it conflates two separate issues: the deprecated error handling and the potential for gas-related failures with '.send()'. The severity of using 'throw' is relatively high due to the potential for unexpected contract behavior and the inefficiency of gas usage. The profitability of exploiting this vulnerability is low, as it primarily affects the contract owner's ability to withdraw funds. A more accurate critique would separate these concerns, emphasizing the need for updated error handling practices and the limitations of '.send()' for transferring ether. Correctness is rated moderately for identifying relevant issues, but the explanation lacks clarity in distinguishing between them.",
+        "correctness": 6,
+        "severity": 4,
+        "profitability": 1,
+        "reason": "The 'drain' function uses '.send()' to transfer ether and checks the return value with a 'throw', which is deprecated and should be replaced with 'require()' for better error handling. It's also susceptible to gas limitations of '.send()', potentially leading to failed transactions without proper notification or handling.",
+        "code": "function drain() onlyOwner { if (!owner.send(this.balance)) throw; }",
+        "file_name": "2018-10944.sol",
+        "final_score": 4.25
+    },
+    {
+        "function_name": "transferFrom",
+        "vulnerability": "Reentrancy",
+        "criticism": "The criticism of the 'transferFrom' function for reentrancy vulnerability is misplaced. Reentrancy is a concern when a contract makes an external call to an untrusted contract before it resolves its internal state. However, 'transferFrom' primarily deals with token transfers and updates balances and allowances before making any external calls. There are no external calls within 'transferFrom' that would allow for reentrancy in the provided code snippet. Therefore, the identification of reentrancy as a vulnerability in this context is incorrect, leading to a low correctness score. The severity and profitability are also rated low because the described vulnerability does not exist in this scenario.",
+        "correctness": 1,
+        "severity": 0,
+        "profitability": 0,
+        "reason": "The 'transferFrom' function transfers tokens on behalf of another address after allowance is given, but does not implement reentrancy guards. This could allow an attacker to perform a reentrancy attack if the recipient contract is malicious and has a fallback function designed to call back into this contract.",
+        "code": "function transferFrom( address _from, address _to, uint256 _amount ) returns (bool success) { if (balances[_from] >= _amount && allowed[_from][msg.sender] >= _amount && _amount > 0 && balances[_to] + _amount > balances[_to]) { balances[_from] -= _amount; allowed[_from][msg.sender] -= _amount; balances[_to] += _amount; Transfer(_from, _to, _amount); return true; } else { return false; } }",
+        "file_name": "2018-10944.sol",
+        "final_score": 0.5
+    }
 ]
\ No newline at end of file
diff --git a/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/ranker_default/2018-11239.json b/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/ranker_default/2018-11239.json
index 695830e3..2f80da1d 100644
--- a/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/ranker_default/2018-11239.json
+++ b/src/logs/auditor_gpt-4-turbo-preview_0.7_top3_1/critic_gpt-4-turbo-preview_0.0_1_few/ranker_default/2018-11239.json
@@ -1,38 +1,38 @@
-[
-    {
-        "function_name": "_transfer",
-        "vulnerability": "Integer Overflow and Underflow",
-        "criticism": "The criticism regarding the potential for integer overflow and underflow in the _transfer function is valid, especially for Solidity versions prior to 0.8.0 which do not automatically handle these issues. The function's arithmetic operations without explicit checks for overflows or underflows could indeed lead to vulnerabilities where token balances are manipulated in unintended ways. This could potentially allow an attacker to exploit the contract by creating conditions under which these arithmetic errors occur, leading to the theft of tokens or other unintended outcomes. The severity of this vulnerability is high due to the potential impact on token balances and the integrity of the contract. Profitability for an attacker is also high, as exploiting these vulnerabilities could lead to significant gains at the expense of other users.",
-        "correctness": 8,
-        "severity": 7,
-        "profitability": 7,
-        "reason": "The function does not adequately check for integer overflows or underflows when calculating balances after a transfer and burn operation. Solidity versions prior to 0.8.0 do not automatically check for arithmetic overflows/underflows. An attacker might exploit this by sending a value that, when added to the recipient's balance, overflows the balance, potentially allowing for theft of tokens.",
-        "code": "function _transfer(address _from, address _to, uint _value) internal { require (_to != 0x0); require (balanceOf[_from] >= _value + burnPerTransaction); require (balanceOf[_to] + _value > balanceOf[_to]); balanceOf[_from] -= _value + burnPerTransaction; balanceOf[_to] += _value; balanceOf[0x0] += burnPerTransaction; currentSupply -= burnPerTransaction; Burn(_from, burnPerTransaction); Transfer(_from, _to, _value); }",
-        "file_name": "2018-11239.sol",
-        "final_score": 7.5
-    },
-    {
-        "function_name": "approve",
-        "vulnerability": "ERC20 Approve/Allowance Race Condition",
-        "criticism": "The criticism of the approve function's vulnerability to a race condition is somewhat overstated. The function's requirement that either the current allowance is zero or the new value is zero mitigates the risk of an attacker exploiting the race condition to a significant extent. However, the scenario described does indeed represent a potential vulnerability in cases where allowances are being changed from one non-zero value to another without first setting them to zero. This could lead to unexpected behavior if not properly managed by the user or the interface interacting with the contract. The correctness of identifying a vulnerability is there, but the severity is overestimated due to the mitigating conditions in the code. Profitability for an attacker is also limited, as it requires specific conditions and timing to exploit successfully.",
-        "correctness": 6,
-        "severity": 3,
-        "profitability": 2,
-        "reason": "This vulnerability occurs because the function does not handle the case where changing an allowance from a non-zero value to another non-zero value could be exploited by an attacker who is able to call transferFrom multiple times. The require condition only checks for changes from zero to non-zero or vice versa, which means an attacker can exploit the race condition by requesting a change in allowance while executing transferFrom, potentially draining the owner's funds.",
-        "code": "function approve(address _spender, uint256 _value) public returns (bool success) { require(_value == 0 || allowance[msg.sender][_spender] == 0); allowance[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; }",
-        "file_name": "2018-11239.sol",
-        "final_score": 4.25
-    },
-    {
-        "function_name": "burn",
-        "vulnerability": "Burning Tokens to 0x0 Address",
-        "criticism": "The criticism of burning tokens by sending them to the 0x0 address overlooks the intentional design choice behind such a mechanism. While it is true that burning tokens in this manner permanently removes them from circulation, thereby reducing the total supply, this is often a desired outcome in token economics to create scarcity or to fulfill specific tokenomics models. The criticism fails to acknowledge the potential benefits of such a design decision. However, caution should indeed be exercised to avoid burning tokens unintentionally. The practice of burning tokens is not inherently problematic but requires clear documentation and user understanding to prevent mistakes. The severity of this issue is low, as it aligns with the intended functionality, and profitability for an attacker is non-existent, as this action does not inherently provide a means for profit.",
-        "correctness": 5,
-        "severity": 1,
-        "profitability": 0,
-        "reason": "Directly burning tokens by sending them to the 0x0 address can lead to a permanent loss of those tokens, decreasing the total supply potentially in an undesirable manner. While this is somewhat intentional as described by the function, it can be problematic if there's a mistake in the amount to be burned. It also does not follow the best practice of burning tokens, which is to reduce the total supply without transferring to the 0x0 address.",
-        "code": "function burn(uint256 _value) public returns (bool success) { require(balanceOf[msg.sender] >= _value); balanceOf[msg.sender] -= _value; balanceOf[0x0] += _value; currentSupply -= _value; Burn(msg.sender, _value); return true; }",
-        "file_name": "2018-11239.sol",
-        "final_score": 2.75
-    }
+[
+    {
+        "function_name": "_transfer",
+        "vulnerability": "Integer Overflow and Underflow",
+        "criticism": "The criticism regarding the potential for integer overflow and underflow in the _transfer function is valid, especially for Solidity versions prior to 0.8.0 which do not automatically handle these issues. The function's arithmetic operations without explicit checks for overflows or underflows could indeed lead to vulnerabilities where token balances are manipulated in unintended ways. This could potentially allow an attacker to exploit the contract by creating conditions under which these arithmetic errors occur, leading to the theft of tokens or other unintended outcomes. The severity of this vulnerability is high due to the potential impact on token balances and the integrity of the contract. Profitability for an attacker is also high, as exploiting these vulnerabilities could lead to significant gains at the expense of other users.",
+        "correctness": 8,
+        "severity": 7,
+        "profitability": 7,
+        "reason": "The function does not adequately check for integer overflows or underflows when calculating balances after a transfer and burn operation. Solidity versions prior to 0.8.0 do not automatically check for arithmetic overflows/underflows. An attacker might exploit this by sending a value that, when added to the recipient's balance, overflows the balance, potentially allowing for theft of tokens.",
+        "code": "function _transfer(address _from, address _to, uint _value) internal { require (_to != 0x0); require (balanceOf[_from] >= _value + burnPerTransaction); require (balanceOf[_to] + _value > balanceOf[_to]); balanceOf[_from] -= _value + burnPerTransaction; balanceOf[_to] += _value; balanceOf[0x0] += burnPerTransaction; currentSupply -= burnPerTransaction; Burn(_from, burnPerTransaction); Transfer(_from, _to, _value); }",
+        "file_name": "2018-11239.sol",
+        "final_score": 7.5
+    },
+    {
+        "function_name": "approve",
+        "vulnerability": "ERC20 Approve/Allowance Race Condition",
+        "criticism": "The criticism of the approve function's vulnerability to a race condition is somewhat overstated. The function's requirement that either the current allowance is zero or the new value is zero mitigates the risk of an attacker exploiting the race condition to a significant extent. However, the scenario described does indeed represent a potential vulnerability in cases where allowances are being changed from one non-zero value to another without first setting them to zero. This could lead to unexpected behavior if not properly managed by the user or the interface interacting with the contract. The correctness of identifying a vulnerability is there, but the severity is overestimated due to the mitigating conditions in the code. Profitability for an attacker is also limited, as it requires specific conditions and timing to exploit successfully.",
+        "correctness": 6,
+        "severity": 3,
+        "profitability": 2,
+        "reason": "This vulnerability occurs because the function does not handle the case where changing an allowance from a non-zero value to another non-zero value could be exploited by an attacker who is able to call transferFrom multiple times. The require condition only checks for changes from zero to non-zero or vice versa, which means an attacker can exploit the race condition by requesting a change in allowance while executing transferFrom, potentially draining the owner's funds.",
+        "code": "function approve(address _spender, uint256 _value) public returns (bool success) { require(_value == 0 || allowance[msg.sender][_spender] == 0); allowance[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; }",
+        "file_name": "2018-11239.sol",
+        "final_score": 4.25
+    },
+    {
+        "function_name": "burn",
+        "vulnerability": "Burning Tokens to 0x0 Address",
+        "criticism": "The criticism of burning tokens by sending them to the 0x0 address overlooks the intentional design choice behind such a mechanism. While it is true that burning tokens in this manner permanently removes them from circulation, thereby reducing the total supply, this is often a desired outcome in token economics to create scarcity or to fulfill specific tokenomics models. The criticism fails to acknowledge the potential benefits of such a design decision. However, caution should indeed be exercised to avoid burning tokens unintentionally. The practice of burning tokens is not inherently problematic but requires clear documentation and user understanding to prevent mistakes. The severity of this issue is low, as it aligns with the intended functionality, and profitability for an attacker is non-existent, as this action does not inherently provide a means for profit.",
+        "correctness": 5,
+        "severity": 1,
+        "profitability": 0,
+        "reason": "Directly burning tokens by sending them to the 0x0 address can lead to a permanent loss of those tokens, decreasing the total supply potentially in an undesirable manner. While this is somewhat intentional as described by the function, it can be problematic if there's a mistake in the amount to be burned. It also does not follow the best practice of burning tokens, which is to reduce the total supply without transferring to the 0x0 address.",
+        "code": "function burn(uint256 _value) public returns (bool success) { require(balanceOf[msg.sender] >= _value); balanceOf[msg.sender] -= _value; balanceOf[0x0] += _value; currentSupply -= _value; Burn(msg.sender, _value); return true; }",
+        "file_name": "2018-11239.sol",
+        "final_score": 2.75
+    }
 ]
\ No newline at end of file
diff --git a/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-10299.json b/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-10299.json
index 70c7a8d2..ca208522 100644
--- a/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-10299.json
+++ b/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-10299.json
@@ -1,29 +1,29 @@
-[
-    {
-        "function_name": "batchTransfer",
-        "code": "function batchTransfer(address[] _receivers, uint256 _value) public whenNotPaused returns (bool) { uint cnt = _receivers.length; uint256 amount = uint256(cnt) * _value; require(cnt > 0 && cnt <= 20); require(_value > 0 && balances[msg.sender] >= amount); balances[msg.sender] = balances[msg.sender].sub(amount); for (uint i = 0; i < cnt; i++) { balances[_receivers[i]] = balances[_receivers[i]].add(_value); Transfer(msg.sender, _receivers[i], _value); } return true; }",
-        "vulnerability": "Integer Overflow and Underflow",
-        "reason": "In the 'batchTransfer' function, the calculation of the 'amount' variable can lead to an integer overflow if the product of 'cnt' and '_value' exceeds the maximum value of uint256. This could lead to unexpected behavior, such as a much smaller 'amount' than expected, which could then allow the transfer of tokens even when the sender's balance is insufficient.",
-        "file_name": "2018-10299.sol",
-        "label": "Integer Overflow",
-        "description": "An integer overflow in the batchTransfer function of a smart contract implementation for Beauty Ecosystem Coin (BEC), the Ethereum ERC20 token used in the Beauty Chain economic system, allows attackers to accomplish an unauthorized increase of digital assets by providing two _receivers arguments in conjunction with a large _value argument, as exploited in the wild in April 2018, aka the \"batchOverflow\" issue."
-    },
-    {
-        "function_name": "transfer",
-        "code": "function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value > 0 && _value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); return true; }",
-        "vulnerability": "Insufficient validation of '_to' address",
-        "reason": "The 'transfer' function lacks a check for the case where '_to' address is the smart contract itself. If tokens are transferred to the contract's address, they could be permanently locked in the contract, as the contract does not have a function to transfer tokens it received.",
-        "file_name": "2018-10299.sol",
-        "label": "Integer Overflow",
-        "description": "An integer overflow in the batchTransfer function of a smart contract implementation for Beauty Ecosystem Coin (BEC), the Ethereum ERC20 token used in the Beauty Chain economic system, allows attackers to accomplish an unauthorized increase of digital assets by providing two _receivers arguments in conjunction with a large _value argument, as exploited in the wild in April 2018, aka the \"batchOverflow\" issue."
-    },
-    {
-        "function_name": "approve",
-        "code": "function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; }",
-        "vulnerability": "Race Condition (also known as front-running)",
-        "reason": "The 'approve' function is vulnerable to the race condition where, if you were to approve someone to spend a particular amount of tokens, and they were to spend them before you had a chance to change the approved amount, they could spend the tokens, and then spend the newly approved tokens again. This could be mitigated by requiring users to first reduce the spender's allowance to 0 before setting it to another value for the same spender.",
-        "file_name": "2018-10299.sol",
-        "label": "Integer Overflow",
-        "description": "An integer overflow in the batchTransfer function of a smart contract implementation for Beauty Ecosystem Coin (BEC), the Ethereum ERC20 token used in the Beauty Chain economic system, allows attackers to accomplish an unauthorized increase of digital assets by providing two _receivers arguments in conjunction with a large _value argument, as exploited in the wild in April 2018, aka the \"batchOverflow\" issue."
-    }
+[
+    {
+        "function_name": "batchTransfer",
+        "code": "function batchTransfer(address[] _receivers, uint256 _value) public whenNotPaused returns (bool) { uint cnt = _receivers.length; uint256 amount = uint256(cnt) * _value; require(cnt > 0 && cnt <= 20); require(_value > 0 && balances[msg.sender] >= amount); balances[msg.sender] = balances[msg.sender].sub(amount); for (uint i = 0; i < cnt; i++) { balances[_receivers[i]] = balances[_receivers[i]].add(_value); Transfer(msg.sender, _receivers[i], _value); } return true; }",
+        "vulnerability": "Integer Overflow and Underflow",
+        "reason": "In the 'batchTransfer' function, the calculation of the 'amount' variable can lead to an integer overflow if the product of 'cnt' and '_value' exceeds the maximum value of uint256. This could lead to unexpected behavior, such as a much smaller 'amount' than expected, which could then allow the transfer of tokens even when the sender's balance is insufficient.",
+        "file_name": "2018-10299.sol",
+        "label": "Integer Overflow",
+        "description": "An integer overflow in the batchTransfer function of a smart contract implementation for Beauty Ecosystem Coin (BEC), the Ethereum ERC20 token used in the Beauty Chain economic system, allows attackers to accomplish an unauthorized increase of digital assets by providing two _receivers arguments in conjunction with a large _value argument, as exploited in the wild in April 2018, aka the \"batchOverflow\" issue."
+    },
+    {
+        "function_name": "transfer",
+        "code": "function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value > 0 && _value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); return true; }",
+        "vulnerability": "Insufficient validation of '_to' address",
+        "reason": "The 'transfer' function lacks a check for the case where '_to' address is the smart contract itself. If tokens are transferred to the contract's address, they could be permanently locked in the contract, as the contract does not have a function to transfer tokens it received.",
+        "file_name": "2018-10299.sol",
+        "label": "Integer Overflow",
+        "description": "An integer overflow in the batchTransfer function of a smart contract implementation for Beauty Ecosystem Coin (BEC), the Ethereum ERC20 token used in the Beauty Chain economic system, allows attackers to accomplish an unauthorized increase of digital assets by providing two _receivers arguments in conjunction with a large _value argument, as exploited in the wild in April 2018, aka the \"batchOverflow\" issue."
+    },
+    {
+        "function_name": "approve",
+        "code": "function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; }",
+        "vulnerability": "Race Condition (also known as front-running)",
+        "reason": "The 'approve' function is vulnerable to the race condition where, if you were to approve someone to spend a particular amount of tokens, and they were to spend them before you had a chance to change the approved amount, they could spend the tokens, and then spend the newly approved tokens again. This could be mitigated by requiring users to first reduce the spender's allowance to 0 before setting it to another value for the same spender.",
+        "file_name": "2018-10299.sol",
+        "label": "Integer Overflow",
+        "description": "An integer overflow in the batchTransfer function of a smart contract implementation for Beauty Ecosystem Coin (BEC), the Ethereum ERC20 token used in the Beauty Chain economic system, allows attackers to accomplish an unauthorized increase of digital assets by providing two _receivers arguments in conjunction with a large _value argument, as exploited in the wild in April 2018, aka the \"batchOverflow\" issue."
+    }
 ]
\ No newline at end of file
diff --git a/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-10376.json b/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-10376.json
index c645b18e..72ac0a9b 100644
--- a/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-10376.json
+++ b/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-10376.json
@@ -1,29 +1,29 @@
-[
-    {
-        "function_name": "transferFrom",
-        "code": "function transferFrom(address _from, address _to, uint256 _value) public transferAllowed(_from) returns (bool success) { if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) { balances[_to] += _value; balances[_from] -= _value; allowed[_from][msg.sender] -= _value; Transfer(_from, _to, _value); return true; } else { return false; } }",
-        "vulnerability": "Missing Input Validation",
-        "reason": "The function 'transferFrom' is missing a validation check to verify if the '_to' address is a non-zero address. This means that it's possible to send tokens to the 0x0 address, effectively destroying them and reducing the total supply of tokens.",
-        "file_name": "2018-10376.sol",
-        "label": "Integer Overflow",
-        "description": "An integer overflow in the transferProxy function of a smart contract implementation for SmartMesh (aka SMT), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized increase of digital assets via crafted _fee and _value parameters, as exploited in the wild in April 2018, aka the \"proxyOverflow\" issue."
-    },
-    {
-        "function_name": "allocateTokens",
-        "code": "function allocateTokens(address[] _owners, uint256[] _values) public onlyOwner { if(allocateEndTime < now) revert(); if(_owners.length != _values.length) revert(); for(uint256 i = 0; i < _owners.length ; i++){ address to = _owners[i]; uint256 value = _values[i]; if(totalSupply + value <= totalSupply || balances[to] + value <= balances[to]) revert(); totalSupply += value; balances[to] += value; } }",
-        "vulnerability": "Arbitrary Minting",
-        "reason": "The function 'allocateTokens' allows the contract owner to mint an arbitrary number of tokens at any time, which is a centralization risk. The owner can manipulate the token supply at will, potentially diluting the value of other holders' tokens.",
-        "file_name": "2018-10376.sol",
-        "label": "Integer Overflow",
-        "description": "An integer overflow in the transferProxy function of a smart contract implementation for SmartMesh (aka SMT), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized increase of digital assets via crafted _fee and _value parameters, as exploited in the wild in April 2018, aka the \"proxyOverflow\" issue."
-    },
-    {
-        "function_name": "changeOwner",
-        "code": "function changeOwner(address _newOwner) public onlyOwner { require(_newOwner != owner); newOwner = _newOwner; }",
-        "vulnerability": "Ownership Takeover",
-        "reason": "The 'changeOwner' function does not require the new owner to accept the ownership. This means that the contract owner can set any address as the new owner, even if that address is not controlled by anyone or is controlled by an attacker. This could result in an irreversible loss of control over the contract.",
-        "file_name": "2018-10376.sol",
-        "label": "Integer Overflow",
-        "description": "An integer overflow in the transferProxy function of a smart contract implementation for SmartMesh (aka SMT), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized increase of digital assets via crafted _fee and _value parameters, as exploited in the wild in April 2018, aka the \"proxyOverflow\" issue."
-    }
+[
+    {
+        "function_name": "transferFrom",
+        "code": "function transferFrom(address _from, address _to, uint256 _value) public transferAllowed(_from) returns (bool success) { if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) { balances[_to] += _value; balances[_from] -= _value; allowed[_from][msg.sender] -= _value; Transfer(_from, _to, _value); return true; } else { return false; } }",
+        "vulnerability": "Missing Input Validation",
+        "reason": "The function 'transferFrom' is missing a validation check to verify if the '_to' address is a non-zero address. This means that it's possible to send tokens to the 0x0 address, effectively destroying them and reducing the total supply of tokens.",
+        "file_name": "2018-10376.sol",
+        "label": "Integer Overflow",
+        "description": "An integer overflow in the transferProxy function of a smart contract implementation for SmartMesh (aka SMT), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized increase of digital assets via crafted _fee and _value parameters, as exploited in the wild in April 2018, aka the \"proxyOverflow\" issue."
+    },
+    {
+        "function_name": "allocateTokens",
+        "code": "function allocateTokens(address[] _owners, uint256[] _values) public onlyOwner { if(allocateEndTime < now) revert(); if(_owners.length != _values.length) revert(); for(uint256 i = 0; i < _owners.length ; i++){ address to = _owners[i]; uint256 value = _values[i]; if(totalSupply + value <= totalSupply || balances[to] + value <= balances[to]) revert(); totalSupply += value; balances[to] += value; } }",
+        "vulnerability": "Arbitrary Minting",
+        "reason": "The function 'allocateTokens' allows the contract owner to mint an arbitrary number of tokens at any time, which is a centralization risk. The owner can manipulate the token supply at will, potentially diluting the value of other holders' tokens.",
+        "file_name": "2018-10376.sol",
+        "label": "Integer Overflow",
+        "description": "An integer overflow in the transferProxy function of a smart contract implementation for SmartMesh (aka SMT), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized increase of digital assets via crafted _fee and _value parameters, as exploited in the wild in April 2018, aka the \"proxyOverflow\" issue."
+    },
+    {
+        "function_name": "changeOwner",
+        "code": "function changeOwner(address _newOwner) public onlyOwner { require(_newOwner != owner); newOwner = _newOwner; }",
+        "vulnerability": "Ownership Takeover",
+        "reason": "The 'changeOwner' function does not require the new owner to accept the ownership. This means that the contract owner can set any address as the new owner, even if that address is not controlled by anyone or is controlled by an attacker. This could result in an irreversible loss of control over the contract.",
+        "file_name": "2018-10376.sol",
+        "label": "Integer Overflow",
+        "description": "An integer overflow in the transferProxy function of a smart contract implementation for SmartMesh (aka SMT), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized increase of digital assets via crafted _fee and _value parameters, as exploited in the wild in April 2018, aka the \"proxyOverflow\" issue."
+    }
 ]
\ No newline at end of file
diff --git a/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-10468.json b/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-10468.json
index a672212e..210f1219 100644
--- a/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-10468.json
+++ b/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-10468.json
@@ -1,29 +1,29 @@
-[
-    {
-        "function_name": "transfer",
-        "code": "function transfer(address _to, uint256 _value) returns (bool success) { if(msg.data.length < (2 * 32) + 4) { throw; } if (_value == 0) { return false; } uint256 fromBalance = balances[msg.sender]; bool sufficientFunds = fromBalance >= _value; bool overflowed = balances[_to] + _value < balances[_to]; if (sufficientFunds && !overflowed) { balances[msg.sender] -= _value; balances[_to] += _value; Transfer(msg.sender, _to, _value); return true; } else { return false; } }",
-        "vulnerability": "Integer Overflow and Underflow",
-        "reason": "The function does not prevent integer overflow and underflow. An attacker can use this vulnerability to manipulate the balance of accounts, such as adding tokens to their account or removing tokens from other accounts.",
-        "file_name": "2018-10468.sol",
-        "label": "Wrong Logic",
-        "description": "The transferFrom function of a smart contract implementation for Useless Ethereum Token (UET), an Ethereum ERC20 token, allows attackers to steal assets (e.g., transfer all victims' balances into their account) because certain computations involving _value are incorrect, as exploited in the wild starting in December 2017, aka the \"transferFlaw\" issue."
-    },
-    {
-        "function_name": "transferFrom",
-        "code": "function transferFrom(address _from, address _to, uint256 _value) returns (bool success) { if(msg.data.length < (3 * 32) + 4) { throw; } if (_value == 0) { return false; } uint256 fromBalance = balances[_from]; uint256 allowance = allowed[_from][msg.sender]; bool sufficientFunds = fromBalance <= _value; bool sufficientAllowance = allowance <= _value; bool overflowed = balances[_to] + _value > balances[_to]; if (sufficientFunds && sufficientAllowance && !overflowed) { balances[_to] += _value; balances[_from] -= _value; allowed[_from][msg.sender] -= _value; Transfer(_from, _to, _value); return true; } else { return false; } }",
-        "vulnerability": "Integer Overflow and Underflow",
-        "reason": "The function does not prevent integer overflow and underflow. An attacker can use this vulnerability to manipulate the balance of accounts and the allowance of tokens, such as adding tokens to their account or removing tokens from other accounts.",
-        "file_name": "2018-10468.sol",
-        "label": "Wrong Logic",
-        "description": "The transferFrom function of a smart contract implementation for Useless Ethereum Token (UET), an Ethereum ERC20 token, allows attackers to steal assets (e.g., transfer all victims' balances into their account) because certain computations involving _value are incorrect, as exploited in the wild starting in December 2017, aka the \"transferFlaw\" issue."
-    },
-    {
-        "function_name": "approve",
-        "code": "function approve(address _spender, uint256 _value) returns (bool success) { if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; } allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; }",
-        "vulnerability": "Race Condition",
-        "reason": "The function does not prevent double spending due to race conditions. An attacker can use this vulnerability to spend tokens more than their allowance by calling the function multiple times before the transaction is mined.",
-        "file_name": "2018-10468.sol",
-        "label": "Wrong Logic",
-        "description": "The transferFrom function of a smart contract implementation for Useless Ethereum Token (UET), an Ethereum ERC20 token, allows attackers to steal assets (e.g., transfer all victims' balances into their account) because certain computations involving _value are incorrect, as exploited in the wild starting in December 2017, aka the \"transferFlaw\" issue."
-    }
+[
+    {
+        "function_name": "transfer",
+        "code": "function transfer(address _to, uint256 _value) returns (bool success) { if(msg.data.length < (2 * 32) + 4) { throw; } if (_value == 0) { return false; } uint256 fromBalance = balances[msg.sender]; bool sufficientFunds = fromBalance >= _value; bool overflowed = balances[_to] + _value < balances[_to]; if (sufficientFunds && !overflowed) { balances[msg.sender] -= _value; balances[_to] += _value; Transfer(msg.sender, _to, _value); return true; } else { return false; } }",
+        "vulnerability": "Integer Overflow and Underflow",
+        "reason": "The function does not prevent integer overflow and underflow. An attacker can use this vulnerability to manipulate the balance of accounts, such as adding tokens to their account or removing tokens from other accounts.",
+        "file_name": "2018-10468.sol",
+        "label": "Wrong Logic",
+        "description": "The transferFrom function of a smart contract implementation for Useless Ethereum Token (UET), an Ethereum ERC20 token, allows attackers to steal assets (e.g., transfer all victims' balances into their account) because certain computations involving _value are incorrect, as exploited in the wild starting in December 2017, aka the \"transferFlaw\" issue."
+    },
+    {
+        "function_name": "transferFrom",
+        "code": "function transferFrom(address _from, address _to, uint256 _value) returns (bool success) { if(msg.data.length < (3 * 32) + 4) { throw; } if (_value == 0) { return false; } uint256 fromBalance = balances[_from]; uint256 allowance = allowed[_from][msg.sender]; bool sufficientFunds = fromBalance <= _value; bool sufficientAllowance = allowance <= _value; bool overflowed = balances[_to] + _value > balances[_to]; if (sufficientFunds && sufficientAllowance && !overflowed) { balances[_to] += _value; balances[_from] -= _value; allowed[_from][msg.sender] -= _value; Transfer(_from, _to, _value); return true; } else { return false; } }",
+        "vulnerability": "Integer Overflow and Underflow",
+        "reason": "The function does not prevent integer overflow and underflow. An attacker can use this vulnerability to manipulate the balance of accounts and the allowance of tokens, such as adding tokens to their account or removing tokens from other accounts.",
+        "file_name": "2018-10468.sol",
+        "label": "Wrong Logic",
+        "description": "The transferFrom function of a smart contract implementation for Useless Ethereum Token (UET), an Ethereum ERC20 token, allows attackers to steal assets (e.g., transfer all victims' balances into their account) because certain computations involving _value are incorrect, as exploited in the wild starting in December 2017, aka the \"transferFlaw\" issue."
+    },
+    {
+        "function_name": "approve",
+        "code": "function approve(address _spender, uint256 _value) returns (bool success) { if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; } allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; }",
+        "vulnerability": "Race Condition",
+        "reason": "The function does not prevent double spending due to race conditions. An attacker can use this vulnerability to spend tokens more than their allowance by calling the function multiple times before the transaction is mined.",
+        "file_name": "2018-10468.sol",
+        "label": "Wrong Logic",
+        "description": "The transferFrom function of a smart contract implementation for Useless Ethereum Token (UET), an Ethereum ERC20 token, allows attackers to steal assets (e.g., transfer all victims' balances into their account) because certain computations involving _value are incorrect, as exploited in the wild starting in December 2017, aka the \"transferFlaw\" issue."
+    }
 ]
\ No newline at end of file
diff --git a/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-11411.json b/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-11411.json
index 61fc959c..f1ec65fd 100644
--- a/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-11411.json
+++ b/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-11411.json
@@ -1,29 +1,29 @@
-[
-    {
-        "function_name": "distributeFUD",
-        "code": "function distributeFUD(address[] addresses, uint256 _value, uint256 _ethbal) onlyOwner { for (uint i = 0; i < addresses.length; i++) { if (getEthBalance(addresses[i]) < _ethbal) { continue; } balances[owner] -= _value; balances[addresses[i]] += _value; Transfer(owner, addresses[i], _value); } }",
-        "vulnerability": "Underflow vulnerability",
-        "reason": "In the distributeFUD function, the balance of the owner is reduced by _value without checking whether the balance of the owner is greater than or equal to _value. This could allow an underflow if _value is greater than the owner's balance which would result in an extremely large balance being assigned to the owner.",
-        "file_name": "2018-11411.sol",
-        "label": "Wrong Logic",
-        "description": "The transferFrom function of a smart contract implementation for DimonCoin (FUD), an Ethereum ERC20 token, allows attackers to steal assets (e.g., transfer all victims' balances into their account) because certain computations involving _value are incorrect."
-    },
-    {
-        "function_name": "transferFrom",
-        "code": "function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(2 * 32) returns (bool success) { if (_value == 0) { return false; } uint256 fromBalance = balances[_from]; uint256 allowance = allowed[_from][msg.sender]; bool sufficientFunds = fromBalance <= _value; bool sufficientAllowance = allowance <= _value; bool overflowed = balances[_to] + _value > balances[_to]; if (sufficientFunds && sufficientAllowance && !overflowed) { balances[_to] += _value; balances[_from] -= _value; allowed[_from][msg.sender] -= _value; Transfer(_from, _to, _value); return true; } else { return false; } }",
-        "vulnerability": "Insufficient balance check",
-        "reason": "The condition for checking sufficient funds in the transferFrom function is incorrect. The condition 'fromBalance <= _value' should be 'fromBalance >= _value'. This could potentially allow a user to transfer more tokens than they have in their balance.",
-        "file_name": "2018-11411.sol",
-        "label": "Wrong Logic",
-        "description": "The transferFrom function of a smart contract implementation for DimonCoin (FUD), an Ethereum ERC20 token, allows attackers to steal assets (e.g., transfer all victims' balances into their account) because certain computations involving _value are incorrect."
-    },
-    {
-        "function_name": "approve",
-        "code": "function approve(address _spender, uint256 _value) returns (bool success) { if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; } allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; }",
-        "vulnerability": "Approval race condition",
-        "reason": "The approve function is vulnerable to the race condition. If a user calls this function twice in quick succession, the second call could overwrite the first, potentially leading to unexpected behavior. This is commonly known as the approve/transferFrom race condition in ERC20 tokens.",
-        "file_name": "2018-11411.sol",
-        "label": "Wrong Logic",
-        "description": "The transferFrom function of a smart contract implementation for DimonCoin (FUD), an Ethereum ERC20 token, allows attackers to steal assets (e.g., transfer all victims' balances into their account) because certain computations involving _value are incorrect."
-    }
+[
+    {
+        "function_name": "distributeFUD",
+        "code": "function distributeFUD(address[] addresses, uint256 _value, uint256 _ethbal) onlyOwner { for (uint i = 0; i < addresses.length; i++) { if (getEthBalance(addresses[i]) < _ethbal) { continue; } balances[owner] -= _value; balances[addresses[i]] += _value; Transfer(owner, addresses[i], _value); } }",
+        "vulnerability": "Underflow vulnerability",
+        "reason": "In the distributeFUD function, the balance of the owner is reduced by _value without checking whether the balance of the owner is greater than or equal to _value. This could allow an underflow if _value is greater than the owner's balance which would result in an extremely large balance being assigned to the owner.",
+        "file_name": "2018-11411.sol",
+        "label": "Wrong Logic",
+        "description": "The transferFrom function of a smart contract implementation for DimonCoin (FUD), an Ethereum ERC20 token, allows attackers to steal assets (e.g., transfer all victims' balances into their account) because certain computations involving _value are incorrect."
+    },
+    {
+        "function_name": "transferFrom",
+        "code": "function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(2 * 32) returns (bool success) { if (_value == 0) { return false; } uint256 fromBalance = balances[_from]; uint256 allowance = allowed[_from][msg.sender]; bool sufficientFunds = fromBalance <= _value; bool sufficientAllowance = allowance <= _value; bool overflowed = balances[_to] + _value > balances[_to]; if (sufficientFunds && sufficientAllowance && !overflowed) { balances[_to] += _value; balances[_from] -= _value; allowed[_from][msg.sender] -= _value; Transfer(_from, _to, _value); return true; } else { return false; } }",
+        "vulnerability": "Insufficient balance check",
+        "reason": "The condition for checking sufficient funds in the transferFrom function is incorrect. The condition 'fromBalance <= _value' should be 'fromBalance >= _value'. This could potentially allow a user to transfer more tokens than they have in their balance.",
+        "file_name": "2018-11411.sol",
+        "label": "Wrong Logic",
+        "description": "The transferFrom function of a smart contract implementation for DimonCoin (FUD), an Ethereum ERC20 token, allows attackers to steal assets (e.g., transfer all victims' balances into their account) because certain computations involving _value are incorrect."
+    },
+    {
+        "function_name": "approve",
+        "code": "function approve(address _spender, uint256 _value) returns (bool success) { if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; } allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; }",
+        "vulnerability": "Approval race condition",
+        "reason": "The approve function is vulnerable to the race condition. If a user calls this function twice in quick succession, the second call could overwrite the first, potentially leading to unexpected behavior. This is commonly known as the approve/transferFrom race condition in ERC20 tokens.",
+        "file_name": "2018-11411.sol",
+        "label": "Wrong Logic",
+        "description": "The transferFrom function of a smart contract implementation for DimonCoin (FUD), an Ethereum ERC20 token, allows attackers to steal assets (e.g., transfer all victims' balances into their account) because certain computations involving _value are incorrect."
+    }
 ]
\ No newline at end of file
diff --git a/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-12025.json b/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-12025.json
index 0b0d0311..cac7b531 100644
--- a/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-12025.json
+++ b/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-12025.json
@@ -1,29 +1,29 @@
-[
-    {
-        "function_name": "transfer",
-        "code": "function transfer(address to, uint value) returns (bool success) { if (frozenAccount[msg.sender]) return false; if(balances[msg.sender] < value) return false; if(balances[to] + value < balances[to]) return false; balances[msg.sender] -= value; balances[to] += value; Transfer(msg.sender, to, value); return true; }",
-        "vulnerability": "Integer Underflow",
-        "reason": "The transfer function does not handle the case where the sender's balance is less than the value to be transferred. Essentially, if the sender's balance is less than the value to be transferred, the balance of the sender would underflow, and the sender would end up with an extraordinarily high balance.",
-        "file_name": "2018-12025.sol",
-        "label": "Wrong Logic",
-        "description": "The transferFrom function of a smart contract implementation for FuturXE (FXE), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized transfer of digital assets because of a logic error. The developer messed up with the boolean judgment - if the input value is smaller than or equal to allowed value, the transfer session would stop execution by returning false. This makes no sense, because the transferFrom() function should require the transferring value to not exceed the allowed value in the first place. Suppose this function asks for the allowed value to be smaller than the input. Then, the attacker could easily ignore the allowance: after this condition, the `allowed[from][msg.sender] -= value;` would cause an underflow because the allowed part is smaller than the value. The attacker could transfer any amount of FuturXe tokens of any accounts to an appointed account (the `_to` address) because the allowed value is initialized to 0, and the attacker could bypass this restriction even without the victim's private key."
-    },
-    {
-        "function_name": "transferFrom",
-        "code": "function transferFrom(address from, address to, uint value) returns (bool success) { if (frozenAccount[msg.sender]) return false; if(balances[from] < value) return false; if( allowed[from][msg.sender] >= value ) return false; if(balances[to] + value < balances[to]) return false; balances[from] -= value; allowed[from][msg.sender] -= value; balances[to] += value; Transfer(from, to, value); return true; }",
-        "vulnerability": "Integer Underflow",
-        "reason": "Similar to the transfer function, the transferFrom function does not handle the case where the sender's balance or allowed value is less than the value to be transferred. This could result in the sender's balance or allowance underflowing and becoming extremely high.",
-        "file_name": "2018-12025.sol",
-        "label": "Wrong Logic",
-        "description": "The transferFrom function of a smart contract implementation for FuturXE (FXE), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized transfer of digital assets because of a logic error. The developer messed up with the boolean judgment - if the input value is smaller than or equal to allowed value, the transfer session would stop execution by returning false. This makes no sense, because the transferFrom() function should require the transferring value to not exceed the allowed value in the first place. Suppose this function asks for the allowed value to be smaller than the input. Then, the attacker could easily ignore the allowance: after this condition, the `allowed[from][msg.sender] -= value;` would cause an underflow because the allowed part is smaller than the value. The attacker could transfer any amount of FuturXe tokens of any accounts to an appointed account (the `_to` address) because the allowed value is initialized to 0, and the attacker could bypass this restriction even without the victim's private key."
-    },
-    {
-        "function_name": "mintToken",
-        "code": "function mintToken(address target, uint256 mintedAmount) onlyOwner{ balances[target] += mintedAmount; totalSupply += mintedAmount; Transfer(0,owner,mintedAmount); Transfer(owner,target,mintedAmount); }",
-        "vulnerability": "Arbitrary Minting",
-        "reason": "The mintToken function allows the contract owner to create an arbitrary amount of tokens and send them to any address. This could lead to an oversupply of tokens, devaluing existing tokens, and it could be used maliciously to grant an enormous number of tokens to an attacker's address.",
-        "file_name": "2018-12025.sol",
-        "label": "Wrong Logic",
-        "description": "The transferFrom function of a smart contract implementation for FuturXE (FXE), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized transfer of digital assets because of a logic error. The developer messed up with the boolean judgment - if the input value is smaller than or equal to allowed value, the transfer session would stop execution by returning false. This makes no sense, because the transferFrom() function should require the transferring value to not exceed the allowed value in the first place. Suppose this function asks for the allowed value to be smaller than the input. Then, the attacker could easily ignore the allowance: after this condition, the `allowed[from][msg.sender] -= value;` would cause an underflow because the allowed part is smaller than the value. The attacker could transfer any amount of FuturXe tokens of any accounts to an appointed account (the `_to` address) because the allowed value is initialized to 0, and the attacker could bypass this restriction even without the victim's private key."
-    }
+[
+    {
+        "function_name": "transfer",
+        "code": "function transfer(address to, uint value) returns (bool success) { if (frozenAccount[msg.sender]) return false; if(balances[msg.sender] < value) return false; if(balances[to] + value < balances[to]) return false; balances[msg.sender] -= value; balances[to] += value; Transfer(msg.sender, to, value); return true; }",
+        "vulnerability": "Integer Underflow",
+        "reason": "The transfer function does not handle the case where the sender's balance is less than the value to be transferred. Essentially, if the sender's balance is less than the value to be transferred, the balance of the sender would underflow, and the sender would end up with an extraordinarily high balance.",
+        "file_name": "2018-12025.sol",
+        "label": "Wrong Logic",
+        "description": "The transferFrom function of a smart contract implementation for FuturXE (FXE), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized transfer of digital assets because of a logic error. The developer messed up with the boolean judgment - if the input value is smaller than or equal to allowed value, the transfer session would stop execution by returning false. This makes no sense, because the transferFrom() function should require the transferring value to not exceed the allowed value in the first place. Suppose this function asks for the allowed value to be smaller than the input. Then, the attacker could easily ignore the allowance: after this condition, the `allowed[from][msg.sender] -= value;` would cause an underflow because the allowed part is smaller than the value. The attacker could transfer any amount of FuturXe tokens of any accounts to an appointed account (the `_to` address) because the allowed value is initialized to 0, and the attacker could bypass this restriction even without the victim's private key."
+    },
+    {
+        "function_name": "transferFrom",
+        "code": "function transferFrom(address from, address to, uint value) returns (bool success) { if (frozenAccount[msg.sender]) return false; if(balances[from] < value) return false; if( allowed[from][msg.sender] >= value ) return false; if(balances[to] + value < balances[to]) return false; balances[from] -= value; allowed[from][msg.sender] -= value; balances[to] += value; Transfer(from, to, value); return true; }",
+        "vulnerability": "Integer Underflow",
+        "reason": "Similar to the transfer function, the transferFrom function does not handle the case where the sender's balance or allowed value is less than the value to be transferred. This could result in the sender's balance or allowance underflowing and becoming extremely high.",
+        "file_name": "2018-12025.sol",
+        "label": "Wrong Logic",
+        "description": "The transferFrom function of a smart contract implementation for FuturXE (FXE), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized transfer of digital assets because of a logic error. The developer messed up with the boolean judgment - if the input value is smaller than or equal to allowed value, the transfer session would stop execution by returning false. This makes no sense, because the transferFrom() function should require the transferring value to not exceed the allowed value in the first place. Suppose this function asks for the allowed value to be smaller than the input. Then, the attacker could easily ignore the allowance: after this condition, the `allowed[from][msg.sender] -= value;` would cause an underflow because the allowed part is smaller than the value. The attacker could transfer any amount of FuturXe tokens of any accounts to an appointed account (the `_to` address) because the allowed value is initialized to 0, and the attacker could bypass this restriction even without the victim's private key."
+    },
+    {
+        "function_name": "mintToken",
+        "code": "function mintToken(address target, uint256 mintedAmount) onlyOwner{ balances[target] += mintedAmount; totalSupply += mintedAmount; Transfer(0,owner,mintedAmount); Transfer(owner,target,mintedAmount); }",
+        "vulnerability": "Arbitrary Minting",
+        "reason": "The mintToken function allows the contract owner to create an arbitrary amount of tokens and send them to any address. This could lead to an oversupply of tokens, devaluing existing tokens, and it could be used maliciously to grant an enormous number of tokens to an attacker's address.",
+        "file_name": "2018-12025.sol",
+        "label": "Wrong Logic",
+        "description": "The transferFrom function of a smart contract implementation for FuturXE (FXE), an Ethereum ERC20 token, allows attackers to accomplish an unauthorized transfer of digital assets because of a logic error. The developer messed up with the boolean judgment - if the input value is smaller than or equal to allowed value, the transfer session would stop execution by returning false. This makes no sense, because the transferFrom() function should require the transferring value to not exceed the allowed value in the first place. Suppose this function asks for the allowed value to be smaller than the input. Then, the attacker could easily ignore the allowance: after this condition, the `allowed[from][msg.sender] -= value;` would cause an underflow because the allowed part is smaller than the value. The attacker could transfer any amount of FuturXe tokens of any accounts to an appointed account (the `_to` address) because the allowed value is initialized to 0, and the attacker could bypass this restriction even without the victim's private key."
+    }
 ]
\ No newline at end of file
diff --git a/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-13836.json b/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-13836.json
index 6263f0d5..86895275 100644
--- a/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-13836.json
+++ b/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-13836.json
@@ -1,29 +1,29 @@
-[
-    {
-        "function_name": "transfer",
-        "code": "function transfer(address _to, uint256 _amount) public returns (bool success) { require(balances[msg.sender] >= _amount && _amount > 0); balances[msg.sender] -= _amount; balances[_to] += _amount; Transfer(msg.sender, _to, _amount); return true; }",
-        "vulnerability": "Missing input validation",
-        "reason": "The function doesn't check if the '_to' address is a zero address. Transferring to a zero address is like burning tokens, it can lead to permanent loss of tokens.",
-        "file_name": "2018-13836.sol",
-        "label": "Integer Overflow",
-        "description": "An integer overflow vulnerability exists in the function multiTransfer of Rocket Coin (XRC), an Ethereum token smart contract. An attacker could use it to set any user's balance."
-    },
-    {
-        "function_name": "multiTransfer",
-        "code": "function multiTransfer(address[] _addresses, uint[] _amounts) public returns (bool success) { require(_addresses.length <= 100 && _addresses.length == _amounts.length); uint totalAmount; for (uint a = 0; a < _amounts.length; a++) { totalAmount += _amounts[a]; } require(totalAmount > 0 && balances[msg.sender] >= totalAmount); balances[msg.sender] -= totalAmount; for (uint b = 0; b < _addresses.length; b++) { if (_amounts[b] > 0) { balances[_addresses[b]] += _amounts[b]; Transfer(msg.sender, _addresses[b], _amounts[b]); } } return true; }",
-        "vulnerability": "Arithmetic Overflow",
-        "reason": "The code doesn't check for arithmetic overflow when adding up the '_amounts'. This could potentially lead to incorrect balance calculations.",
-        "file_name": "2018-13836.sol",
-        "label": "Integer Overflow",
-        "description": "An integer overflow vulnerability exists in the function multiTransfer of Rocket Coin (XRC), an Ethereum token smart contract. An attacker could use it to set any user's balance."
-    },
-    {
-        "function_name": "withdrawFunds",
-        "code": "function withdrawFunds(address _token) public returns (bool success) { require(msg.sender == owner); if (_token == address(0)) { owner.transfer(this.balance); } else { Token ERC20 = Token(_token); ERC20.transfer(owner, ERC20.balanceOf(this)); } return true; }",
-        "vulnerability": "Potential for unexpected behavior",
-        "reason": "The function transfers all the contract's ether to the owner without any restrictions or checks. This might not be an exploitable vulnerability, but it's a bad practice and can lead to unexpected behavior. For example, if the contract receives ether from a fallback function, it will be immediately transferred to the owner, which might not be the intended behavior.",
-        "file_name": "2018-13836.sol",
-        "label": "Integer Overflow",
-        "description": "An integer overflow vulnerability exists in the function multiTransfer of Rocket Coin (XRC), an Ethereum token smart contract. An attacker could use it to set any user's balance."
-    }
+[
+    {
+        "function_name": "transfer",
+        "code": "function transfer(address _to, uint256 _amount) public returns (bool success) { require(balances[msg.sender] >= _amount && _amount > 0); balances[msg.sender] -= _amount; balances[_to] += _amount; Transfer(msg.sender, _to, _amount); return true; }",
+        "vulnerability": "Missing input validation",
+        "reason": "The function doesn't check if the '_to' address is a zero address. Transferring to a zero address is like burning tokens, it can lead to permanent loss of tokens.",
+        "file_name": "2018-13836.sol",
+        "label": "Integer Overflow",
+        "description": "An integer overflow vulnerability exists in the function multiTransfer of Rocket Coin (XRC), an Ethereum token smart contract. An attacker could use it to set any user's balance."
+    },
+    {
+        "function_name": "multiTransfer",
+        "code": "function multiTransfer(address[] _addresses, uint[] _amounts) public returns (bool success) { require(_addresses.length <= 100 && _addresses.length == _amounts.length); uint totalAmount; for (uint a = 0; a < _amounts.length; a++) { totalAmount += _amounts[a]; } require(totalAmount > 0 && balances[msg.sender] >= totalAmount); balances[msg.sender] -= totalAmount; for (uint b = 0; b < _addresses.length; b++) { if (_amounts[b] > 0) { balances[_addresses[b]] += _amounts[b]; Transfer(msg.sender, _addresses[b], _amounts[b]); } } return true; }",
+        "vulnerability": "Arithmetic Overflow",
+        "reason": "The code doesn't check for arithmetic overflow when adding up the '_amounts'. This could potentially lead to incorrect balance calculations.",
+        "file_name": "2018-13836.sol",
+        "label": "Integer Overflow",
+        "description": "An integer overflow vulnerability exists in the function multiTransfer of Rocket Coin (XRC), an Ethereum token smart contract. An attacker could use it to set any user's balance."
+    },
+    {
+        "function_name": "withdrawFunds",
+        "code": "function withdrawFunds(address _token) public returns (bool success) { require(msg.sender == owner); if (_token == address(0)) { owner.transfer(this.balance); } else { Token ERC20 = Token(_token); ERC20.transfer(owner, ERC20.balanceOf(this)); } return true; }",
+        "vulnerability": "Potential for unexpected behavior",
+        "reason": "The function transfers all the contract's ether to the owner without any restrictions or checks. This might not be an exploitable vulnerability, but it's a bad practice and can lead to unexpected behavior. For example, if the contract receives ether from a fallback function, it will be immediately transferred to the owner, which might not be the intended behavior.",
+        "file_name": "2018-13836.sol",
+        "label": "Integer Overflow",
+        "description": "An integer overflow vulnerability exists in the function multiTransfer of Rocket Coin (XRC), an Ethereum token smart contract. An attacker could use it to set any user's balance."
+    }
 ]
\ No newline at end of file
diff --git a/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-15552.json b/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-15552.json
index 1acfa11c..a9b77169 100644
--- a/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-15552.json
+++ b/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-15552.json
@@ -1,29 +1,29 @@
-[
-    {
-        "function_name": "AddTicket",
-        "code": "function AddTicket() public payable { require(msg.value == ticketPrice); require(numtickets < maxTickets); lastTicketTime = now; numtickets += 1; totalBounty += ticketPrice; bool success = numtickets == maxTickets; NewTicket(msg.sender, success); if(success) { PayWinner(msg.sender); } }",
-        "vulnerability": "Re-entrancy attack",
-        "reason": "The AddTicket function calls the PayWinner function, which in turn makes an external call to the winner's address. This operation can allow the contract to be re-entered before the state variables have been updated, allowing an attacker to potentially withdraw funds multiple times.",
-        "file_name": "2018-15552.sol",
-        "label": "Bad Randomness",
-        "description": "The \"PayWinner\" function of a simplelottery smart contract implementation for The Ethereum Lottery, an Ethereum gambling game, generates a random value with publicly readable variable \"maxTickets\" (which is private, yet predictable and readable by the eth.getStorageAt function). Therefore, it allows attackers to always win and get rewards."
-    },
-    {
-        "function_name": "PayWinner",
-        "code": "function PayWinner( address winner ) private { require(numtickets == maxTickets); uint ownerTax = 6 * totalBounty / 100; uint winnerPrice = totalBounty - ownerTax; LottoComplete(msg.sender, lottoIndex, winnerPrice); lottoIndex += 1; numtickets = 0; totalBounty = 0; if(_direction == 0 && maxTickets < 20) maxTickets += 1; if(_direction == 1 && maxTickets > 10) maxTickets -= 1; if(_direction == 0 && maxTickets == 20) _direction = 1; if(_direction == 1 && maxTickets == 10) _direction = 0; worldOwner.transfer(ownerTax); winner.transfer(winnerPrice); }",
-        "vulnerability": "Integer division rounding down",
-        "reason": "The calculation of the ownerTax can result in rounding down due to integer division. This can lead to precision loss and the winner receiving less than the intended amount.",
-        "file_name": "2018-15552.sol",
-        "label": "Bad Randomness",
-        "description": "The \"PayWinner\" function of a simplelottery smart contract implementation for The Ethereum Lottery, an Ethereum gambling game, generates a random value with publicly readable variable \"maxTickets\" (which is private, yet predictable and readable by the eth.getStorageAt function). Therefore, it allows attackers to always win and get rewards."
-    },
-    {
-        "function_name": "withdraw",
-        "code": "function withdraw() public { require(worldOwner == msg.sender); lottoIndex += 1; numtickets = 0; totalBounty = 0; worldOwner.transfer(this.balance); }",
-        "vulnerability": "Potential for loss of funds",
-        "reason": "The worldOwner can withdraw all funds from the contract at any time. This can result in a loss of funds for users who have purchased tickets but the lottery has not yet been drawn.",
-        "file_name": "2018-15552.sol",
-        "label": "Bad Randomness",
-        "description": "The \"PayWinner\" function of a simplelottery smart contract implementation for The Ethereum Lottery, an Ethereum gambling game, generates a random value with publicly readable variable \"maxTickets\" (which is private, yet predictable and readable by the eth.getStorageAt function). Therefore, it allows attackers to always win and get rewards."
-    }
+[
+    {
+        "function_name": "AddTicket",
+        "code": "function AddTicket() public payable { require(msg.value == ticketPrice); require(numtickets < maxTickets); lastTicketTime = now; numtickets += 1; totalBounty += ticketPrice; bool success = numtickets == maxTickets; NewTicket(msg.sender, success); if(success) { PayWinner(msg.sender); } }",
+        "vulnerability": "Re-entrancy attack",
+        "reason": "The AddTicket function calls the PayWinner function, which in turn makes an external call to the winner's address. This operation can allow the contract to be re-entered before the state variables have been updated, allowing an attacker to potentially withdraw funds multiple times.",
+        "file_name": "2018-15552.sol",
+        "label": "Bad Randomness",
+        "description": "The \"PayWinner\" function of a simplelottery smart contract implementation for The Ethereum Lottery, an Ethereum gambling game, generates a random value with publicly readable variable \"maxTickets\" (which is private, yet predictable and readable by the eth.getStorageAt function). Therefore, it allows attackers to always win and get rewards."
+    },
+    {
+        "function_name": "PayWinner",
+        "code": "function PayWinner( address winner ) private { require(numtickets == maxTickets); uint ownerTax = 6 * totalBounty / 100; uint winnerPrice = totalBounty - ownerTax; LottoComplete(msg.sender, lottoIndex, winnerPrice); lottoIndex += 1; numtickets = 0; totalBounty = 0; if(_direction == 0 && maxTickets < 20) maxTickets += 1; if(_direction == 1 && maxTickets > 10) maxTickets -= 1; if(_direction == 0 && maxTickets == 20) _direction = 1; if(_direction == 1 && maxTickets == 10) _direction = 0; worldOwner.transfer(ownerTax); winner.transfer(winnerPrice); }",
+        "vulnerability": "Integer division rounding down",
+        "reason": "The calculation of the ownerTax can result in rounding down due to integer division. This can lead to precision loss and the winner receiving less than the intended amount.",
+        "file_name": "2018-15552.sol",
+        "label": "Bad Randomness",
+        "description": "The \"PayWinner\" function of a simplelottery smart contract implementation for The Ethereum Lottery, an Ethereum gambling game, generates a random value with publicly readable variable \"maxTickets\" (which is private, yet predictable and readable by the eth.getStorageAt function). Therefore, it allows attackers to always win and get rewards."
+    },
+    {
+        "function_name": "withdraw",
+        "code": "function withdraw() public { require(worldOwner == msg.sender); lottoIndex += 1; numtickets = 0; totalBounty = 0; worldOwner.transfer(this.balance); }",
+        "vulnerability": "Potential for loss of funds",
+        "reason": "The worldOwner can withdraw all funds from the contract at any time. This can result in a loss of funds for users who have purchased tickets but the lottery has not yet been drawn.",
+        "file_name": "2018-15552.sol",
+        "label": "Bad Randomness",
+        "description": "The \"PayWinner\" function of a simplelottery smart contract implementation for The Ethereum Lottery, an Ethereum gambling game, generates a random value with publicly readable variable \"maxTickets\" (which is private, yet predictable and readable by the eth.getStorageAt function). Therefore, it allows attackers to always win and get rewards."
+    }
 ]
\ No newline at end of file
diff --git a/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-17877.json b/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-17877.json
index aec2dd6d..a9cca922 100644
--- a/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-17877.json
+++ b/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-17877.json
@@ -1,29 +1,29 @@
-[
-    {
-        "function_name": "buyHeart",
-        "code": "function buyHeart(address referred) public payable {...}",
-        "vulnerability": "Reentrancy Attack",
-        "reason": "The function 'buyHeart' executes a transfer of ether (msg.sender.transfer(Luckybuy)) before resolving all the internal state changes, which leaves the contract vulnerable to a Reentrancy Attack. In this attack, the attacker could repeatedly call the 'buyHeart' function before the first function call is finished, draining the contract of Ether.",
-        "file_name": "2018-17877.sol",
-        "label": "Bad Randomness",
-        "description": "A lottery smart contract implementation for Greedy 599, an Ethereum gambling game, generates a random value that is predictable via an external contract call. The developer used the extcodesize() function to prevent a malicious contract from being called, but the attacker can bypass it by writing the core code in the constructor of their exploit code. Therefore, it allows attackers to always win and get rewards."
-    },
-    {
-        "function_name": "withdraw",
-        "code": "function withdraw(uint _round) public {...}",
-        "vulnerability": "Unchecked Return Values",
-        "reason": "The function 'withdraw' executes the 'transfer' method without validating its return value. If the transfer fails for whatever reason (e.g., the receiver contract throws an exception), the contract will not be aware of this, leading to inconsistent state and potential loss of funds.",
-        "file_name": "2018-17877.sol",
-        "label": "Bad Randomness",
-        "description": "A lottery smart contract implementation for Greedy 599, an Ethereum gambling game, generates a random value that is predictable via an external contract call. The developer used the extcodesize() function to prevent a malicious contract from being called, but the attacker can bypass it by writing the core code in the constructor of their exploit code. Therefore, it allows attackers to always win and get rewards."
-    },
-    {
-        "function_name": "win",
-        "code": "function win() public {...}",
-        "vulnerability": "Arbitrary Address Execution",
-        "reason": "In the 'win' function, there is a transfer of ether to an address without checking whether the address is a contract or externally owned account. If the address is a contract, the fallback function could be executed, allowing for potential malicious attacks. Moreover, it does not check whether the transfer was successful, potentially leading to loss of funds.",
-        "file_name": "2018-17877.sol",
-        "label": "Bad Randomness",
-        "description": "A lottery smart contract implementation for Greedy 599, an Ethereum gambling game, generates a random value that is predictable via an external contract call. The developer used the extcodesize() function to prevent a malicious contract from being called, but the attacker can bypass it by writing the core code in the constructor of their exploit code. Therefore, it allows attackers to always win and get rewards."
-    }
+[
+    {
+        "function_name": "buyHeart",
+        "code": "function buyHeart(address referred) public payable {...}",
+        "vulnerability": "Reentrancy Attack",
+        "reason": "The function 'buyHeart' executes a transfer of ether (msg.sender.transfer(Luckybuy)) before resolving all the internal state changes, which leaves the contract vulnerable to a Reentrancy Attack. In this attack, the attacker could repeatedly call the 'buyHeart' function before the first function call is finished, draining the contract of Ether.",
+        "file_name": "2018-17877.sol",
+        "label": "Bad Randomness",
+        "description": "A lottery smart contract implementation for Greedy 599, an Ethereum gambling game, generates a random value that is predictable via an external contract call. The developer used the extcodesize() function to prevent a malicious contract from being called, but the attacker can bypass it by writing the core code in the constructor of their exploit code. Therefore, it allows attackers to always win and get rewards."
+    },
+    {
+        "function_name": "withdraw",
+        "code": "function withdraw(uint _round) public {...}",
+        "vulnerability": "Unchecked Return Values",
+        "reason": "The function 'withdraw' executes the 'transfer' method without validating its return value. If the transfer fails for whatever reason (e.g., the receiver contract throws an exception), the contract will not be aware of this, leading to inconsistent state and potential loss of funds.",
+        "file_name": "2018-17877.sol",
+        "label": "Bad Randomness",
+        "description": "A lottery smart contract implementation for Greedy 599, an Ethereum gambling game, generates a random value that is predictable via an external contract call. The developer used the extcodesize() function to prevent a malicious contract from being called, but the attacker can bypass it by writing the core code in the constructor of their exploit code. Therefore, it allows attackers to always win and get rewards."
+    },
+    {
+        "function_name": "win",
+        "code": "function win() public {...}",
+        "vulnerability": "Arbitrary Address Execution",
+        "reason": "In the 'win' function, there is a transfer of ether to an address without checking whether the address is a contract or externally owned account. If the address is a contract, the fallback function could be executed, allowing for potential malicious attacks. Moreover, it does not check whether the transfer was successful, potentially leading to loss of funds.",
+        "file_name": "2018-17877.sol",
+        "label": "Bad Randomness",
+        "description": "A lottery smart contract implementation for Greedy 599, an Ethereum gambling game, generates a random value that is predictable via an external contract call. The developer used the extcodesize() function to prevent a malicious contract from being called, but the attacker can bypass it by writing the core code in the constructor of their exploit code. Therefore, it allows attackers to always win and get rewards."
+    }
 ]
\ No newline at end of file
diff --git a/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-17882.json b/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-17882.json
index 6f7bf82c..fed80bab 100644
--- a/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-17882.json
+++ b/src/logs/auditor_gpt-4_0.7_top3_1/CVE-2018-17882.json
@@ -1,29 +1,29 @@
-[
-    {
-        "function_name": "transfer",
-        "code": "function transfer(address _to, uint256 _value) public returns (bool success) { balances[msg.sender] = safeSub(balances[msg.sender], _value); balances[_to] = safeAdd(balances[_to], _value); Transfer(msg.sender, _to, _value); return true; }",
-        "vulnerability": "Missing input validation",
-        "reason": "This function allows an attacker to send tokens to the 0x0 address (burn address) or any other unintended addresses. This is because there is no validation on the '_to' address. The function can lead to permanent loss of tokens.",
-        "file_name": "2018-17882.sol",
-        "label": "Integer Overflow",
-        "description": "An Integer overflow vulnerability exists in the batchTransfer function of a smart contract implementation for CryptoBotsBattle (CBTB), an Ethereum token. This vulnerability could be used by an attacker to create an arbitrary amount of tokens for any user."
-    },
-    {
-        "function_name": "batchTransfer",
-        "code": "function batchTransfer(address[] _to, uint _value) public { balances[msg.sender] = safeSub( balances[msg.sender], _to.length * _value ); for (uint i = 0; i < _to.length; i++) { balances[_to[i]] = safeAdd(balances[_to[i]], _value); Transfer(msg.sender, _to[i], _value); } }",
-        "vulnerability": "Integer Overflow and Underflow",
-        "reason": "In the '_to.length * _value' operation, if the multiplication of the length of '_to' array and '_value' is greater than the max limit of uint, it can cause overflow. If overflow occurs, the result will be less than the operands which can cause the 'safeSub' function to underflow, leading to incorrect balance updates.",
-        "file_name": "2018-17882.sol",
-        "label": "Integer Overflow",
-        "description": "An Integer overflow vulnerability exists in the batchTransfer function of a smart contract implementation for CryptoBotsBattle (CBTB), an Ethereum token. This vulnerability could be used by an attacker to create an arbitrary amount of tokens for any user."
-    },
-    {
-        "function_name": "transferFrom",
-        "code": "function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) { balances[_to] = safeAdd(balances[_to], _value); balances[_from] = safeSub(balances[_from], _value); if (_to != fights) { allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value); } Transfer(_from, _to, _value); return true; }",
-        "vulnerability": "Missing authorization check",
-        "reason": "The function allows to transfer tokens from any account to any other account without checking if 'msg.sender' is allowed to do so. This can result in unauthorized transfer of tokens.",
-        "file_name": "2018-17882.sol",
-        "label": "Integer Overflow",
-        "description": "An Integer overflow vulnerability exists in the batchTransfer function of a smart contract implementation for CryptoBotsBattle (CBTB), an Ethereum token. This vulnerability could be used by an attacker to create an arbitrary amount of tokens for any user."
-    }
+[
+    {
+        "function_name": "transfer",
+        "code": "function transfer(address _to, uint256 _value) public returns (bool success) { balances[msg.sender] = safeSub(balances[msg.sender], _value); balances[_to] = safeAdd(balances[_to], _value); Transfer(msg.sender, _to, _value); return true; }",
+        "vulnerability": "Missing input validation",
+        "reason": "This function allows an attacker to send tokens to the 0x0 address (burn address) or any other unintended addresses. This is because there is no validation on the '_to' address. The function can lead to permanent loss of tokens.",
+        "file_name": "2018-17882.sol",
+        "label": "Integer Overflow",
+        "description": "An Integer overflow vulnerability exists in the batchTransfer function of a smart contract implementation for CryptoBotsBattle (CBTB), an Ethereum token. This vulnerability could be used by an attacker to create an arbitrary amount of tokens for any user."
+    },
+    {
+        "function_name": "batchTransfer",
+        "code": "function batchTransfer(address[] _to, uint _value) public { balances[msg.sender] = safeSub( balances[msg.sender], _to.length * _value ); for (uint i = 0; i < _to.length; i++) { balances[_to[i]] = safeAdd(balances[_to[i]], _value); Transfer(msg.sender, _to[i], _value); } }",
+        "vulnerability": "Integer Overflow and Underflow",
+        "reason": "In the '_to.length * _value' operation, if the multiplication of the length of '_to' array and '_value' is greater than the max limit of uint, it can cause overflow. If overflow occurs, the result will be less than the operands which can cause the 'safeSub' function to underflow, leading to incorrect balance updates.",
+        "file_name": "2018-17882.sol",
+        "label": "Integer Overflow",
+        "description": "An Integer overflow vulnerability exists in the batchTransfer function of a smart contract implementation for CryptoBotsBattle (CBTB), an Ethereum token. This vulnerability could be used by an attacker to create an arbitrary amount of tokens for any user."
+    },
+    {
+        "function_name": "transferFrom",
+        "code": "function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) { balances[_to] = safeAdd(balances[_to], _value); balances[_from] = safeSub(balances[_from], _value); if (_to != fights) { allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value); } Transfer(_from, _to, _value); return true; }",
+        "vulnerability": "Missing authorization check",
+        "reason": "The function allows to transfer tokens from any account to any other account without checking if 'msg.sender' is allowed to do so. This can result in unauthorized transfer of tokens.",
+        "file_name": "2018-17882.sol",
+        "label": "Integer Overflow",
+        "description": "An Integer overflow vulnerability exists in the batchTransfer function of a smart contract implementation for CryptoBotsBattle (CBTB), an Ethereum token. This vulnerability could be used by an attacker to create an arbitrary amount of tokens for any user."
+    }
 ]
\ No newline at end of file
diff --git a/src/model.py b/src/model.py
index bd94fa43..ef45c24d 100644
--- a/src/model.py
+++ b/src/model.py
@@ -1,42 +1,74 @@
 import time
-import openai
 import os
-from utils import dotdict
+from openai import OpenAI
 
-
-OPENAI_API_KEY = os.environ.get('OPENAI_API_KEY') #"Enter your openai API key"
+DEEPSEEK_API_KEY = os.environ.get('DEEPSEEK_API_KEY')
+OPENAI_API_KEY = os.environ.get('OPENAI_API_KEY')
 completion_tokens = 0
 prompt_tokens = 0
 
+# Initialize Deepseek client
+deepseek_client = OpenAI(api_key=DEEPSEEK_API_KEY, base_url="https://api.deepseek.com")
+
+# Initialize OpenAI client
+openai_client = OpenAI(api_key=OPENAI_API_KEY)
+
 def gpt(prompt, model, temperature=0.7, max_tokens=4000, n=1, stop=None) -> list:
     messages = [{"role": "user", "content": prompt}]
-    if model == "gpt-4":
-        pass
-        time.sleep(30) # to prevent speed limitation exception
     return chatgpt(messages, model=model, temperature=temperature, max_tokens=max_tokens, n=n, stop=stop)
 
-
-def chatgpt(messages, model, temperature, max_tokens, n, stop) -> list:
+def chatgpt(messages, model, temperature=0.0, max_tokens=4000, n=1, stop=None) -> list:
     global completion_tokens, prompt_tokens
     outputs = []
+
+    # Check which client to use based on model name
+    # OpenAI models start with "gpt-", while Deepseek models don't
+    if model.startswith("gpt-"):
+        client = openai_client
+    else:
+        client = deepseek_client
+        #mapping model name if its r1
+        if model == "deepseek-r1":
+            model = "deepseek-reasoner"
+    
     while n > 0:
-        cnt = min(n, 20)
-        n -= cnt
-        res = openai.chat.completions.create(model=model, messages=messages, temperature=temperature, max_tokens=max_tokens,
-                                           n=cnt, stop=stop)
-        outputs.extend([choice.message.content for choice in res.choices])
-        # log completion tokens
+        batch_size = min(n, 20)
+        n -= batch_size
+        
+        res = client.chat.completions.create(
+            model=model,
+            messages=messages,
+            max_tokens=max_tokens,
+            stop=stop
+        )
+        
+        outputs.append(res.choices[0].message.content)
+        
         completion_tokens += res.usage.completion_tokens
         prompt_tokens += res.usage.prompt_tokens
+    
     return outputs
 
-
-def gpt_usage(backend="gpt-4"):
+def gpt_usage(backend="deepseek-r1"):
     global completion_tokens, prompt_tokens
-    if backend == "gpt-4":
-        cost = completion_tokens / 1000 * 0.06 + prompt_tokens / 1000 * 0.03
-    elif backend == "gpt-4-turbo-preview":
-        cost = completion_tokens / 1000 * 0.03 + prompt_tokens / 1000 * 0.01
-    elif backend == "gpt-3.5-turbo":
-        cost = completion_tokens / 1000 * 0.002 + prompt_tokens / 1000 * 0.0015
-    return {"completion_tokens": completion_tokens, "prompt_tokens": prompt_tokens, "cost": cost}
+    
+    # If the backend is an OpenAI model
+    if backend.startswith("gpt-"):
+        # OpenAI pricing varies per model
+        if "gpt-4" in backend:
+            # GPT-4 pricing (approximate)
+            input_cost = prompt_tokens / 1000000 * 10.0  # $10 per 1M tokens (approximate)
+            output_cost = completion_tokens / 1000000 * 30.0  # $30 per 1M tokens (approximate)
+        else:
+            # GPT-3.5 pricing (approximate)
+            input_cost = prompt_tokens / 1000000 * 0.5  # $0.5 per 1M tokens (approximate)
+            output_cost = completion_tokens / 1000000 * 1.5  # $1.5 per 1M tokens (approximate)
+    else:
+        # Deepseek Reasoner pricing (standard rate), not off peak discount rates. 
+        # Input: $0.55 per 1M tokens
+        # Output: $2.19 per 1M tokens
+        input_cost = prompt_tokens / 1000000 * 0.55
+        output_cost = completion_tokens / 1000000 * 2.19
+        
+    cost = input_cost + output_cost
+    return {"completion_tokens": completion_tokens, "prompt_tokens": prompt_tokens, "cost": cost}
\ No newline at end of file
diff --git a/src/run_auditor.py b/src/run_auditor.py
index 5794c346..283479b6 100644
--- a/src/run_auditor.py
+++ b/src/run_auditor.py
@@ -1,117 +1,115 @@
-import json
-import random
-import argparse
-import os
-from tqdm import tqdm
-from utils import dotdict
-from stqdm import stqdm
-
-import openai
-from model import gpt, gpt_usage, OPENAI_API_KEY
-from prompts import auditor_prompt, auditor_format_constrain
-from prompts import topk_prompt1, topk_prompt2
-
-completion_tokens = 0
-prompt_tokens = 0
-
-def remove_spaces(s):
-    return ' '.join(s.split())
-
-def prompt_wrap(prompt, format_constraint, code, topk):
-    return prompt + code + format_constraint + topk_prompt1.format(topk=topk) + topk_prompt2
-
-def auditor_response_parse(auditor_outputs):
-    output_list = []
-    for auditor_output in auditor_outputs:
-        try:
-            start_idx = auditor_output.find("{")
-            end_idx = auditor_output.rfind("}")
-            data = json.loads(auditor_output[start_idx: end_idx+1])
-        except:
-            print("parsing json fail.")
-            continue
-        try:
-            output_list += data["output_list"]
-        except:
-            print("No vulnerability detected")
-            continue
-
-    return output_list
-
-def solve(args, code):
-
-    bug_info_list = []
-    auditor_input = prompt_wrap(auditor_prompt, auditor_format_constrain, code, args.topk)
-
-    try:
-        auditor_outputs = gpt(auditor_input, model=args.backend, temperature=args.temperature, n=args.num_auditor)
-        bug_info_list = auditor_response_parse(auditor_outputs)
-    except Exception as e:
-        print(e)
-
-    return bug_info_list
-
-def run(args):
-
-    if args.get('openai_api_key') is None:
-        openai.api_key = OPENAI_API_KEY
-    else:
-        openai.api_key = args.openai_api_key
-
-    with open("data/CVE_label/CVE2description.json", "r") as f:
-        CVE2description = json.load(f)
-    with open("data/CVE_label/CVE2label.json", "r") as f:
-        CVE2label = json.load(f)
-
-    # log output file
-    log_dir = f"./src/logs/auditor_{args.backend}_{args.temperature}_top{args.topk}_{args.num_auditor}"
-
-    for CVE_index, label in stqdm(CVE2label.items()):
-
-        all_bug_info_list = []
-        description = CVE2description[CVE_index]
-        file_name = "-".join(CVE_index.split("-")[1:]) + ".sol"
-
-        with open("data/CVE_clean/" + file_name, "r") as f:
-            code = f.read()
-        # remove space
-        code = remove_spaces(code)
-
-        # auditing
-        bug_info_list = solve(args, code)
-
-        if len(bug_info_list) == 0: #Sometimes the query fails because the model does not strictly follow the format
-            print("{index} failed".format(index=CVE_index))
-            continue
-
-        for info in bug_info_list:
-            info.update({"file_name": file_name, "label": label, "description": description})
-            all_bug_info_list.append(info)
-
-        file = f"{log_dir}/{CVE_index}.json"
-        os.makedirs(os.path.dirname(file), exist_ok=True)
-
-        with open(file, 'w') as f:
-            json.dump(all_bug_info_list, f, indent=4)
-
-def parse_args():
-    args = argparse.ArgumentParser()
-    args.add_argument('--backend', type=str, choices=['gpt-3.5-turbo','gpt-4', 'gpt-4-turbo-preview'], default='gpt-4-turbo-preview')
-    args.add_argument('--temperature', type=float, default=0.7)
-    args.add_argument('--dataset', type=str, default="CVE")
-    args.add_argument('--topk', type=int, default=5) # the topk per each auditor
-    args.add_argument('--num_auditor', type=int, default=1)
-
-    args = args.parse_args()
-    return args
-
-if __name__ == '__main__':
-
-    args = parse_args()
-    print(args)
-    run(args)
-
-def mainfnc(args=dotdict):
-    # args = parse_args()
-    # print(args)
+import json
+import random
+import argparse
+import os
+from tqdm import tqdm
+from utils import dotdict
+from stqdm import stqdm
+
+from model import gpt, gpt_usage
+from prompts import auditor_prompt, auditor_format_constrain
+from prompts import topk_prompt1, topk_prompt2
+
+completion_tokens = 0
+prompt_tokens = 0
+
+def remove_spaces(s):
+    return ' '.join(s.split())
+
+def prompt_wrap(prompt, format_constraint, code, topk):
+    return prompt + code + format_constraint + topk_prompt1.format(topk=topk) + topk_prompt2
+
+def auditor_response_parse(auditor_outputs):
+    output_list = []
+    for auditor_output in auditor_outputs:
+        try:
+            start_idx = auditor_output.find("{")
+            end_idx = auditor_output.rfind("}")
+            data = json.loads(auditor_output[start_idx: end_idx+1])
+        except:
+            print("parsing json fail.")
+            continue
+        try:
+            output_list += data["output_list"]
+        except:
+            print("No vulnerability detected")
+            continue
+
+    return output_list
+
+def solve(args, code):
+
+    bug_info_list = []
+    auditor_input = prompt_wrap(auditor_prompt, auditor_format_constrain, code, args.topk)
+
+    try:
+        auditor_outputs = gpt(auditor_input, model=args.backend, temperature=args.temperature, n=args.num_auditor)
+        bug_info_list = auditor_response_parse(auditor_outputs)
+    except Exception as e:
+        print(e)
+
+    return bug_info_list
+
+def run(args):
+
+    # No need to set API keys as they were previously here as they're already set in model.py
+    # Just proceeding with the rest of the function
+
+    with open("data/CVE_label/CVE2description.json", "r") as f:
+        CVE2description = json.load(f)
+    with open("data/CVE_label/CVE2label.json", "r") as f:
+        CVE2label = json.load(f)
+
+    # log output file
+    log_dir = f"./src/logs/auditor_{args.backend}_{args.temperature}_top{args.topk}_{args.num_auditor}"
+
+    for CVE_index, label in stqdm(CVE2label.items()):
+
+        all_bug_info_list = []
+        description = CVE2description[CVE_index]
+        file_name = "-".join(CVE_index.split("-")[1:]) + ".sol"
+
+        with open(f"{args.data_dir}/" + file_name, "r") as f:
+            code = f.read()
+        # remove space
+        code = remove_spaces(code)
+
+        # auditing
+        bug_info_list = solve(args, code)
+
+        if len(bug_info_list) == 0: #Sometimes the query fails because the model does not strictly follow the format
+            print("{index} failed".format(index=CVE_index))
+            continue
+
+        for info in bug_info_list:
+            info.update({"file_name": file_name, "label": label, "description": description})
+            all_bug_info_list.append(info)
+
+        file = f"{log_dir}/{CVE_index}.json"
+        os.makedirs(os.path.dirname(file), exist_ok=True)
+
+        with open(file, 'w') as f:
+            json.dump(all_bug_info_list, f, indent=4)
+
+def parse_args():
+    args = argparse.ArgumentParser()
+    args.add_argument('--backend', type=str, choices=['gpt-3.5-turbo','gpt-4', 'gpt-4-turbo-preview', 'deepseek-r1', 'deepseek-reasoner'], default='gpt-4-turbo-preview')
+    args.add_argument('--temperature', type=float, default=0.7)
+    args.add_argument('--dataset', type=str, default="CVE")
+    args.add_argument('--data_dir', type=str, default="data_full/CVE_clean")
+    args.add_argument('--topk', type=int, default=5) # the topk per each auditor
+    args.add_argument('--num_auditor', type=int, default=1)
+
+    args = args.parse_args()
+    return args
+
+if __name__ == '__main__':
+
+    args = parse_args()
+    print(args)
+    run(args)
+
+def mainfnc(args=dotdict):
+    # args = parse_args()
+    # print(args)
     run(args)
\ No newline at end of file
diff --git a/src/run_auditor_user_defined.py b/src/run_auditor_user_defined.py
index edec358c..8a5432c0 100644
--- a/src/run_auditor_user_defined.py
+++ b/src/run_auditor_user_defined.py
@@ -1,113 +1,113 @@
-import json
-import random
-import argparse
-import os
-from tqdm import tqdm
-from utils import dotdict
-from stqdm import stqdm
-
-import openai
-from model import gpt, gpt_usage, OPENAI_API_KEY
-from prompts import auditor_prompt, auditor_format_constrain
-from prompts import topk_prompt1, topk_prompt2
-
-completion_tokens = 0
-prompt_tokens = 0
-
-def remove_spaces(s):
-    return ' '.join(s.split())
-
-def prompt_wrap(prompt, format_constraint, code, topk):
-    return prompt + code + format_constraint + topk_prompt1.format(topk=topk) + topk_prompt2
-
-def auditor_response_parse(auditor_outputs):
-    output_list = []
-    for auditor_output in auditor_outputs:
-        try:
-            start_idx = auditor_output.find("{")
-            end_idx = auditor_output.rfind("}")
-            data = json.loads(auditor_output[start_idx: end_idx+1])
-        except:
-            print("parsing json fail.")
-            continue
-        try:
-            output_list += data["output_list"]
-        except:
-            print("No vulnerability detected")
-            continue
-
-    return output_list
-
-def solve(args, code):
-
-    bug_info_list = []
-    auditor_input = prompt_wrap(auditor_prompt, auditor_format_constrain, code, args.topk)
-
-    try:
-        auditor_outputs = gpt(auditor_input, model=args.backend, temperature=args.temperature, n=args.num_auditor)
-        bug_info_list = auditor_response_parse(auditor_outputs)
-    except Exception as e:
-        print(e)
-
-    return bug_info_list
-
-def run(args):
-
-    if args.get('openai_api_key') is None:
-        openai.api_key = OPENAI_API_KEY
-    else:
-        openai.api_key = args.openai_api_key
-
-    # log output file
-    log_dir = f"./src/logs/auditor_{args.backend}_{args.temperature}_top{args.topk}_{args.num_auditor}"
-
-    for file_name in stqdm(os.listdir(args.data_dir)):
-
-        all_bug_info_list = []
-
-        if not file_name.endswith(".sol"):
-            continue
-
-        with open(f"{args.data_dir}/{file_name}", "r") as f:
-            code = f.read()
-        # remove space
-        code = remove_spaces(code)
-
-        # auditing
-        bug_info_list = solve(args, code)
-
-        if len(bug_info_list) == 0: #Sometimes the query fails because the model does not strictly follow the format
-            print("{index} failed".format(index=file_name))
-            continue
-
-        for info in bug_info_list:
-            info.update({"file_name": file_name})
-            all_bug_info_list.append(info)
-
-        file = f"{log_dir}/{file_name.replace('.sol', '.json')}"
-        os.makedirs(os.path.dirname(file), exist_ok=True)
-
-        with open(file, 'w') as f:
-            json.dump(all_bug_info_list, f, indent=4)
-
-def parse_args():
-    args = argparse.ArgumentParser()
-    args.add_argument('--backend', type=str, choices=['gpt-3.5-turbo','gpt-4', 'gpt-4-turbo-preview'], default='gpt-4-turbo-preview')
-    args.add_argument('--temperature', type=float, default=0.7)
-    args.add_argument('--data_dir', type=str, default="data/CVE_clean")
-    args.add_argument('--topk', type=int, default=5) # the topk per each auditor
-    args.add_argument('--num_auditor', type=int, default=1)
-
-    args = args.parse_args()
-    return args
-
-if __name__ == '__main__':
-
-    args = parse_args()
-    print(args)
-    run(args)
-
-def mainfnc(args=dotdict):
-    # args = parse_args()
-    # print(args)
+import json
+import random
+import argparse
+import os
+from tqdm import tqdm
+from utils import dotdict
+from stqdm import stqdm
+
+import openai
+from model import gpt, gpt_usage, OPENAI_API_KEY
+from prompts import auditor_prompt, auditor_format_constrain
+from prompts import topk_prompt1, topk_prompt2
+
+completion_tokens = 0
+prompt_tokens = 0
+
+def remove_spaces(s):
+    return ' '.join(s.split())
+
+def prompt_wrap(prompt, format_constraint, code, topk):
+    return prompt + code + format_constraint + topk_prompt1.format(topk=topk) + topk_prompt2
+
+def auditor_response_parse(auditor_outputs):
+    output_list = []
+    for auditor_output in auditor_outputs:
+        try:
+            start_idx = auditor_output.find("{")
+            end_idx = auditor_output.rfind("}")
+            data = json.loads(auditor_output[start_idx: end_idx+1])
+        except:
+            print("parsing json fail.")
+            continue
+        try:
+            output_list += data["output_list"]
+        except:
+            print("No vulnerability detected")
+            continue
+
+    return output_list
+
+def solve(args, code):
+
+    bug_info_list = []
+    auditor_input = prompt_wrap(auditor_prompt, auditor_format_constrain, code, args.topk)
+
+    try:
+        auditor_outputs = gpt(auditor_input, model=args.backend, temperature=args.temperature, n=args.num_auditor)
+        bug_info_list = auditor_response_parse(auditor_outputs)
+    except Exception as e:
+        print(e)
+
+    return bug_info_list
+
+def run(args):
+
+    if args.get('openai_api_key') is None:
+        openai.api_key = OPENAI_API_KEY
+    else:
+        openai.api_key = args.openai_api_key
+
+    # log output file
+    log_dir = f"./src/logs/auditor_{args.backend}_{args.temperature}_top{args.topk}_{args.num_auditor}"
+
+    for file_name in stqdm(os.listdir(args.data_dir)):
+
+        all_bug_info_list = []
+
+        if not file_name.endswith(".sol"):
+            continue
+
+        with open(f"{args.data_dir}/{file_name}", "r") as f:
+            code = f.read()
+        # remove space
+        code = remove_spaces(code)
+
+        # auditing
+        bug_info_list = solve(args, code)
+
+        if len(bug_info_list) == 0: #Sometimes the query fails because the model does not strictly follow the format
+            print("{index} failed".format(index=file_name))
+            continue
+
+        for info in bug_info_list:
+            info.update({"file_name": file_name})
+            all_bug_info_list.append(info)
+
+        file = f"{log_dir}/{file_name.replace('.sol', '.json')}"
+        os.makedirs(os.path.dirname(file), exist_ok=True)
+
+        with open(file, 'w') as f:
+            json.dump(all_bug_info_list, f, indent=4)
+
+def parse_args():
+    args = argparse.ArgumentParser()
+    args.add_argument('--backend', type=str, choices=['gpt-3.5-turbo','gpt-4', 'gpt-4-turbo-preview', 'deepseek-r1', 'deepseek-reasoner'], default='deepseek-r1')
+    args.add_argument('--temperature', type=float, default=0.7)
+    args.add_argument('--data_dir', type=str, default="data_full/CVE_clean")
+    args.add_argument('--topk', type=int, default=5) # the topk per each auditor
+    args.add_argument('--num_auditor', type=int, default=1)
+
+    args = args.parse_args()
+    return args
+
+if __name__ == '__main__':
+
+    args = parse_args()
+    print(args)
+    run(args)
+
+def mainfnc(args=dotdict):
+    # args = parse_args()
+    # print(args)
     run(args)
\ No newline at end of file
diff --git a/src/run_critic.py b/src/run_critic.py
index 3d8ec056..738419b4 100644
--- a/src/run_critic.py
+++ b/src/run_critic.py
@@ -1,13 +1,12 @@
 import json
 import argparse
 import os
-import openai
 from stqdm import stqdm
 from utils import dotdict
 
 
 from prompts import critic_zero_shot_prompt, critic_few_shot_prompt, critic_format_constrain
-from model import gpt, OPENAI_API_KEY
+from model import gpt
 
 completion_tokens = 0
 prompt_tokens = 0
@@ -24,10 +23,8 @@ def critic_response_parse(critic_outputs):
 
 def run(args):
 
-    if args.get('openai_api_key') is None:
-        openai.api_key = OPENAI_API_KEY
-    else:
-        openai.api_key = args.openai_api_key
+    # No need to set API keys here as they're already set in model.py
+    # Just proceed with the rest of the function
     critic_dir = f"src/logs/{args.auditor_dir}/critic_{args.backend}_{args.temperature}_{args.num_critic}_{args.shot}"
 
     for filename in stqdm(os.listdir(f"src/logs/{args.auditor_dir}")):
@@ -84,7 +81,7 @@ def run(args):
 
 def parse_args():
     args = argparse.ArgumentParser()
-    args.add_argument('--backend', type=str, choices=['gpt-3.5-turbo','gpt-4', 'gpt-4-turbo-preview'], default='gpt-4-turbo-preview')
+    args.add_argument('--backend', type=str, choices=['gpt-3.5-turbo','gpt-4', 'gpt-4-turbo-preview', 'deepseek-r1', 'deepseek-reasoner'], default='gpt-4-turbo-preview')
     args.add_argument('--temperature', type=float, default=0)
     args.add_argument('--dataset', type=str, choices=['CVE'], default="CVE")
     args.add_argument('--auditor_dir', type=str, default="auditor_gpt-4_0.7_top3_1") #The auditor output directory
diff --git a/src/run_critic_user_defined.py b/src/run_critic_user_defined.py
index c10ecb74..fe96ee61 100644
--- a/src/run_critic_user_defined.py
+++ b/src/run_critic_user_defined.py
@@ -82,7 +82,7 @@ def run(args):
 
 def parse_args():
     args = argparse.ArgumentParser()
-    args.add_argument('--backend', type=str, choices=['gpt-3.5-turbo','gpt-4', 'gpt-4-turbo-preview'], default='gpt-4-turbo-preview')
+    args.add_argument('--backend', type=str, choices=['gpt-3.5-turbo','gpt-4', 'gpt-4-turbo-preview', 'deepseek-r1', 'deepseek-reasoner'], default='gpt-4-turbo-preview')
     args.add_argument('--temperature', type=float, default=0)
     args.add_argument('--dataset', type=str, choices=['CVE'], default="CVE")
     args.add_argument('--auditor_dir', type=str, default="auditor_gpt-4_0.7_top3_1") #The auditor output directory
diff --git a/src/utils.py b/src/utils.py
index 58aebc0d..74b00534 100644
--- a/src/utils.py
+++ b/src/utils.py
@@ -1,19 +1,19 @@
-import os
-import shutil
-
-class dotdict(dict):
-    """dot.notation access to dictionary attributes"""
-    __getattr__ = dict.get
-    __setattr__ = dict.__setitem__
-    __delattr__ = dict.__delitem__
-
-def clean_folder(folder):
-    for filename in os.listdir(folder):
-        file_path = f"{folder}/{filename}"
-        try:
-            if os.path.isfile(file_path) or os.path.islink(file_path):
-                os.unlink(file_path)
-            elif os.path.isdir(file_path):
-                shutil.rmtree(file_path)
-        except Exception as e:
+import os
+import shutil
+
+class dotdict(dict):
+    """dot.notation access to dictionary attributes"""
+    __getattr__ = dict.get
+    __setattr__ = dict.__setitem__
+    __delattr__ = dict.__delitem__
+
+def clean_folder(folder):
+    for filename in os.listdir(folder):
+        file_path = f"{folder}/{filename}"
+        try:
+            if os.path.isfile(file_path) or os.path.islink(file_path):
+                os.unlink(file_path)
+            elif os.path.isdir(file_path):
+                shutil.rmtree(file_path)
+        except Exception as e:
             print('Failed to delete %s. Reason: %s' % (file_path, e))
\ No newline at end of file