diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/EgoExoBench/__pycache__/__init__.cpython-310.pyc b/VLMEvalKit-sudoku/vlmeval/dataset/EgoExoBench/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ff6bfe1b75d961d9c4ae0369a4061c8649681c4a
Binary files /dev/null and b/VLMEvalKit-sudoku/vlmeval/dataset/EgoExoBench/__pycache__/__init__.cpython-310.pyc differ
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/EgoExoBench/egoexobench.py b/VLMEvalKit-sudoku/vlmeval/dataset/EgoExoBench/egoexobench.py
new file mode 100644
index 0000000000000000000000000000000000000000..9400966c09c44420357b0bfd0569ac692aeba441
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/EgoExoBench/egoexobench.py
@@ -0,0 +1,301 @@
+import huggingface_hub
+from huggingface_hub import snapshot_download
+from ...smp import *
+from ..video_base import VideoBaseDataset
+from ..utils import build_judge, DEBUG_MESSAGE
+import torchvision.transforms as T
+from torchvision import transforms
+import pandas as pd
+import os
+import re
+from .utils import *
+import torch
+import shutil
+import glob
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+class EgoExoBench_MCQ(VideoBaseDataset):
+    MD5 = '9c0aa8da235d766d02dd7e9a19182719'
+    TYPE = 'Video-MCQ'
+
+    def __init__(self, dataset='EgoExoBench_MCQ', nframe=64, skip_EgoExo4D=False):
+        super().__init__(dataset=dataset, nframe=nframe)
+        self.frame_fps = 2
+        self.skip_EgoExo4D = skip_EgoExo4D
+
+    @classmethod
+    def supported_datasets(cls):
+        return ['EgoExoBench_MCQ']
+
+    def prepare_dataset(self, dataset_name='EgoExoBench_MCQ', repo_id='Heleun/EgoExoBench_MCQ', video_repo_id='onlyfaces/EgoExoBench'):  # noqa: E501
+        def check_integrity(pth):
+            data_file = osp.join(pth, f'{dataset_name}.tsv')
+
+            if not osp.exists(data_file):
+                return False
+
+            if md5(data_file) != self.MD5:
+                return False
+
+            return True
+        cache_path = get_cache_path(repo_id)
+        self.video_root = os.path.join(LMUDataRoot(), 'videos', 'EgoExoBench')
+        os.makedirs(self.video_root, exist_ok=True)
+        if not osp.exists(osp.join(self.video_root, 'processed_videos')) or not osp.exists(osp.join(self.video_root, 'processed_frames')):  # noqa: E501
+            snapshot_download(
+                repo_id=video_repo_id,
+                repo_type='dataset',
+                allow_patterns=['*.tar.gz.part*'],
+                local_dir=self.video_root
+            )
+
+            def combine_and_extract(root_dir, prefix, remove_parts=True):
+                parts_pattern = osp.join(root_dir, f'{prefix}.tar.gz.part*')
+                combined_archive = osp.join(root_dir, f'{prefix}.tar.gz')
+                if not osp.exists(combined_archive):
+                    parts = sorted(glob.glob(parts_pattern))
+                    with open(combined_archive, 'wb') as outfile:
+                        for part in parts:
+                            with open(part, 'rb') as infile:
+                                shutil.copyfileobj(infile, outfile)
+                shutil.unpack_archive(combined_archive, root_dir)
+                if remove_parts:
+                    for part in parts:
+                        os.remove(part)
+                    os.remove(combined_archive)
+
+            combine_and_extract(self.video_root, 'processed_videos')
+            combine_and_extract(self.video_root, 'processed_frames')
+
+        if cache_path is not None and check_integrity(cache_path):
+            dataset_path = cache_path
+        else:
+            dataset_path = snapshot_download(repo_id=repo_id, repo_type='dataset')
+
+        data_file = osp.join(dataset_path, f'{dataset_name}.tsv')
+
+        # transform
+        self.transform = T.Compose([
+            Stack(),
+            ToTorchFormatTensor()
+        ])
+
+        return dict(root=dataset_path, data_file=data_file)
+
+    def get_index(self, bound, fps, max_frame, first_idx=0, num_segments=16):
+        start, end = bound if bound else (-100000, 100000)
+        start_idx = max(first_idx, round(start * fps))
+        end_idx = min(round(end * fps), max_frame)
+        seg_size = (end_idx - start_idx) / num_segments
+        mid_seg_size = seg_size / 2
+        indices = np.arange(num_segments)
+        frame_indices = start_idx + mid_seg_size + np.round(seg_size * indices)
+        return frame_indices.astype(int)
+
+    def load_into_video_and_process(self, media, mcq_idx):
+        try:
+            from moviepy.editor import VideoFileClip, ImageSequenceClip
+        except:
+            raise ImportError(
+                'MoviePy is not installed, please install it by running "pip install moviepy==1.0.3"'
+            )
+        video_root = self.video_root
+        if media['type'] in ['image']:
+            original_image_path = osp.join(video_root, media['image_paths'][0])
+            processed_video_path = osp.join(video_root, 'processed_videos', f'{mcq_idx}.jpg')
+            if not os.path.exists(processed_video_path):
+                shutil.copy(original_image_path, processed_video_path)
+            return dict(type='image', value=processed_video_path)
+        elif media['type'] in ['frames']:
+            input_images = [osp.join(video_root, im) for im in media['image_paths']]
+            processed_video_path = osp.join(video_root, 'processed_videos', f'{mcq_idx}.mp4')
+            media['nframes'] = len(input_images) // 2 * 2
+            if not os.path.exists(processed_video_path):
+                # using MoviePy to transform images into mp4
+                image_files = sorted(input_images)
+                image_clip = ImageSequenceClip(image_files, fps=self.frame_fps)
+                image_clip.write_videofile(processed_video_path, codec='libx264')
+                image_clip.close()
+        elif media['type'] in ['video']:
+            original_video_path = osp.join(video_root, media['video_path'])
+            processed_video_path = osp.join(video_root, 'processed_videos', f'{mcq_idx}.mp4')
+            if 'video_start' in media and 'video_end' in media and media['video_start'] is not None and media['video_end'] is not None:  # noqa: E501
+                video_start, video_end = media['video_start'], media['video_end']
+                if not os.path.exists(processed_video_path):
+                    video_clip = VideoFileClip(original_video_path)
+                    clip = video_clip.subclip(video_start, min(video_end, video_clip.duration))
+                    clip.write_videofile(processed_video_path)
+                    clip.close()
+            else:
+                if not os.path.exists(processed_video_path):
+                    shutil.copy(original_video_path, processed_video_path)
+        else:
+            raise ValueError(f"Unsupported media type: {media['type']}")
+
+        return dict(type='video', value=processed_video_path, nframes=media.get('nframes', 8))
+
+    def save_video_into_images(self, media, mcq_idx):
+        bound = None
+        video_root = self.video_root
+
+        if media['type'] in ['frames', 'image']:
+            media_paths = [osp.join(video_root, im) for im in media['image_paths']]
+            save_dir = osp.join(video_root, 'processed_frames', str(mcq_idx))
+            os.makedirs(save_dir, exist_ok=True)
+            input_images = []
+            for media_path in media_paths:
+                img_path = media_path.split('/')[-1]
+                save_image_path = osp.join(save_dir, img_path)
+                shutil.copy(media_path, save_image_path)
+                input_images.append(save_image_path)
+            return input_images
+
+        if 'video_start' in media and 'video_end' in media and media['video_start'] is not None and media['video_end'] is not None:  # noqa: E501
+            bound = (
+                media['video_start'], media['video_end']
+            )
+        video_path = os.path.join(video_root, media['video_path'])
+
+        def read_video(video_path, bound=None, num_segments=16):
+            from decord import VideoReader, cpu
+            vr = VideoReader(video_path, ctx=cpu(0), num_threads=1)
+            max_frame = len(vr) - 1
+            fps = float(vr.get_avg_fps())
+
+            images_group = list()
+            frame_indices = self.get_index(bound, fps, max_frame, first_idx=0, num_segments=num_segments)
+            save_dir = osp.join(video_root, 'processed_frames', str(mcq_idx))
+
+            if osp.exists(save_dir) and len(os.listdir(save_dir)) > 0:
+                return None, frame_indices
+
+            for frame_index in frame_indices:
+                img = Image.fromarray(vr[frame_index].asnumpy())
+                images_group.append(img)
+            torch_imgs = self.transform(images_group)
+            return torch_imgs, frame_indices
+
+        def save_video_frames(imgs, video_root, frame_indices, mcq_idx):
+            save_dir = osp.join(video_root, 'processed_frames', str(mcq_idx))
+            os.makedirs(save_dir, exist_ok=True)
+            frame_paths = [osp.join(save_dir, f'{fidx:07d}.jpg') for fidx in frame_indices]
+
+            flag = np.all([osp.exists(pth) for pth in frame_paths])
+
+            if not flag:
+                block_size = imgs.size(0) // len(frame_indices)
+                split_tensors = torch.split(imgs, block_size)
+                to_pil = transforms.ToPILImage()
+                images = [to_pil(arr) for arr in split_tensors]
+                for im, pth in zip(images, frame_paths):
+                    if not osp.exists(pth):
+                        im.save(pth)
+
+            return frame_paths
+
+        torch_imgs, frame_indices = read_video(video_path, bound, media['nframes'])
+        img_frame_paths = save_video_frames(torch_imgs, video_root, frame_indices, mcq_idx)
+        return img_frame_paths
+
+    def process_text_and_media(self, text, media_list, video_llm, mcq_idx):
+
+        message = []
+        chunks = re.split(r'(<image>|<video>)', text)
+        media_index = 0
+        media_list = eval(media_list)
+
+        placeholder_count = sum(1 for chunk in chunks if chunk in ['<image>', '<video>'])
+        assert placeholder_count == len(media_list), \
+            f"Placeholder count {placeholder_count} does not match media list length {len(media_list)}."
+
+        for chunk in chunks:
+            if chunk in ['<image>', '<video>']:
+                if video_llm:
+                    media_content = self.load_into_video_and_process(media_list[media_index], f'question{mcq_idx}_video{media_index}')  # noqa: E501
+                    message.append(media_content)
+                else:
+                    # Save the video as individual image frames for processing
+                    img_frame_paths = self.save_video_into_images(media_list[media_index], f'question{mcq_idx}_video{media_index}')  # noqa: E501
+                    for im in img_frame_paths:
+                        message.append(dict(type='image', value=im))
+
+                media_index += 1
+            elif chunk.strip():
+                message.append(dict(type='text', value=chunk.strip()))
+
+        return message
+
+    def build_prompt(self, line, video_llm):
+        if isinstance(line, int):
+            mcq_idx = line
+            assert line < len(self)
+            line = self.data.iloc[line]
+            mcq_idx = int(line['index'])
+        if self.skip_EgoExo4D and 'EgoExo4D' in line['medias']:
+            return None
+        text = line['question'] + '\nOptions:\n' + line['options'] + '\n' + line['response_format']
+        message = self.process_text_and_media(text, line['medias'], video_llm, mcq_idx)
+        return message
+
+    # It returns a dictionary
+    @classmethod
+    def evaluate(self, eval_file, **judge_kwargs):
+        from .utils import get_dimension_rating, extract_characters_regex, extract_option
+
+        assert get_file_extension(eval_file) in ['xlsx', 'json', 'tsv'], \
+            'data file should be an supported format (xlsx/json/tsv) file'
+
+        tmp_file = get_intermediate_file_path(eval_file, '_tmp', 'pkl')
+        tgt_file = get_intermediate_file_path(eval_file, '_rating', 'json')
+        score_file = get_intermediate_file_path(eval_file, '_score', 'csv')
+
+        if not osp.exists(score_file):
+            model = judge_kwargs.get('model', 'exact_matching')
+            assert model in ['chatgpt-0125', 'exact_matching', 'gpt-4-0125']
+
+            if model == 'exact_matching':
+                model = None
+            elif gpt_key_set():
+                model = build_judge(**judge_kwargs)
+                if not model.working():
+                    warnings.warn('OPENAI API is not working properly, will use exact matching for evaluation')
+                    warnings.warn(DEBUG_MESSAGE)
+                    model = None
+            else:
+                warnings.warn('OPENAI_API_KEY is not set properly, will use exact matching for evaluation')
+                model = None
+            res = {} if not osp.exists(tmp_file) else load(tmp_file)
+            res = {k: v for k, v in res.items() if FAIL_MSG not in v}
+
+            data = load(eval_file)
+            data_un = data[~pd.isna(data['prediction'])]
+
+            for idx in data['index']:
+                ans = data.loc[data['index'] == idx, 'answer'].values[0]
+                pred = data.loc[data['index'] == idx, 'prediction'].values[0]
+
+                if extract_characters_regex(pred) == '':
+                    extract_pred = extract_option(
+                        model,
+                        data.loc[data['index'] == idx].to_dict(orient='records')[0],
+                        'EgoExoBench_MCQ',
+                    )
+                    data.loc[idx, 'score'] = int(extract_pred == ans)
+                else:
+                    data.loc[idx, 'score'] = int(extract_characters_regex(pred) == ans)
+
+            rejected = [x for x in data['score'] if x == -1]
+
+            print(
+                f'Among {len(data)} questions, failed to obtain prediction for {len(data) - len(data_un)} questions, '
+                f'failed to obtain the score for another {len(rejected)} questions. '
+                f'Those questions will be counted as -1 score in ALL rating, and will not be counted in VALID rating.'
+            )
+
+            dump(data, score_file)
+
+        rating = get_dimension_rating(score_file)
+        dump(rating, tgt_file)
+        return rating
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/page_ocr_metric.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/page_ocr_metric.py
new file mode 100644
index 0000000000000000000000000000000000000000..ba282e347f362b6f5e0c4535dea3e39ff285a4b8
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/page_ocr_metric.py
@@ -0,0 +1,51 @@
+import json
+import argparse
+import nltk
+from nltk.metrics import precision, recall, f_measure
+import numpy as np
+import jieba
+import re
+from nltk.translate import meteor_score
+
+
+def contain_chinese_string(text):
+    chinese_pattern = re.compile(r'[\u4e00-\u9fa5]')
+    return bool(chinese_pattern.search(text))
+
+
+def cal_per_metrics(pred, gt):
+    metrics = {}
+
+    if contain_chinese_string(gt) or contain_chinese_string(pred):
+        reference = jieba.lcut(gt)
+        hypothesis = jieba.lcut(pred)
+    else:
+        reference = gt.split()
+        hypothesis = pred.split()
+
+    metrics["bleu"] = nltk.translate.bleu([reference], hypothesis)
+    metrics["meteor"] = meteor_score.meteor_score([reference], hypothesis)
+
+    reference = set(reference)
+    hypothesis = set(hypothesis)
+    metrics["f_measure"] = f_measure(reference, hypothesis)
+
+    metrics["precision"] = precision(reference, hypothesis)
+    metrics["recall"] = recall(reference, hypothesis)
+    metrics["edit_dist"] = nltk.edit_distance(pred, gt) / max(len(pred), len(gt))
+    return metrics
+
+
+if __name__ == "__main__":
+
+    # Examples for region text recognition and read all text tasks
+    predict_text = "metrics['edit_dist'] = nltk.edit_distance(pred, gt) / max(len(pred), len(gt))"
+    true_text = "metrics = nltk.edit_distance(pred, gt) / max(len(pred), len(gt))"
+
+    scores = cal_per_metrics(predict_text, true_text)
+
+    predict_text = "metrics['edit_dist'] len(gt))"
+    true_text = "metrics = nltk.edit_distance(pred, gt) / max(len(pred), len(gt))"
+
+    scores = cal_per_metrics(predict_text, true_text)
+    print(scores)
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/parallel.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/parallel.py
new file mode 100644
index 0000000000000000000000000000000000000000..97c825899415c9a6498d038406e342b524883f1b
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/parallel.py
@@ -0,0 +1,51 @@
+from tqdm import tqdm
+from concurrent.futures import ProcessPoolExecutor, as_completed
+
+
+def parallel_process(array, function, n_jobs=16, use_kwargs=False, front_num=0):
+    """
+        A parallel version of the map function with a progress bar.
+
+        Args:
+            array (array-like): An array to iterate over.
+            function (function): A python function to apply to the elements of array
+            n_jobs (int, default=16): The number of cores to use
+            use_kwargs (boolean, default=False): Whether to consider the elements of array as dictionaries of
+                keyword arguments to function
+            front_num (int, default=3): The number of iterations to run serially before kicking off the parallel job.
+                Useful for catching bugs
+        Returns:
+            [function(array[0]), function(array[1]), ...]
+    """
+    # We run the first few iterations serially to catch bugs
+    if front_num > 0:
+        front = [function(**a) if use_kwargs else function(a) for a in array[:front_num]]
+    else:
+        front = []
+    # If we set n_jobs to 1, just run a list comprehension. This is useful for benchmarking and debugging.
+    if n_jobs == 1:
+        return front + [function(**a) if use_kwargs else function(a) for a in tqdm(array[front_num:])]
+    # Assemble the workers
+    with ProcessPoolExecutor(max_workers=n_jobs) as pool:
+        # Pass the elements of array into function
+        if use_kwargs:
+            futures = [pool.submit(function, **a) for a in array[front_num:]]
+        else:
+            futures = [pool.submit(function, a) for a in array[front_num:]]
+        kwargs = {
+            'total': len(futures),
+            'unit': 'it',
+            'unit_scale': True,
+            'leave': True
+        }
+        # Print out the progress as tasks complete
+        for f in tqdm(as_completed(futures), **kwargs):
+            pass
+    out = []
+    # Get the results from the futures.
+    for i, future in tqdm(enumerate(futures)):
+        try:
+            out.append(future.result())
+        except Exception as e:
+            out.append(e)
+    return front + out
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/requirements.txt b/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a2f0be3e0fb7055cbb5d59e5a9d202dd91f00a16
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/requirements.txt
@@ -0,0 +1,13 @@
+apted
+distance
+distance
+editdistance
+ipdb
+jieba
+Levenshtein
+lxml
+nltk
+numpy
+Polygon3
+tqdm
+zss
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/spotting_eval/script.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/spotting_eval/script.py
new file mode 100644
index 0000000000000000000000000000000000000000..7939d1001bfe37fd73601a97218451b69c4dceb3
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/spotting_eval/script.py
@@ -0,0 +1,451 @@
+# flake8: noqa
+#!/usr/bin/env python
+# encoding=utf8
+#File: E2E_iou_1_1.py
+#Version: 1.1
+#Version info: changes for Python 3
+#Date: 2019-12-29
+#Description: Evaluation script that computes End to End Recognition. For Text Localization it's used Intersection over Union criteria.
+#Average Precision is also calcuted when 'CONFIDENCES' parameter is True
+#There are 2 modes to determine if a detection is correct or not:
+#with Word Spotting: The detected word must coincide (ingnoring case) to a filtered Ground Truth containing only dictionary words (see include_in_dictionary and include_in_dictionary_transcription functions)
+#without Word Spotting: words must be equal excluding a set of special characters
+
+from collections import namedtuple
+import vlmeval.dataset.utils.Ocrbench_v2.spotting_eval.rrc_evaluation_funcs_1_1 as rrc_evaluation_funcs
+import importlib
+
+def evaluation_imports():
+    """
+    evaluation_imports: Dictionary ( key = module name , value = alias  )  with python modules used in the evaluation.
+    """
+    return {
+            'Polygon':'plg',
+            'numpy':'np'
+            }
+
+def default_evaluation_params():
+    """
+    default_evaluation_params: Default parameters to use for the validation and evaluation.
+    """
+    return {
+            'IOU_CONSTRAINT' :0.5,
+            'AREA_PRECISION_CONSTRAINT' :0.5,
+            'WORD_SPOTTING' :False,
+            'MIN_LENGTH_CARE_WORD' :3,
+            'GT_SAMPLE_NAME_2_ID':'gt_img_([0-9]+).txt',
+            'DET_SAMPLE_NAME_2_ID':'res_img_([0-9]+).txt',
+            'LTRB':False, #LTRB:2points(left,top,right,bottom) or 4 points(x1,y1,x2,y2,x3,y3,x4,y4)
+            'CRLF':False, # Lines are delimited by Windows CRLF format
+            'CONFIDENCES':False, #Detections must include confidence value. AP will be calculated,
+            'SPECIAL_CHARACTERS':'!?.:,*"()·[]/\'',
+            'ONLY_REMOVE_FIRST_LAST_CHARACTER' : True
+        }
+
+def validate_data(gtFilePath, submFilePath, evaluationParams):
+    """
+    Method validate_data: validates that all files in the results folder are correct (have the correct name contents).
+                            Validates also that there are no missing files in the folder.
+                            If some error detected, the method raises the error
+    """
+    gt = rrc_evaluation_funcs.load_zip_file(gtFilePath, evaluationParams['GT_SAMPLE_NAME_2_ID'])
+
+    subm = rrc_evaluation_funcs.load_zip_file(submFilePath, evaluationParams['DET_SAMPLE_NAME_2_ID'], True)
+
+    #Validate format of GroundTruth
+    for k in gt:
+        rrc_evaluation_funcs.validate_lines_in_file(k,gt[k],evaluationParams['CRLF'],evaluationParams['LTRB'],True)
+
+    #Validate format of results
+    for k in subm:
+        if (k in gt) == False :
+            raise Exception("The sample %s not present in GT" %k)
+
+        rrc_evaluation_funcs.validate_lines_in_file(k,subm[k],evaluationParams['CRLF'],evaluationParams['LTRB'],True,evaluationParams['CONFIDENCES'])
+
+
+def evaluate_method(gtFilePath, submFilePath, evaluationParams):
+    """
+    Method evaluate_method: evaluate method and returns the results
+        Results. Dictionary with the following values:
+        - method (required)  Global method metrics. Ex: { 'Precision':0.8,'Recall':0.9 }
+        - samples (optional) Per sample metrics. Ex: {'sample1' : { 'Precision':0.8,'Recall':0.9 } , 'sample2' : { 'Precision':0.8,'Recall':0.9 }
+    """
+    for module,alias in evaluation_imports().items():
+        globals()[alias] = importlib.import_module(module)
+
+    def polygon_from_points(points,correctOffset=False):
+        """
+        Returns a Polygon object to use with the Polygon2 class from a list of 8 points: x1,y1,x2,y2,x3,y3,x4,y4
+        """
+
+        if correctOffset: #this will substract 1 from the coordinates that correspond to the xmax and ymax
+            points[2] -= 1
+            points[4] -= 1
+            points[5] -= 1
+            points[7] -= 1
+
+        resBoxes=np.empty([1,8],dtype='int32')
+        resBoxes[0,0]=int(points[0])
+        resBoxes[0,4]=int(points[1])
+        resBoxes[0,1]=int(points[2])
+        resBoxes[0,5]=int(points[3])
+        resBoxes[0,2]=int(points[4])
+        resBoxes[0,6]=int(points[5])
+        resBoxes[0,3]=int(points[6])
+        resBoxes[0,7]=int(points[7])
+        pointMat = resBoxes[0].reshape([2,4]).T
+        return plg.Polygon( pointMat)
+
+    def rectangle_to_polygon(rect):
+        resBoxes=np.empty([1,8],dtype='int32')
+        resBoxes[0,0]=int(rect.xmin)
+        resBoxes[0,4]=int(rect.ymax)
+        resBoxes[0,1]=int(rect.xmin)
+        resBoxes[0,5]=int(rect.ymin)
+        resBoxes[0,2]=int(rect.xmax)
+        resBoxes[0,6]=int(rect.ymin)
+        resBoxes[0,3]=int(rect.xmax)
+        resBoxes[0,7]=int(rect.ymax)
+
+        pointMat = resBoxes[0].reshape([2,4]).T
+
+        return plg.Polygon( pointMat)
+
+    def rectangle_to_points(rect):
+        points = [int(rect.xmin), int(rect.ymax), int(rect.xmax), int(rect.ymax), int(rect.xmax), int(rect.ymin), int(rect.xmin), int(rect.ymin)]
+        return points
+
+    def get_union(pD,pG):
+        areaA = pD.area();
+        areaB = pG.area();
+        return areaA + areaB - get_intersection(pD, pG);
+
+    def get_intersection_over_union(pD,pG):
+        try:
+            return get_intersection(pD, pG) / get_union(pD, pG);
+        except:
+            return 0
+
+    def get_intersection(pD,pG):
+        pInt = pD & pG
+        if len(pInt) == 0:
+            return 0
+        return pInt.area()
+
+    def compute_ap(confList, matchList,numGtCare):
+        correct = 0
+        AP = 0
+        if len(confList)>0:
+            confList = np.array(confList)
+            matchList = np.array(matchList)
+            sorted_ind = np.argsort(-confList)
+            confList = confList[sorted_ind]
+            matchList = matchList[sorted_ind]
+            for n in range(len(confList)):
+                match = matchList[n]
+                if match:
+                    correct += 1
+                    AP += float(correct)/(n + 1)
+
+            if numGtCare>0:
+                AP /= numGtCare
+
+        return AP
+
+    def transcription_match(transGt,transDet,specialCharacters='!?.:,*"()·[]/\'',onlyRemoveFirstLastCharacterGT=True):
+
+        if onlyRemoveFirstLastCharacterGT:
+            #special characters in GT are allowed only at initial or final position
+            if (transGt==transDet):
+                return True
+
+            if specialCharacters.find(transGt[0])>-1:
+                if transGt[1:]==transDet:
+                    return True
+
+            if specialCharacters.find(transGt[-1])>-1:
+                if transGt[0:len(transGt)-1]==transDet:
+                    return True
+
+            if specialCharacters.find(transGt[0])>-1 and specialCharacters.find(transGt[-1])>-1:
+                if transGt[1:len(transGt)-1]==transDet:
+                    return True
+            return False
+        else:
+            #Special characters are removed from the begining and the end of both Detection and GroundTruth
+            while len(transGt)>0 and specialCharacters.find(transGt[0])>-1:
+                transGt = transGt[1:]
+
+            while len(transDet)>0 and specialCharacters.find(transDet[0])>-1:
+                transDet = transDet[1:]
+
+            while len(transGt)>0 and specialCharacters.find(transGt[-1])>-1 :
+                transGt = transGt[0:len(transGt)-1]
+
+            while len(transDet)>0 and specialCharacters.find(transDet[-1])>-1:
+                transDet = transDet[0:len(transDet)-1]
+
+            return transGt == transDet
+
+
+    def include_in_dictionary(transcription):
+        """
+        Function used in Word Spotting that finds if the Ground Truth transcription meets the rules to enter into the dictionary. If not, the transcription will be cared as don't care
+        """
+        #special case 's at final
+        if transcription[len(transcription)-2:]=="'s" or transcription[len(transcription)-2:]=="'S":
+            transcription = transcription[0:len(transcription)-2]
+
+        #hypens at init or final of the word
+        transcription = transcription.strip('-');
+
+        specialCharacters = "'!?.:,*\"()·[]/";
+        for character in specialCharacters:
+            transcription = transcription.replace(character,' ')
+
+        transcription = transcription.strip()
+
+        if len(transcription) != len(transcription.replace(" ","")) :
+            return False;
+
+        if len(transcription) < evaluationParams['MIN_LENGTH_CARE_WORD']:
+            return False;
+
+        notAllowed = "×÷·";
+
+        range1 = [ ord(u'a'), ord(u'z') ]
+        range2 = [ ord(u'A'), ord(u'Z') ]
+        range3 = [ ord(u'À'), ord(u'ƿ') ]
+        range4 = [ ord(u'DŽ'), ord(u'ɿ') ]
+        range5 = [ ord(u'Ά'), ord(u'Ͽ') ]
+        range6 = [ ord(u'-'), ord(u'-') ]
+
+        for char in transcription :
+            charCode = ord(char)
+            if(notAllowed.find(char) != -1):
+                return False
+
+            valid = ( charCode>=range1[0] and charCode<=range1[1] ) or ( charCode>=range2[0] and charCode<=range2[1] ) or ( charCode>=range3[0] and charCode<=range3[1] ) or ( charCode>=range4[0] and charCode<=range4[1] ) or ( charCode>=range5[0] and charCode<=range5[1] ) or ( charCode>=range6[0] and charCode<=range6[1] )
+            if valid == False:
+                return False
+
+        return True
+
+    def include_in_dictionary_transcription(transcription):
+        """
+        Function applied to the Ground Truth transcriptions used in Word Spotting. It removes special characters or terminations
+        """
+        #special case 's at final
+        if transcription[len(transcription)-2:]=="'s" or transcription[len(transcription)-2:]=="'S":
+            transcription = transcription[0:len(transcription)-2]
+
+        #hypens at init or final of the word
+        transcription = transcription.strip('-');
+
+        specialCharacters = "'!?.:,*\"()·[]/";
+        for character in specialCharacters:
+            transcription = transcription.replace(character,' ')
+
+        transcription = transcription.strip()
+
+        return transcription
+
+    perSampleMetrics = {}
+
+    matchedSum = 0
+
+    Rectangle = namedtuple('Rectangle', 'xmin ymin xmax ymax')
+
+    gt = rrc_evaluation_funcs.load_zip_file(gtFilePath,evaluationParams['GT_SAMPLE_NAME_2_ID'])
+    subm = rrc_evaluation_funcs.load_zip_file(submFilePath,evaluationParams['DET_SAMPLE_NAME_2_ID'],True)
+
+    numGlobalCareGt = 0;
+    numGlobalCareDet = 0;
+
+    arrGlobalConfidences = [];
+    arrGlobalMatches = [];
+
+    for resFile in gt:
+
+        gtFile = rrc_evaluation_funcs.decode_utf8(gt[resFile])
+        if (gtFile is None) :
+            raise Exception("The file %s is not UTF-8" %resFile)
+
+        recall = 0
+        precision = 0
+        hmean = 0
+        detCorrect = 0
+        iouMat = np.empty([1,1])
+        gtPols = []
+        detPols = []
+        gtTrans = []
+        detTrans = []
+        gtPolPoints = []
+        detPolPoints = []
+        gtDontCarePolsNum = [] #Array of Ground Truth Polygons' keys marked as don't Care
+        detDontCarePolsNum = [] #Array of Detected Polygons' matched with a don't Care GT
+        detMatchedNums = []
+        pairs = []
+
+        arrSampleConfidences = [];
+        arrSampleMatch = [];
+        sampleAP = 0;
+
+        evaluationLog = ""
+
+        pointsList,_,transcriptionsList = rrc_evaluation_funcs.get_tl_line_values_from_file_contents(gtFile,evaluationParams['CRLF'],evaluationParams['LTRB'],True,False)
+        for n in range(len(pointsList)):
+            points = pointsList[n]
+            transcription = transcriptionsList[n]
+            dontCare = transcription == "###"
+            if evaluationParams['LTRB']:
+                gtRect = Rectangle(*points)
+                gtPol = rectangle_to_polygon(gtRect)
+            else:
+                gtPol = polygon_from_points(points)
+            gtPols.append(gtPol)
+            gtPolPoints.append(points)
+
+            #On word spotting we will filter some transcriptions with special characters
+            if evaluationParams['WORD_SPOTTING'] :
+                if dontCare == False :
+                    if include_in_dictionary(transcription) == False :
+                        dontCare = True
+                    else:
+                        transcription = include_in_dictionary_transcription(transcription)
+
+            gtTrans.append(transcription)
+            if dontCare:
+                gtDontCarePolsNum.append( len(gtPols)-1 )
+
+        evaluationLog += "GT polygons: " + str(len(gtPols)) + (" (" + str(len(gtDontCarePolsNum)) + " don't care)\n" if len(gtDontCarePolsNum)>0 else "\n")
+
+        if resFile in subm:
+
+            detFile = rrc_evaluation_funcs.decode_utf8(subm[resFile])
+
+            pointsList,confidencesList,transcriptionsList = rrc_evaluation_funcs.get_tl_line_values_from_file_contents(detFile,evaluationParams['CRLF'],evaluationParams['LTRB'],True,evaluationParams['CONFIDENCES'])
+
+            for n in range(len(pointsList)):
+                points = pointsList[n]
+                transcription = transcriptionsList[n]
+
+                if evaluationParams['LTRB']:
+                    detRect = Rectangle(*points)
+                    detPol = rectangle_to_polygon(detRect)
+                else:
+                    detPol = polygon_from_points(points)
+                detPols.append(detPol)
+                detPolPoints.append(points)
+                detTrans.append(transcription)
+
+                if len(gtDontCarePolsNum)>0 :
+                    for dontCarePol in gtDontCarePolsNum:
+                        dontCarePol = gtPols[dontCarePol]
+                        intersected_area = get_intersection(dontCarePol,detPol)
+                        pdDimensions = detPol.area()
+                        precision = 0 if pdDimensions == 0 else intersected_area / pdDimensions
+                        if (precision > evaluationParams['AREA_PRECISION_CONSTRAINT'] ):
+                            detDontCarePolsNum.append( len(detPols)-1 )
+                            break
+
+            evaluationLog += "DET polygons: " + str(len(detPols)) + (" (" + str(len(detDontCarePolsNum)) + " don't care)\n" if len(detDontCarePolsNum)>0 else "\n")
+
+            if len(gtPols)>0 and len(detPols)>0:
+                #Calculate IoU and precision matrixs
+                outputShape=[len(gtPols),len(detPols)]
+                iouMat = np.empty(outputShape)
+                gtRectMat = np.zeros(len(gtPols),np.int8)
+                detRectMat = np.zeros(len(detPols),np.int8)
+                for gtNum in range(len(gtPols)):
+                    for detNum in range(len(detPols)):
+                        pG = gtPols[gtNum]
+                        pD = detPols[detNum]
+                        iouMat[gtNum,detNum] = get_intersection_over_union(pD,pG)
+
+                for gtNum in range(len(gtPols)):
+                    for detNum in range(len(detPols)):
+                        if gtRectMat[gtNum] == 0 and detRectMat[detNum] == 0 and gtNum not in gtDontCarePolsNum and detNum not in detDontCarePolsNum :
+                            if iouMat[gtNum,detNum]>evaluationParams['IOU_CONSTRAINT']:
+                                gtRectMat[gtNum] = 1
+                                detRectMat[detNum] = 1
+                                #detection matched only if transcription is equal
+                                if evaluationParams['WORD_SPOTTING']:
+                                    correct = gtTrans[gtNum].upper() == detTrans[detNum].upper()
+                                else:
+                                    correct = transcription_match(gtTrans[gtNum].upper(),detTrans[detNum].upper(),evaluationParams['SPECIAL_CHARACTERS'],evaluationParams['ONLY_REMOVE_FIRST_LAST_CHARACTER'])==True
+                                detCorrect += (1 if correct else 0)
+                                if correct:
+                                    detMatchedNums.append(detNum)
+                                pairs.append({'gt':gtNum,'det':detNum,'correct':correct})
+                                evaluationLog += "Match GT #" + str(gtNum) + " with Det #" + str(detNum) + " trans. correct: " + str(correct) + "\n"
+
+            if evaluationParams['CONFIDENCES']:
+                for detNum in range(len(detPols)):
+                    if detNum not in detDontCarePolsNum :
+                        #we exclude the don't care detections
+                        match = detNum in detMatchedNums
+
+                        arrSampleConfidences.append(confidencesList[detNum])
+                        arrSampleMatch.append(match)
+
+                        arrGlobalConfidences.append(confidencesList[detNum]);
+                        arrGlobalMatches.append(match);
+
+        numGtCare = (len(gtPols) - len(gtDontCarePolsNum))
+        numDetCare = (len(detPols) - len(detDontCarePolsNum))
+        if numGtCare == 0:
+            recall = float(1)
+            precision = float(0) if numDetCare >0 else float(1)
+            sampleAP = precision
+        else:
+            recall = float(detCorrect) / numGtCare
+            precision = 0 if numDetCare==0 else float(detCorrect) / numDetCare
+            if evaluationParams['CONFIDENCES']:
+                sampleAP = compute_ap(arrSampleConfidences, arrSampleMatch, numGtCare )
+
+        hmean = 0 if (precision + recall)==0 else 2.0 * precision * recall / (precision + recall)
+
+        matchedSum += detCorrect
+        numGlobalCareGt += numGtCare
+        numGlobalCareDet += numDetCare
+
+        perSampleMetrics[resFile] = {
+                                        'precision':precision,
+                                        'recall':recall,
+                                        'hmean':hmean,
+                                        'pairs':pairs,
+                                        'AP':sampleAP,
+                                        'iouMat':[] if len(detPols)>100 else iouMat.tolist(),
+                                        'gtPolPoints':gtPolPoints,
+                                        'detPolPoints':detPolPoints,
+                                        'gtTrans':gtTrans,
+                                        'detTrans':detTrans,
+                                        'gtDontCare':gtDontCarePolsNum,
+                                        'detDontCare':detDontCarePolsNum,
+                                        'evaluationParams': evaluationParams,
+                                        'evaluationLog': evaluationLog
+                                    }
+
+    # Compute AP
+    AP = 0
+    if evaluationParams['CONFIDENCES']:
+        AP = compute_ap(arrGlobalConfidences, arrGlobalMatches, numGlobalCareGt)
+
+    methodRecall = 0 if numGlobalCareGt == 0 else float(matchedSum)/numGlobalCareGt
+    methodPrecision = 0 if numGlobalCareDet == 0 else float(matchedSum)/numGlobalCareDet
+    methodHmean = 0 if methodRecall + methodPrecision==0 else 2* methodRecall * methodPrecision / (methodRecall + methodPrecision)
+
+    methodMetrics = {'precision':methodPrecision, 'recall':methodRecall,'hmean': methodHmean, 'AP': AP  }
+
+    resDict = {'calculated':True,'Message':'','method': methodMetrics,'per_sample': perSampleMetrics}
+
+
+    return resDict
+
+
+
+if __name__=='__main__':
+
+    rrc_evaluation_funcs.main_evaluation(None,default_evaluation_params,validate_data,evaluate_method)
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/spotting_metric.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/spotting_metric.py
new file mode 100644
index 0000000000000000000000000000000000000000..2ca4567c332e44fd46a3ac202a47a7eb94170c4a
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/spotting_metric.py
@@ -0,0 +1,185 @@
+# flake8: noqa
+import re
+import os
+import ast
+import ipdb
+import shutil
+import zipfile
+import subprocess
+import vlmeval.dataset.utils.Ocrbench_v2.spotting_eval.rrc_evaluation_funcs_1_1 as rrc_evaluation_funcs
+from vlmeval.dataset.utils.Ocrbench_v2.spotting_eval.script import default_evaluation_params,validate_data,evaluate_method
+
+
+def extract_bounding_boxes_robust(predict_str):
+    """
+    Extract coordinates and text content from the given prediction string,
+    handling potential format issues.
+
+    Args:
+    predict_str (str): Model prediction output as a string.
+
+    Returns:
+    list: Extracted data in the format [[x1, y1, x2, y2, text_content], ...].
+          Returns None if no valid data is extracted.
+    """
+    results = []
+    seen = set()
+
+    # try parsing with ast.literal_eval
+    try:
+        data = ast.literal_eval(predict_str)
+    except Exception:
+        data = None
+
+    if data is not None:
+        if isinstance(data, (list, tuple)):
+            for item in data:
+                if isinstance(item, (list, tuple)) and len(item) >= 5:
+                    x1_str, y1_str, x2_str, y2_str = item[:4]
+                    text_content = item[4]
+
+                    x1_str = str(x1_str).strip()
+                    y1_str = str(y1_str).strip()
+                    x2_str = str(x2_str).strip()
+                    y2_str = str(y2_str).strip()
+                    text_content = str(text_content).replace("\n", "").strip().strip('"').strip("'")
+
+                    try:
+                        x1 = int(x1_str)
+                        y1 = int(y1_str)
+                        x2 = int(x2_str)
+                        y2 = int(y2_str)
+
+                        if not (0 <= x1 <= 1000 and 0 <= y1 <= 1000 and 0 <= x2 <= 1000 and 0 <= y2 <= 1000):
+                            continue
+
+                        key = (x1, y1, x2, y2, text_content)
+                        if key in seen:
+                            continue
+
+                        seen.add(key)
+                        results.append([x1, y1, x2, y2, text_content])
+                    except ValueError:
+                        continue
+    else:
+        # try parsing with regular expression
+
+        list_content = predict_str
+        items = re.findall(r'[\[\(]\s*([^\[\]\(\)]*?)\s*[\]\)]', list_content)
+
+        if not items:
+            return None
+
+        for item in items:
+            parts = item.split(',', 4)
+            if len(parts) < 5:
+                continue
+
+            x1_str, y1_str, x2_str, y2_str, text_content = parts
+
+            x1_str = x1_str.strip()
+            y1_str = y1_str.strip()
+            x2_str = x2_str.strip()
+            y2_str = y2_str.strip()
+            text_content = text_content.replace("\n", "").strip().strip('"').strip("'")
+
+            try:
+                x1 = int(x1_str)
+                y1 = int(y1_str)
+                x2 = int(x2_str)
+                y2 = int(y2_str)
+
+                if not (0 <= x1 <= 1000 and 0 <= y1 <= 1000 and 0 <= x2 <= 1000 and 0 <= y2 <= 1000):
+                    continue
+
+                key = (x1, y1, x2, y2, text_content)
+                if key in seen:
+                    continue
+
+                seen.add(key)
+                results.append([x1, y1, x2, y2, text_content])
+            except ValueError:
+                continue
+
+    if not results:
+        return None
+
+    return results
+
+
+def zip_folder(source_folder, destination_zip):
+    abs_source = os.path.abspath(source_folder)
+    abs_destination = os.path.abspath(destination_zip)
+
+    with zipfile.ZipFile(abs_destination, 'w', zipfile.ZIP_DEFLATED) as zf:
+        for root, _, files in os.walk(abs_source):
+            for file in files:
+                abs_file_path = os.path.join(root, file)
+
+                relative_path = os.path.relpath(abs_file_path, abs_source)
+                zf.write(abs_file_path, relative_path)
+
+
+def spotting_evaluation(prediction_list, img_metas):
+    score = 0
+
+    submit_path = ".vlmeval/dataset/utils/Ocrbench_v2/spotting_eval/submit"
+    gt_path = ".vlmeval/dataset/utils/Ocrbench_v2/spotting_eval/gt"
+    submit_zip_path = ".vlmeval/dataset/utils/Ocrbench_v2/spotting_eval/submit.zip"
+    gt_zip_path = ".vlmeval/dataset/utils/Ocrbench_v2/spotting_eval/gt.zip"
+    for file_path in [submit_path, gt_path, submit_zip_path, gt_zip_path]:
+        if "zip" in file_path:
+            if os.path.exists(file_path):
+                os.remove(file_path)
+        else:
+            if os.path.exists(file_path):
+                shutil.rmtree(file_path)
+            os.makedirs(file_path)
+
+    res_submit_list = []
+    for item in prediction_list:
+        if len(item) != 5:
+            ipdb.set_trace()
+        x1, y1, x2, y2, rec = item
+        if x1 >= x2 or y1 >= y2:
+            continue
+
+        res_submit_list.append(",".join([str(x1),str(y1),str(x2),str(y1),str(x2),str(y2),str(x1),str(y2),rec]))
+
+    res_gt_list = []
+    for bbox, rec in zip(img_metas["bbox"], img_metas["content"]):
+        x_coords = bbox[0::2]
+        y_coords = bbox[1::2]
+
+        x1, y1 = min(x_coords), min(y_coords)
+        x2, y2 = max(x_coords), max(y_coords)
+
+        res_gt_list.append(",".join([str(x1),str(y1),str(x2),str(y1),str(x2),str(y2),str(x1),str(y2),rec]))
+
+    if len(res_submit_list) == 0 or len(res_gt_list) == 0:
+        return 0
+
+    with open(os.path.join(submit_path,"res_img_0.txt"), "w") as f:
+        for item in res_submit_list[:-1]:
+            f.write(item + "\n")
+        f.write(res_submit_list[-1])
+
+    with open(os.path.join(gt_path,"gt_img_0.txt"), "w") as f:
+        for item in res_gt_list[:-1]:
+            f.write(item + "\n")
+        f.write(res_gt_list[-1])
+
+    zip_folder(submit_path, submit_zip_path)
+    zip_folder(gt_path, gt_zip_path)
+
+    command = {
+        'g': gt_zip_path,
+        's': submit_zip_path,
+        'o': './',
+        'p': '{"IOU_CONSTRAINT":0.5}'
+    }
+
+    # run rrc_evaluation_funcs
+    result = rrc_evaluation_funcs.main_evaluation(command,default_evaluation_params,validate_data,evaluate_method)
+    score = result["method"]["hmean"]
+    return score
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/vqa_metric.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/vqa_metric.py
new file mode 100644
index 0000000000000000000000000000000000000000..deff0f9d6bb454a2372b6e1879d54d16e37868e6
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/vqa_metric.py
@@ -0,0 +1,282 @@
+import re
+import os
+import json
+import ipdb
+import math
+import numpy as np
+
+
+def levenshtein_distance(s1, s2):
+    if len(s1) > len(s2):
+        s1, s2 = s2, s1
+
+    distances = range(len(s1) + 1)
+    for i2, c2 in enumerate(s2):
+        distances_ = [i2 + 1]
+        for i1, c1 in enumerate(s1):
+            if c1 == c2:
+                distances_.append(distances[i1])
+            else:
+                distances_.append(1 + min((distances[i1], distances[i1 + 1], distances_[-1])))
+        distances = distances_
+    return distances[-1]
+
+
+def vqa_evaluation(predict, answers):
+    score = 0
+    if isinstance(answers, list):
+        for j in range(len(answers)):
+            if isinstance(answers[j], (int, float)):
+                answers[j] = str(answers[j])
+            try:
+                answer = answers[j].lower().strip().replace("\n"," ")
+            except:
+                ipdb.set_trace()
+            if isinstance(predict, (int, float)):
+                predict = str(predict)
+            predict = predict.lower().strip().replace("\n"," ")
+            if len(answer.split()) < 5:
+                if answer in predict:
+                    score = 1
+            else:
+                dist = levenshtein_distance(predict, answer)
+                length = max(len(predict), len(answer))
+                ANLS_value = 0.0 if length == 0 else float(dist) / float(length)
+                ANLS_value = 1 - ANLS_value
+
+                if ANLS_value >= 0.5 and ANLS_value > score:
+                    score = ANLS_value
+
+    else:
+        answers = answers.lower().strip().replace("\n"," ")
+        predict = predict.lower().strip().replace("\n"," ")
+        if len(answers.split()) < 5:
+            if answers in predict:
+                score = 1
+            else:
+                dist = levenshtein_distance(predict, answers)
+                length = max(len(predict), len(answers))
+                ANLS_value = 0.0 if length == 0 else float(dist) / float(length)
+                ANLS_value = 1 - ANLS_value
+
+                if ANLS_value >= 0.5 and ANLS_value > score:
+                    score = ANLS_value
+
+    return score
+
+
+def cn_vqa_evaluation(predict, answers):
+    score = 0
+    if isinstance(answers, list):
+        for j in range(len(answers)):
+            if isinstance(answers[j], (int, float)):
+                answers[j] = str(answers[j])
+            try:
+                answer = answers[j].lower().strip().replace("\n"," ").replace(" ", "")
+            except:
+                ipdb.set_trace()
+            if isinstance(predict, (int, float)):
+                predict = str(predict)
+            predict = predict.lower().strip().replace("\n"," ").replace(" ", "")
+            if len(answer.split(",")) < 4:
+                if answer in predict:
+                    score = 1
+            else:
+                dist = levenshtein_distance(predict, answer)
+                length = max(len(predict), len(answer))
+                ANLS_value = 0.0 if length == 0 else float(dist) / float(length)
+                ANLS_value = 1 - ANLS_value
+
+                if ANLS_value >= 0.5 and ANLS_value > score:
+                    score = ANLS_value
+
+    else:
+        answers = answers.lower().strip().replace("\n"," ").replace(" ", "")
+        predict = predict.lower().strip().replace("\n"," ").replace(" ", "")
+        if len(answer.split(",")) < 4:
+            if answers in predict:
+                score = 1
+            else:
+                dist = levenshtein_distance(predict, answers)
+                length = max(len(predict), len(answers))
+                ANLS_value = 0.0 if length == 0 else float(dist) / float(length)
+                ANLS_value = 1 - ANLS_value
+
+                if ANLS_value >= 0.5 and ANLS_value > score:
+                    score = ANLS_value
+
+    return score
+
+
+def vqa_evaluation_case_sensitive(predict, answers):
+    score = 0
+    if isinstance(answers, list):
+        for j in range(len(answers)):
+            if isinstance(answers[j], (int, float)):
+                answers[j] = str(answers[j])
+            try:
+                answer = answers[j].strip().replace("\n"," ")
+            except:
+                ipdb.set_trace()
+            predict = predict.strip().replace("\n"," ")
+            if len(answer.split()) < 5:
+                if answer in predict:
+                    score = 1
+            else:
+                dist = levenshtein_distance(predict, answer)
+                length = max(len(predict), len(answer))
+                ANLS_value = 0.0 if length == 0 else float(dist) / float(length)
+                ANLS_value = 1 - ANLS_value
+
+                if ANLS_value >= 0.5 and ANLS_value > score:
+                    score = ANLS_value
+
+    else:
+        answers = answers.strip().replace("\n"," ")
+        predict = predict.strip().replace("\n"," ")
+        if len(answers.split()) < 5:
+            if answers in predict:
+                score = 1
+            else:
+                dist = levenshtein_distance(predict, answers)
+                length = max(len(predict), len(answers))
+                ANLS_value = 0.0 if length == 0 else float(dist) / float(length)
+                ANLS_value = 1 - ANLS_value
+
+                if ANLS_value >= 0.5 and ANLS_value > score:
+                    score = ANLS_value
+
+    return score
+
+
+def extract_first_number(string):
+    match = re.search(r'\d+', string)
+    if match:
+        return int(match.group())
+    return None
+
+
+def counting_evaluation(predict, answers, eval_method):
+    score = 0
+
+    if isinstance(predict, str):
+        predict_processed = predict.lower().strip().replace("\n", " ")
+    elif math.isnan(predict):
+        return 0
+    else:
+        predict_processed = int(predict)
+    if isinstance(answers, list):
+        temp_score = 0
+        for j in range(len(answers)):
+            if isinstance(answers[j], (int, float)):
+                answers[j] = str(answers[j])
+            answer = answers[j].lower().strip().replace("\n"," ")
+            if eval_method == "exact match":
+                if answer in predict:
+                    score = 1
+                else:
+                    score = 0
+            elif eval_method == "regression":
+                predict_number = extract_first_number(predict_processed)
+                if predict_number:
+
+                    answer = int(answer)
+
+                    if predict_number <= 0 or predict_number >= 2 * answer:
+                        score = 0
+                    else:
+                        iou = 1 - abs(predict_number - answer) / answer
+                        if iou > 0.5:
+                            score = iou
+                        else:
+                            score = 0
+                else:
+                    score = 0
+            if score > temp_score:
+                temp_score = score
+        score = temp_score
+
+    else:
+        answers = answers.lower().strip().replace("\n"," ")
+        predict = predict.lower().strip().replace("\n"," ")
+        if eval_method == "exact match":
+            if answer in predict:
+                score = 1
+            else:
+                score = 0
+        elif eval_method == "regression":
+            predict = extract_first_number(predict)
+            if predict:
+                answer = int(answer)
+                if predict <= 0 or predict >= 2 * answer:
+                    score = 0
+                else:
+                    iou = 1 - abs(predict - answer) / answer
+
+                    if iou > 0.5:
+                        score = iou
+                    else:
+                        score = 0
+            else:
+                score = 0
+    return score
+
+
+def math_expression_evaluation(predict, answers):
+    score = 0
+    if isinstance(answers, list):
+        for j in range(len(answers)):
+            answer = answers[j].strip().replace("\n"," ").replace(" ","")
+            predict = predict.strip().replace("\n"," ").replace(" ","")
+            if answer in predict:
+                score = 1
+    else:
+        answers = answers.strip().replace("\n"," ").replace(" ","")
+        predict = predict.strip().replace("\n"," ").replace(" ","")
+        if answers in predict:
+            score = 1
+    return score
+
+
+def remove_text_tags(latex_str):
+    """
+    Removes LaTeX \text{...} tags while keeping their content.
+
+    :param latex_str: A string containing LaTeX expressions
+    :return: The processed string with \text{...} tags removed
+    """
+
+    pattern = r'\\text\{([^{}]*)\}'
+
+    processed_str = re.sub(pattern, r'\1', latex_str)
+
+    return processed_str
+
+
+def cn_math_expression_evaluation(predict, answers):
+    score = 0
+
+    assert len(answers) == 1
+    answers = [remove_text_tags(answers[0])]
+    predict = remove_text_tags(predict)
+
+    if isinstance(answers, list):
+        for j in range(len(answers)):
+            answer = answers[j].strip().replace("\n"," ").replace(" ","")
+            predict = predict.strip().replace("\n"," ").replace(" ","")
+            if answer in predict:
+                score = 1
+    else:
+        answers = answers.strip().replace("\n"," ").replace(" ","")
+        predict = predict.strip().replace("\n"," ").replace(" ","")
+        if answers in predict:
+            score = 1
+    return score
+
+
+if __name__ == "__main__":
+    test_predict = "apple pie and banana"
+    test_answers = ["apple", "banana pie", "apple pie and orange"]
+
+    vqa_score = vqa_evaluation(test_predict, test_answers)
+    print(f"VQA evaluation score for predict '{test_predict}' and answers {test_answers}: {vqa_score}")
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/cgbench.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/cgbench.py
new file mode 100644
index 0000000000000000000000000000000000000000..55ba6afc25b018477462bbf6167b924feb474571
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/cgbench.py
@@ -0,0 +1,620 @@
+from ...smp import *
+from .multiple_choice import extract_answer_from_item
+import pandas as pd
+import numpy as np
+import re
+import zipfile
+
+FAIL_MSG = "Failed to obtain answer via API."
+
+frame_tmpl = "frame-{}-of-{}.jpg"
+
+sys_prompt_open_eval_step_1 = (
+    "You will be provided with a question, a model's prediction, and the ground "
+    "truth answer for this question.\n"
+    "Your task is to judge whether the model's prediction is correct based on the "
+    "meaning of the two texts.\n"
+    "In most cases, this can be done by determining if the meaning of the model's "
+    "prediction is consistent with, or contains, the ground truth answer. However, "
+    "in some cases where the two texts differ, it may represent different "
+    "descriptions of the same visual scene, in which case visual information is "
+    "needed for further judgment.\n"
+    "Therefore, I hope you:\n"
+    "- Output 0, if the model's prediction and the ground truth answer are neither "
+    "consistent nor related by inclusion, with fundamentally different meanings.\n"
+    "- Output 1, if the meaning of the model's prediction and the ground truth "
+    "answer is consistent, or if the model's prediction meaningfully contains the "
+    "ground truth answer.\n"
+    "- Output 2, if the model's prediction and ground truth are not consistent or "
+    "inclusive, but may be different descriptions of the same visual scene, "
+    "requiring visual information for further judgment.\n"
+    "Only output the answer in the following format:\n\n"
+    '```json\n{"result": choice}\n```\n\n'
+    "The choice is either 0, 1, or 2 as specified above."
+)
+
+sys_prompt_open_eval_step_2 = (
+    "You will be provided with a question, a model's prediction, and the sampling "
+    "frames of the clue intervals related to this question.\n"
+    "Your task is to determine whether the model has answered the question "
+    "correctly based on the visual information provided.\n"
+    "Therefore, I hope you:\n"
+    "- Output 0, if the model's prediction does not correctly answer the question.\n"
+    "- Output 1, if the model's prediction correctly answers the question.\n"
+    "Only output the answer in the following format without output extra "
+    "explanation:\n\n"
+    '```json\n{"result": choice}\n```\n\n'
+    "The choice is either 0 or 1 as specified above."
+)
+
+FAIL_MSG = "Failed to obtain answer via API."
+
+# '10-20', '20-30', '30-40', '40-50', '50-60'
+DURATIONS = ["0 ~ 10", "10 ~ 20", "20 ~ 30", "30 ~ 40", "40 ~ 50", "50 ~ 60", "60+"]
+
+DOMAINS = [
+    "Life Record",
+    "Music & TV show",
+    "Instruction & Knowledge",
+    "Driving",
+    "Embodied Expert",
+    "Humor/funny",
+    "Electonic/Social Gaming",
+    "Security & Health",
+    "Sports & Exercise",
+    "Special Scenes",
+    "Art & Culture",
+    "GUI",
+    "News",
+    "Animal & Pet",
+]
+
+SUB_CATEGORIES = [
+    "Time Cognition",
+    "Hallucination",
+    "Entity Perception",
+    "2D Spatial Perception",
+    "Time Perception",
+    "Scene Perception",
+    "Text Perception",
+    "Event Cognition",
+    "Entity Cognition",
+    "Text Cognition",
+    "Event Perception",
+    "Scene Cognition",
+]
+
+
+def get_dimention_rating_open_ended(data_path):
+    # 读取数据
+    df = load(data_path)
+
+    df = df[df["score"] != -1]
+
+    # 将秒转换为分钟并分配到对应区间
+    df["duration_minutes"] = df["duration"] / 60
+    df["duration_range"] = pd.cut(
+        df["duration_minutes"], bins=[-np.inf, 10, 20, 30, 40, 50, 60, np.inf], labels=DURATIONS
+    )
+
+    # 初始化结果字典
+    result = {
+        "overall": 0,
+        "duration": {k: 0 for k in DURATIONS},
+        "domain": {k: 0 for k in DOMAINS},
+        "sub_category": {k: 0 for k in SUB_CATEGORIES},
+    }
+
+    # Overall
+    result["overall"] = round(df["score"].mean(), 4)
+
+    # Duration
+    for dur in DURATIONS:
+        dur_scores = df[df["duration_range"] == dur]["score"]
+        result["duration"][dur] = round(dur_scores.mean(), 4) if not dur_scores.empty else 0
+
+    # Domain
+    for domain in DOMAINS:
+        domain_scores = df[df["domain"] == domain]["score"]
+        result["domain"][domain] = round(domain_scores.mean(), 4) if not domain_scores.empty else 0
+
+    # Sub-category
+    for sub_cat in SUB_CATEGORIES:
+        sub_cat_scores = df[df["sub_category"] == sub_cat]["score"]
+        result["sub_category"][sub_cat] = round(sub_cat_scores.mean(), 4) if not sub_cat_scores.empty else 0
+
+    return result
+
+
+def get_dimention_rating_mcq_grouding(data_path):
+
+    # 读取数据
+    df = load(data_path)
+
+    # df.loc[(df['task_mode'] == 'miou') & (df['score'] == -1), 'score'] = 0
+
+    df = df[df["score"] != -1]
+
+    # 将秒转换为分钟并分配到对应区间
+    df["duration_minutes"] = df["duration"] / 60
+    df["duration_range"] = pd.cut(
+        df["duration_minutes"], bins=[-np.inf, 10, 20, 30, 40, 50, 60, np.inf], labels=DURATIONS
+    )
+
+    # 初始化结果字典
+    result = {
+        metric: {
+            "overall": 0,
+            "duration": {k: 0 for k in DURATIONS},
+            "domain": {k: 0 for k in DOMAINS},
+            "sub_category": {k: 0 for k in SUB_CATEGORIES},
+        }
+        for metric in ["long_acc", "clue_acc", "miou", "CRR", "acc@iou", "rec@iou"]
+    }
+
+    # 计算基础指标
+    for metric in ["long_acc", "clue_acc", "miou"]:
+        metric_df = df[df["task_mode"] == metric]
+
+        # Overall
+        result[metric]["overall"] = round(metric_df["score"].mean(), 4)
+
+        # Duration
+        for dur in DURATIONS:
+            dur_scores = metric_df[metric_df["duration_range"] == dur]["score"]
+            result[metric]["duration"][dur] = round(dur_scores.mean(), 4) if not dur_scores.empty else 0
+
+        # Domain
+        for domain in DOMAINS:
+            domain_scores = metric_df[metric_df["domain"] == domain]["score"]
+            result[metric]["domain"][domain] = round(domain_scores.mean(), 4) if not domain_scores.empty else 0
+
+        # Sub-category
+        for sub_cat in SUB_CATEGORIES:
+            sub_cat_scores = metric_df[metric_df["sub_category"] == sub_cat]["score"]
+            result[metric]["sub_category"][sub_cat] = round(sub_cat_scores.mean(), 4) if not sub_cat_scores.empty else 0
+
+    # 计算复合指标 CRR
+    def calculate_crr(scores):
+        long_acc = scores[scores["task_mode"] == "long_acc"]["score"].mean()
+        clue_acc = scores[scores["task_mode"] == "clue_acc"]["score"].mean()
+        return round(min(long_acc, clue_acc) / clue_acc, 4) if clue_acc != 0 else 0
+
+    # Overall CRR
+    result["CRR"]["overall"] = calculate_crr(df)
+
+    # Duration CRR
+    for dur in DURATIONS:
+        dur_df = df[df["duration_range"] == dur]
+        result["CRR"]["duration"][dur] = calculate_crr(dur_df)
+
+    # Domain CRR
+    for domain in DOMAINS:
+        domain_df = df[df["domain"] == domain]
+        result["CRR"]["domain"][domain] = calculate_crr(domain_df)
+
+    # Sub-category CRR
+    for sub_cat in SUB_CATEGORIES:
+        sub_cat_df = df[df["sub_category"] == sub_cat]
+        result["CRR"]["sub_category"][sub_cat] = calculate_crr(sub_cat_df)
+
+    # 计算 acc@iou
+    def calculate_acc_at_iou_threshold(scores, threshold):
+
+        miou_qids = set(scores[scores["task_mode"] == "miou"]["qid"])
+
+        long_acc_qids = set(scores[scores["task_mode"] == "long_acc"]["qid"])
+
+        valid_qids = miou_qids & long_acc_qids
+
+        miou_positive = set(scores[(scores["task_mode"] == "miou") & (scores["score"] > threshold)]["qid"])
+
+        long_acc_positive = scores[
+            (scores["task_mode"] == "long_acc") & (scores["qid"].isin(miou_positive)) & (scores["score"] == 1)
+        ]
+
+        acc_at_iou_threshold = len(long_acc_positive) / len(valid_qids) if len(valid_qids) > 0 else 0
+        return round(acc_at_iou_threshold, 4)
+
+    def calculate_acc_at_iou(scores):
+        thresholds = [0.1, 0.2, 0.3, 0.4, 0.5]
+        acc_at_iou_values = [calculate_acc_at_iou_threshold(scores, threshold) for threshold in thresholds]
+
+        return round(sum(acc_at_iou_values) / len(acc_at_iou_values), 4)
+
+    # Overall acc@iou
+    result["acc@iou"]["overall"] = calculate_acc_at_iou(df)
+
+    # Duration acc@iou
+    for dur in DURATIONS:
+        dur_df = df[df["duration_range"] == dur]
+        result["acc@iou"]["duration"][dur] = calculate_acc_at_iou(dur_df)
+
+    # Domain acc@iou
+    for domain in DOMAINS:
+        domain_df = df[df["domain"] == domain]
+        result["acc@iou"]["domain"][domain] = calculate_acc_at_iou(domain_df)
+
+    # Sub-category acc@iou
+    for sub_cat in SUB_CATEGORIES:
+        sub_cat_df = df[df["sub_category"] == sub_cat]
+        result["acc@iou"]["sub_category"][sub_cat] = calculate_acc_at_iou(sub_cat_df)
+
+    # 计算 rec@iou
+    def calculate_rec_at_iou_threshold(scores, threshold):
+        # 获取所有 miou 类型的数据
+        miou_scores = scores[scores["task_mode"] == "miou"]
+
+        # 计算 miou score 大于 threshold 的数量
+        miou_positive = miou_scores[miou_scores["score"] > threshold]
+
+        # 计算比例
+        rec_at_iou = len(miou_positive) / len(miou_scores) if len(miou_scores) > 0 else 0
+
+        return round(rec_at_iou, 4)
+
+    def calculate_rec_at_iou(scores):
+        thresholds = [0.1, 0.2, 0.3, 0.4, 0.5]
+        rec_at_iou_values = [calculate_rec_at_iou_threshold(scores, threshold) for threshold in thresholds]
+
+        return round(sum(rec_at_iou_values) / len(rec_at_iou_values), 4)
+
+    # Overall rec@iou
+    result["rec@iou"]["overall"] = calculate_rec_at_iou(df)
+
+    # Duration rec@iou
+    for dur in DURATIONS:
+        dur_df = df[df["duration_range"] == dur]
+        result["rec@iou"]["duration"][dur] = calculate_rec_at_iou(dur_df)
+
+    # Domain rec@iou
+    for domain in DOMAINS:
+        domain_df = df[df["domain"] == domain]
+        result["rec@iou"]["domain"][domain] = calculate_rec_at_iou(domain_df)
+
+    # Sub-category rec@iou
+    for sub_cat in SUB_CATEGORIES:
+        sub_cat_df = df[df["sub_category"] == sub_cat]
+        result["rec@iou"]["sub_category"][sub_cat] = calculate_rec_at_iou(sub_cat_df)
+
+    return result
+
+
+def milliseconds_to_seconds(milliseconds):
+    return milliseconds / 1000
+
+
+def sample_frames_clue_average(clues_time_intervals, frame_num, fps):
+    # 计算每个线索区间的时长
+    clues_frame_intervals = [(round(interval[0] * fps), round(interval[1] * fps)) for interval in clues_time_intervals]
+    clue_durations = [interval[1] - interval[0] for interval in clues_frame_intervals]
+    total_duration = sum(clue_durations)
+    # 如果 frame_num 的数量大于等于总帧数, 则直接返回全部帧
+    if frame_num >= total_duration:
+        return [frame for interval in clues_frame_intervals for frame in range(interval[0], interval[1])]
+    frames_per_clue = [int(frame_num * (duration / total_duration)) for duration in clue_durations]
+    frame_indices = []
+    for i, (interval, num_frames) in enumerate(zip(clues_frame_intervals, frames_per_clue)):
+        num_frames = max(1, num_frames)
+        seg_size = (interval[1] - interval[0]) / num_frames
+        clue_frame_indices = [int(interval[0] + seg_size / 2 + seg_size * idx) for idx in range(num_frames)]
+        frame_indices.extend(clue_frame_indices)
+    return frame_indices
+
+
+def merge_intervals(intervals):
+    """
+    Merge overlapping intervals in a list.
+    Assumes each interval is a list [start, end].
+    """
+    if not intervals:
+        return []
+
+    # Sort intervals by start time
+    intervals.sort(key=lambda x: x[0])
+
+    merged = [intervals[0]]
+
+    for current in intervals[1:]:
+        last_merged = merged[-1]
+
+        # Check if there is an overlap
+        if current[0] <= last_merged[1]:
+            # Merge the current interval with the last one
+            last_merged[1] = max(last_merged[1], current[1])
+        else:
+            # No overlap, add current interval
+            merged.append(current)
+
+    return merged
+
+
+def calculate_intervals_iou(intervals1, intervals2):
+    """
+    Calculate the IoU of two lists of intervals.
+    Each list contains intervals represented as [start, end].
+    """
+    # Merge overlapping intervals in both lists
+    merged1 = merge_intervals(intervals1)
+    merged2 = merge_intervals(intervals2)
+
+    # Calculate total length of intervals for both lists
+    def total_length(merged_intervals):
+        return sum(end - start for start, end in merged_intervals)
+
+    length1 = total_length(merged1)
+    length2 = total_length(merged2)
+
+    # Calculate intersection length
+    intersection_length = 0
+    for interval1 in merged1:
+        for interval2 in merged2:
+            intersection_start = max(interval1[0], interval2[0])
+            intersection_end = min(interval1[1], interval2[1])
+            intersection_length += max(0, intersection_end - intersection_start)
+    # Calculate union length
+    union_length = length1 + length2 - intersection_length
+    # IoU is intersection divided by union
+    iou = intersection_length / union_length if union_length > 0 else 0
+    return iou
+
+
+def post_process(response, right_answer, task_mode, duration):
+    result = -1
+
+    if response:
+        # 找到 ```json 和 ``` 的位置
+        json_start = response.find("```json")
+        json_end = response.find("```", json_start + len("```json"))
+
+        # 如果找到了 json 内容
+        if json_start != -1 and json_end != -1:
+            json_content = response[json_start + len("```json"):json_end].strip()
+        else:
+            json_content = ""
+
+        if json_content:
+            if task_mode in ["long_acc", "clue_acc"]:
+                json_content = re.sub(r"(?<=:\s)([A-Za-z_]\w*)", r'"\1"', json_content)
+
+            try:
+                model_result = json.loads(json_content)["result"]
+
+                if task_mode in ["long_acc", "clue_acc"]:
+                    result = 1 if right_answer == model_result else 0
+                elif task_mode == "miou":
+                    if not isinstance(model_result, list):
+                        return -1
+                    if not isinstance(model_result[0], list):
+                        model_result = [model_result]
+
+                    need_duration = all(interval[0] <= 1 and interval[1] <= 1 for interval in model_result)
+
+                    if need_duration:
+                        model_result = [[interval[0] * duration, interval[1] * duration] for interval in model_result]
+
+                    right_answer = eval(right_answer)
+
+                    result = calculate_intervals_iou(right_answer, model_result)
+
+            except Exception as e:
+                print(f"Error in parsing JSON: {e}, {json_content}")
+
+        if result == -1:
+            if task_mode in ["long_acc", "clue_acc"]:
+                # 检查是否存在大写字母 A-H，认为其为模型答案
+                matches = re.findall(r"\b[A-H]\b", response)
+                if matches:
+                    result = 1 if right_answer in matches else 0
+            elif task_mode == "miou":
+                # 提取所有实数，进行配对
+                numbers = re.findall(r"-?\d+\.?\d*", response)
+                if len(numbers) < 2:
+                    result = -1
+                else:
+                    if len(numbers) % 2 != 0:
+                        numbers = numbers[:-1]
+                    model_result = [[float(numbers[i]), float(numbers[i + 1])] for i in range(0, len(numbers), 2)]
+
+                    if type(right_answer) is str:
+                        right_answer = eval(right_answer)
+
+                    result = calculate_intervals_iou(right_answer, model_result)
+
+    return result
+
+
+def get_timestampes(frame_indices, fps):
+    seconds = list(map(lambda x: str(round(x / fps, 4)), frame_indices))
+    timestamps = ", ".join(seconds)
+    return "A total of {frame_num} frames are sampled. Their corresponding timestamps are:\n\n{timestamps}\n\n".format(
+        frame_num=len(frame_indices), timestamps=timestamps
+    )
+
+
+def post_process_open(response):
+    model_result = -1
+
+    if response and response != FAIL_MSG:
+        json_start = response.find("```json")
+        json_end = response.find("```", json_start + len("```json"))
+
+        # 如果找到了 json 内容
+        if json_start != -1 and json_end != -1:
+            json_content = response[json_start + len("```json"):json_end].strip()
+        else:
+            json_content = ""
+
+        if json_content:
+            try:
+                model_result = json.loads(json_content)["result"]
+            except Exception as e:
+                print(f"Error in parsing JSON: {e}, {json_content}")
+
+        if model_result == -1:
+            model_result = response
+
+    return model_result
+
+
+def post_process_eval_open(response, step):
+
+    model_result = -1
+
+    if response and response != FAIL_MSG:
+
+        json_start = response.find("```json")
+        json_end = response.find("```", json_start + len("```json"))
+
+        if json_start != -1 and json_end != -1:
+            json_content = response[json_start + len("```json"):json_end].strip()
+        else:
+            json_content = ""
+
+        if json_content:
+            try:
+                model_result = json.loads(json_content)["result"]
+            except Exception as e:
+                print(f"Error in parsing JSON: {e}, {json_content}")
+                return -1
+        if model_result == -1:
+            if step == 1:
+                match = re.search(r"[012]", response)
+                if match:
+                    model_result = int(match.group())
+            else:
+                match = re.search(r"[01]", response)
+                if match:
+                    model_result = int(match.group())
+
+    return model_result
+
+
+def eval_open_first(model, line):
+
+    user_prompt = ""
+
+    user_prompt += f"Question: {line['question']}\n\n"
+
+    user_prompt += f"The ground truth answer is '{line['answer']}'\n\n"
+
+    user_prompt += f"The model's prediction is '{line['model_result']}'\n\n"
+
+    result = model.generate(user_prompt)
+
+    return result
+
+
+def save_step_1_steps(data, step_1_results):
+
+    # 处理所有结果
+    data["step_1_result"] = data["qid"].map(lambda x: post_process_eval_open(step_1_results[x], 1))
+
+    # 条件更新
+    mask = data["step_1_result"].isin([-1, 0, 1])
+    data.loc[mask, "step_2_result"] = data.loc[mask, "step_1_result"]
+    data.loc[mask, "score"] = data.loc[mask, "step_1_result"]
+
+    return data
+
+
+def eval_open_second(model, line, frame_paths):
+
+    user_prompt = ""
+
+    user_prompt += f"Question: {line['question']}\n\n"
+
+    user_prompt += f"The model's prediction is '{line['model_result']}'\n\n"
+
+    result = model.generate([user_prompt] + frame_paths)
+
+    return result
+
+
+def save_step_2_steps(data, step_1_results):
+
+    # 处理所有结果
+    data["score"] = data["qid"].map(lambda x: post_process_eval_open(step_1_results[x], 2))
+
+    return data
+
+
+def clue_frame_paths(clue_frame_root, qid, num_frames=8):
+    frame_root = osp.join(clue_frame_root, str(qid))
+    os.makedirs(frame_root, exist_ok=True)
+    return [osp.join(frame_root, frame_tmpl.format(i, num_frames)) for i in range(1, num_frames + 1)]
+
+
+def save_clue_video_frames(data_root, clue_frame_root, video, uid, clue_intervals=None, num_frames=8, fps=-1):
+
+    if type(uid) is str:
+        uid = str(uid)
+
+    vid_path = osp.join(data_root, video)
+    import decord
+    vid = decord.VideoReader(vid_path)
+    vid_fps = vid.get_avg_fps()
+
+    if clue_intervals is not None:
+        # 1. 合并重叠区间
+        merged_intervals = merge_intervals(clue_intervals)
+
+        if num_frames > 0 and fps < 0:
+            # 2. 基于clue_intervals均匀抽帧
+            indices = sample_frames_clue_average(merged_intervals, num_frames, vid_fps)
+            frame_paths = clue_frame_paths(clue_frame_root, uid, len(indices))
+
+    # 保存帧
+    flag = np.all([osp.exists(p) for p in frame_paths])
+    if not flag:
+        lock_path = osp.splitext(vid_path)[0] + '.lock'
+        with portalocker.Lock(lock_path, 'w', timeout=30):
+            if not np.all([osp.exists(p) for p in frame_paths]):
+                images = [vid[i].asnumpy() for i in indices]
+                images = [Image.fromarray(arr) for arr in images]
+                for im, pth in zip(images, frame_paths):
+                    if not osp.exists(pth):
+                        im.save(pth)
+
+    return frame_paths, indices, vid_fps
+
+
+def get_chunk_number(filename):
+    try:
+        num = filename.split("chunk_")[1].split(".zip")[0]
+        return int(num)
+    except:
+        return float('inf')
+
+
+def unzip_hf_zip(target_dir):
+    target_dir = Path(target_dir)
+
+    videos_dir = target_dir / "cg_videos_720p"
+    clue_videos_dir = target_dir / "cg_clue_videos"
+    subtitles_dir = target_dir / "cg_subtitles"
+
+    if videos_dir.exists() and clue_videos_dir.exists() and subtitles_dir.exists():
+        print("all target dirs exist, skip.")
+        return
+
+    videos_dir.mkdir(parents=True, exist_ok=True)
+    clue_videos_dir.mkdir(parents=True, exist_ok=True)
+    subtitles_dir.mkdir(parents=True, exist_ok=True)
+
+    video_zips = sorted(target_dir.glob("video_chunk_*.zip"))
+    for zip_path in tqdm(video_zips, desc="unzip videos"):
+        with zipfile.ZipFile(zip_path, "r") as zip_ref:
+            zip_ref.extractall(videos_dir)
+
+    clue_zips = sorted(target_dir.glob("clue_video_chunk_*.zip"))
+    for zip_path in tqdm(clue_zips, desc="unzip clue videos"):
+        with zipfile.ZipFile(zip_path, "r") as zip_ref:
+            zip_ref.extractall(clue_videos_dir)
+
+    subtitles_zip = target_dir / "subtitles.zip"
+    with zipfile.ZipFile(subtitles_zip, "r") as zip_ref:
+        for file in tqdm(zip_ref.namelist(), desc="unzip subtitles"):
+            zip_ref.extract(file, subtitles_dir)
+
+    print("sucessfully unzip all files.")
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/eval_configs/__init__.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/eval_configs/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/eval_configs/__pycache__/__init__.cpython-310.pyc b/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/eval_configs/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..55cdc482f1722613a276a698bbff32ae97bd3b73
Binary files /dev/null and b/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/eval_configs/__pycache__/__init__.cpython-310.pyc differ
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/eval_configs/global_config.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/eval_configs/global_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..0cf0cc9cf97d1d80f666f91f3075852890d17a71
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/eval_configs/global_config.py
@@ -0,0 +1,61 @@
+import subprocess
+texts = []
+images = []
+markers = []
+
+
+def reset_texts():
+    texts.clear()
+
+
+def add_text(text):
+    texts.append(text)
+
+
+def get_raw_texts():
+    return [item[2] for item in texts]
+
+
+def get_texts():
+    return texts
+
+
+def reset_images():
+    images.clear()
+
+
+def add_image(image):
+    images.append(image)
+
+
+def get_images():
+    return images
+
+
+def reset_markers():
+    markers.clear()
+
+
+def add_marker(marker):
+    markers.append(marker)
+
+
+def get_markers():
+    return markers
+
+
+def run_script_safe(script_path):
+    try:
+        subprocess.run(
+            ["python3", script_path],
+            check=True,
+            capture_output=True,
+            text=True
+        )
+        return True  # success
+    except subprocess.CalledProcessError as e:
+        print(f"[ERROR] Failed to run {script_path}")
+        print(f"[Return Code]: {e.returncode}")
+        print(f"[Stdout]:\n{e.stdout}")
+        print(f"[Stderr]:\n{e.stderr}")
+        return False  # failed
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/__pycache__/__init__.cpython-310.pyc b/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..20d8b87b3b0126fa7817e5638c1f40e027c5bdaa
Binary files /dev/null and b/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/__pycache__/__init__.cpython-310.pyc differ
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/__pycache__/chart_type_evaluator.cpython-310.pyc b/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/__pycache__/chart_type_evaluator.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..95781f7f192ce5da5f8eeabb9877c7151aaa1194
Binary files /dev/null and b/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/__pycache__/chart_type_evaluator.cpython-310.pyc differ
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/__pycache__/color_evaluator.cpython-310.pyc b/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/__pycache__/color_evaluator.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..daa320aabf68eb51ea85ca3c64019a3d9f10b72b
Binary files /dev/null and b/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/__pycache__/color_evaluator.cpython-310.pyc differ
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/__pycache__/layout_evaluator.cpython-310.pyc b/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/__pycache__/layout_evaluator.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8d290df33b419085deae8471cf21fc0b9cf34fb9
Binary files /dev/null and b/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/__pycache__/layout_evaluator.cpython-310.pyc differ
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/chart_type_evaluator_prefix.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/chart_type_evaluator_prefix.py
new file mode 100644
index 0000000000000000000000000000000000000000..6cd9494db76a3b527f808edb3ae7677ae5334976
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/chart_type_evaluator_prefix.py
@@ -0,0 +1,372 @@
+import os
+import sys
+# sys.path.insert(0, os.environ['PROJECT_PATH'])
+if os.environ["VLMEVAL_CHARTMIMIC_UTILS_PATH"] not in sys.path:
+    sys.path.insert(0, os.environ["VLMEVAL_CHARTMIMIC_UTILS_PATH"])
+
+from matplotlib.projections.polar import PolarAxes
+import matplotlib.pyplot as plt
+from matplotlib.axes import Axes
+from matplotlib.axes._base import _process_plot_var_args
+import squarify
+import networkx.drawing.nx_pylab as nx_pylab
+import networkx as nx
+from mpl_toolkits.mplot3d import Axes3D
+from matplotlib.image import NonUniformImage
+from matplotlib.patches import Ellipse, Circle
+from matplotlib.tri._tripcolor import tripcolor
+from matplotlib_venn._common import VennDiagram
+import inspect
+import warnings
+warnings.filterwarnings("ignore", category=UserWarning)
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+warnings.filterwarnings("ignore", category=FutureWarning)
+
+# sys.path.insert(0, os.environ['PROJECT_PATH'])
+
+called_functions = {}
+in_decorator = False
+
+
+def log_function_specific_for_draw_networkx_labels(func):
+    def wrapper(
+        G,
+        pos,
+        labels=None,
+        font_size=12,
+        font_color="k",
+        font_family="sans-serif",
+        font_weight="normal",
+        alpha=None,
+        bbox=None,
+        horizontalalignment="center",
+        verticalalignment="center",
+        ax=None,
+        clip_on=True,
+    ):
+        global drawed_colors
+        global in_decorator
+
+        if not in_decorator:
+            in_decorator = True
+
+            file_name = inspect.getfile(func) + "/" + func.__name__
+            name = file_name + "-" + func.__name__
+            called_functions[name] = called_functions.get(name, 0) + 1
+
+            result = func(
+                G,
+                pos,
+                labels=labels,
+                font_size=font_size,
+                font_color=font_color,
+                font_family=font_family,
+                font_weight=font_weight,
+                alpha=alpha,
+                bbox=bbox,
+                horizontalalignment=horizontalalignment,
+                verticalalignment=verticalalignment,
+                ax=ax,
+                clip_on=clip_on
+            )
+
+            in_decorator = False
+        else:
+            return func(
+                G,
+                pos,
+                labels=labels,
+                font_size=font_size,
+                font_color=font_color,
+                font_family=font_family,
+                font_weight=font_weight,
+                alpha=alpha,
+                bbox=bbox,
+                horizontalalignment=horizontalalignment,
+                verticalalignment=verticalalignment,
+                ax=ax,
+                clip_on=clip_on
+            )
+        return result
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+
+def log_function_specific_for_draw_networkx_edges(func):
+    def wrapper(
+        G,
+        pos,
+        edgelist=None,
+        width=1.0,
+        edge_color="k",
+        style="solid",
+        alpha=None,
+        arrowstyle=None,
+        arrowsize=10,
+        edge_cmap=None,
+        edge_vmin=None,
+        edge_vmax=None,
+        ax=None,
+        arrows=None,
+        label=None,
+        node_size=300,
+        nodelist=None,
+        node_shape="o",
+        connectionstyle="arc3",
+        min_source_margin=0,
+        min_target_margin=0,
+    ):
+        global drawed_colors
+        global in_decorator
+
+        if not in_decorator:
+            in_decorator = True
+
+            file_name = inspect.getfile(func) + "/" + func.__name__
+            name = file_name + "-" + func.__name__
+            called_functions[name] = called_functions.get(name, 0) + 1
+
+            result = func(
+                G,
+                pos,
+                edgelist=edgelist,
+                width=width,
+                edge_color=edge_color,
+                style=style,
+                alpha=alpha,
+                arrowstyle=arrowstyle,
+                arrowsize=arrowsize,
+                edge_cmap=edge_cmap,
+                edge_vmin=edge_vmin,
+                edge_vmax=edge_vmax,
+                ax=ax,
+                arrows=arrows,
+                label=label,
+                node_size=node_size,
+                nodelist=nodelist,
+                node_shape=node_shape,
+                connectionstyle=connectionstyle,
+                min_source_margin=min_source_margin,
+                min_target_margin=min_target_margin
+            )
+
+            in_decorator = False
+        else:
+            return func(
+                G,
+                pos,
+                edgelist=edgelist,
+                width=width,
+                edge_color=edge_color,
+                style=style,
+                alpha=alpha,
+                arrowstyle=arrowstyle,
+                arrowsize=arrowsize,
+                edge_cmap=edge_cmap,
+                edge_vmin=edge_vmin,
+                edge_vmax=edge_vmax,
+                ax=ax,
+                arrows=arrows,
+                label=label,
+                node_size=node_size,
+                nodelist=nodelist,
+                node_shape=node_shape,
+                connectionstyle=connectionstyle,
+                min_source_margin=min_source_margin,
+                min_target_margin=min_target_margin
+            )
+        return result
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+
+def log_function_specific_for_draw_networkx_nodes(func):
+    def wrapper(
+        G,
+        pos,
+        nodelist=None,
+        node_size=300,
+        node_color="#1f78b4",
+        node_shape="o",
+        alpha=None,
+        cmap=None,
+        vmin=None,
+        vmax=None,
+        ax=None,
+        linewidths=None,
+        edgecolors=None,
+        label=None,
+        margins=None,
+    ):
+        global drawed_colors
+        global in_decorator
+
+        if not in_decorator:
+            in_decorator = True
+
+            file_name = inspect.getfile(func) + "/" + func.__name__
+            name = file_name + "-" + func.__name__
+            called_functions[name] = called_functions.get(name, 0) + 1
+
+            result = func(
+                G,
+                pos,
+                nodelist=nodelist,
+                node_size=node_size,
+                node_color=node_color,
+                node_shape=node_shape,
+                alpha=alpha,
+                cmap=cmap,
+                vmin=vmin,
+                vmax=vmax,
+                ax=ax,
+                linewidths=linewidths,
+                edgecolors=edgecolors,
+                label=label,
+                margins=margins
+            )
+
+            in_decorator = False
+        else:
+            return func(
+                G,
+                pos,
+                nodelist=nodelist,
+                node_size=node_size,
+                node_color=node_color,
+                node_shape=node_shape,
+                alpha=alpha,
+                cmap=cmap,
+                vmin=vmin,
+                vmax=vmax,
+                ax=ax,
+                linewidths=linewidths,
+                edgecolors=edgecolors,
+                label=label,
+                margins=margins
+            )
+        return result
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+
+def log_function(func):
+    def wrapper(*args, **kwargs):
+        global in_decorator
+        if not in_decorator:
+            in_decorator = True
+            if len(args) > 0 and isinstance(
+                    args[0], PolarAxes) and func.__name__ == "plot":
+                file_name = inspect.getfile(func)
+                file_name += "_polar"
+            else:
+                file_name = inspect.getfile(func)
+            name = file_name + "-" + func.__name__
+            called_functions[name] = called_functions.get(name, 0) + 1
+            result = func(*args, **kwargs)
+            in_decorator = False
+            return result
+        else:
+            return func(*args, **kwargs)
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+
+Axes.bar = log_function(Axes.bar)
+Axes.barh = log_function(Axes.barh)   # The same as the bar
+
+# _process_plot_var_args._makeline = log_function(_process_plot_var_args._makeline)
+Axes.plot = log_function(Axes.plot)     # Special Case for polar plot
+Axes.axhline = log_function(Axes.axhline)
+Axes.axvline = log_function(Axes.axvline)
+Axes.axvspan = log_function(Axes.axvspan)
+Axes.axhspan = log_function(Axes.axhspan)
+Axes.hlines = log_function(Axes.hlines)
+Axes.vlines = log_function(Axes.vlines)
+
+Axes.errorbar = log_function(Axes.errorbar)   # The same as the line
+
+Axes.boxplot = log_function(Axes.boxplot)
+
+Axes.violinplot = log_function(Axes.violinplot)
+Axes.violin = log_function(Axes.violin)
+
+Axes.hist = log_function(Axes.hist)
+
+# Axes._fill_between_x_or_y = log_function(Axes._fill_between_x_or_y)
+Axes.fill_between = log_function(Axes.fill_between)
+Axes.fill_betweenx = log_function(Axes.fill_betweenx)
+
+Axes.scatter = log_function(Axes.scatter)
+
+nx_pylab.draw_networkx_nodes = log_function_specific_for_draw_networkx_nodes(
+    nx_pylab.draw_networkx_nodes)
+nx_pylab.draw_networkx_edges = log_function_specific_for_draw_networkx_edges(
+    nx_pylab.draw_networkx_edges)
+nx_pylab.draw_networkx_labels = log_function_specific_for_draw_networkx_labels(
+    nx_pylab.draw_networkx_labels)
+
+# nx_pylab.draw_networkx_nodes = log_function_specific_for_draw_networkx_nodes(nx_pylab.draw_networkx_nodes)
+# nx_pylab.draw_networkx_edges = log_function_specific_for_draw_networkx_edges(nx_pylab.draw_networkx_edges)
+# nx_pylab.draw_networkx_labels = log_function_specific_for_draw_networkx_labels(nx_pylab.draw_networkx_labels)
+
+nx.draw_networkx_nodes = log_function_specific_for_draw_networkx_nodes(
+    nx.draw_networkx_nodes)
+nx.draw_networkx_edges = log_function_specific_for_draw_networkx_edges(
+    nx.draw_networkx_edges)
+nx.draw_networkx_labels = log_function_specific_for_draw_networkx_labels(
+    nx.draw_networkx_labels)
+
+Axes.quiver = log_function(Axes.quiver)
+
+Axes3D.scatter = log_function(Axes3D.scatter)
+Axes3D.plot = log_function(Axes3D.plot)
+Axes3D.plot_surface = log_function(Axes3D.plot_surface)
+Axes3D.bar3d = log_function(Axes3D.bar3d)
+Axes3D.bar = log_function(Axes3D.bar)
+Axes3D.add_collection3d = log_function(Axes3D.add_collection3d)
+
+Axes.pie = log_function(Axes.pie)
+
+Axes.fill = log_function(Axes.fill)
+
+squarify.plot = log_function(squarify.plot)
+
+Axes.imshow = log_function(Axes.imshow)
+Axes.pcolor = log_function(Axes.pcolor)
+NonUniformImage.__init__ = log_function(NonUniformImage.__init__)
+
+Axes.contour = log_function(Axes.contour)
+Axes.contourf = log_function(Axes.contourf)
+
+Ellipse.__init__ = log_function(Ellipse.__init__)
+Axes.broken_barh = log_function(Axes.broken_barh)
+
+Axes.tripcolor = log_function(Axes.tripcolor)
+
+VennDiagram.__init__ = log_function(VennDiagram.__init__)
+
+Circle.__init__ = log_function(Circle.__init__)
+
+# Axes.plot = log_function(Axes.plot)
+# Axes.loglog = log_function(Axes.loglog)
+# Axes.scatter = log_function(Axes.scatter)
+# Axes.bar = log_function(Axes.bar)
+# Axes.barh = log_function(Axes.barh)
+# Axes.axhline = log_function(Axes.axhline)
+# Axes.axvline = log_function(Axes.axvline)
+# Axes.errorbar = log_function(Axes.errorbar)
+# Axes.matshow = log_function(Axes.matshow)
+# Axes.hist = log_function(Axes.hist)
+# Axes.pie = log_function(Axes.pie)
+# Axes.boxplot = log_function(Axes.boxplot)
+# Axes.arrow = log_function(Axes.arrow)
+# Axes.fill_between = log_function(Axes.fill_between)
+# Axes.fill_betweenx = log_function(Axes.fill_betweenx)
+# Axes.imshow = log_function(Axes.imshow)
+# Axes.contour = log_function(Axes.contour)
+# Axes.contourf = log_function(Axes.contourf)
+# Axes.violinplot = log_function(Axes.violinplot)
+# Axes.violin = log_function(Axes.violin)
+
+# squarify.plot = log_function(squarify.plot)
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/color_evaluator.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/color_evaluator.py
new file mode 100644
index 0000000000000000000000000000000000000000..dd8f8a665cda2f88a7a71dae87f4b92eafc140b0
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/color_evaluator.py
@@ -0,0 +1,326 @@
+# flake8: noqa
+from typing import List, Tuple
+
+# from dotenv import load_dotenv
+# load_dotenv()
+
+import os
+
+# sys.path.insert(0, os.environ["PROJECT_PATH"])
+
+from ..eval_configs.global_config import run_script_safe
+
+
+# from skimage.color import deltaE_cie76
+# from skimage.color import rgb2lab
+from itertools import permutations
+from multiprocessing import Pool, cpu_count
+from .color_utils import group_color, calculate_similarity_single
+
+from multiprocessing import Process
+
+
+# def hex_to_rgb(hex_color):
+#     hex_color = hex_color.lstrip('#')
+#     return tuple(int(hex_color[i:i+2], 16) / 255.0 for i in (0, 2, 4))
+
+# def calculate_similarity_single(c1, c2):
+#     c1_file = c1.split("--")[0]
+#     c2_file = c2.split("--")[0]
+
+#     c1_color = c1.split("--")[1]
+#     c2_color = c2.split("--")[1]
+
+#     if c1_file != c2_file:
+#         return 0
+#     elif c1_color.startswith("#") and c2_color.startswith("#"):
+
+#         c1_color = rgb2lab(np.array([hex_to_rgb(c1_color)]))
+#         c2_color = rgb2lab(np.array([hex_to_rgb(c2_color)]))
+
+#         return max(0, 1 - deltaE_cie76(c1_color, c2_color)[0] / 100)
+#     elif not c1_color.startswith("#") and not c2_color.startswith("#"):
+
+#         return 1 if c1_color == c2_color else 0
+#     else:
+#         return 0
+
+
+def calculate_similarity_for_permutation(args):
+    shorter, perm = args
+    current_similarity = sum(
+        calculate_similarity_single(c1, c2) for c1, c2 in zip(shorter, perm)
+    )
+    return current_similarity
+
+
+class ColorEvaluator:
+
+    def __init__(self) -> None:
+        self.metrics = {
+            "precision": 0,
+            "recall": 0,
+            "f1": 0,
+        }
+
+    def __call__(self, generation_code_file, golden_code_file):
+        # print("genearion_code_file", generation_code_file)
+        # print("golden_code_file", golden_code_file)
+
+        self.golden_code_file = golden_code_file
+
+        # print(f"generation_code_file: {generation_code_file}")
+        generation_colors = self._log_colors(generation_code_file)
+        # print(f"golden_code_file: {golden_code_file}")
+        golden_colors = self._log_colors(golden_code_file)
+        # print(f"len(generation_colors): {len(generation_colors)}")
+        # print(f"len(golden_colors): {len(golden_colors)}")
+
+        self._calculate_metrics(generation_colors, golden_colors)
+
+        # [TAG] What is this for?
+        # redunant_file = os.environ["PROJECT_PATH"] + "/" + os.path.basename(golden_code_file).replace(".py", ".pdf")
+        # os.remove(redunant_file)
+        # print(self.metrics)
+
+    def _log_colors(self, code_file):
+        """
+        Get text objects of the code
+        """
+
+        with open(code_file, "r") as f:
+            lines = f.readlines()
+        code = "".join(lines)
+
+        prefix = self._get_prefix()
+        output_file = code_file.replace(".py", "_log_colors.txt")
+        suffix = self._get_suffix(output_file)
+        code = prefix + code + suffix
+
+        code_log_texts_file = code_file.replace(".py", "_log_colors.py")
+        with open(code_log_texts_file, "w") as f:
+            f.write(code)
+
+        # os.system(f"python3 {code_log_texts_file}")
+        success = run_script_safe(code_log_texts_file)
+        if not success:
+            print("Skip downstream logic due to previous failure.")
+            # optionally return default result or continue
+
+        if os.path.exists(output_file):
+            with open(output_file, "r") as f:
+                colors = f.read()
+                try:
+                    colors = eval(colors)
+                except BaseException:
+                    colors = []
+            os.remove(output_file)
+        else:
+            colors = []
+
+        os.remove(code_log_texts_file)
+
+        # pdf_file = re.findall(r"plt\.savefig\('(.*)'\)", code)
+        # if len(pdf_file) != 0:
+        # pdf_file = pdf_file[0]
+        # if os.path.basename(pdf_file) == pdf_file:
+        # os.remove(pdf_file)
+
+        return colors
+
+    def _calculate_metrics(
+        self, generation_colors: List[Tuple], golden_colors: List[Tuple]
+    ):
+        generation_colors = list(generation_colors)
+        golden_colors = list(golden_colors)
+
+        if len(generation_colors) == 0 or len(golden_colors) == 0:
+            self.metrics["precision"] = 0
+            self.metrics["recall"] = 0
+            self.metrics["f1"] = 0
+            return
+
+        group_generation_colors = group_color(generation_colors)
+        group_golden_colors = group_color(golden_colors)
+
+        # print("group_generation_colors", group_generation_colors)
+        # print("group_golden_colors", group_golden_colors)
+
+        # print("generation_colors", generation_colors)
+        # print("golden_colors", golden_colors)
+
+        def calculate_similarity_serial(lst1, lst2):
+            if len(lst1) == 0 or len(lst2) == 0:
+                return 0
+
+            shorter, longer = (lst1, lst2) if len(lst1) <= len(lst2) else (lst2, lst1)
+
+            max_total_similarity = float("-inf")
+            best_index = None
+
+            for perm in permutations(longer, len(shorter)):
+                current_similarity = sum(
+                    calculate_similarity_single(c1, c2) for c1, c2 in zip(shorter, perm)
+                )
+                current_similarity /= len(shorter)
+
+                if current_similarity > max_total_similarity:
+                    max_total_similarity = current_similarity
+                    best_index = [shorter, perm]
+
+            # best_index[0] = sorted(best_index[0])
+            # best_index[1] = sorted(best_index[1])
+            # print("best_index", best_index)
+            for i1, i2 in zip(best_index[0], best_index[1]):
+                print(i1, i2)
+            tmp_similarity = sum(
+                calculate_similarity_single(c1, c2)
+                for c1, c2 in zip(best_index[0], best_index[1])
+            ) / len(shorter)
+            print("tmp_similarity", tmp_similarity)
+
+            return max_total_similarity
+
+        def calculate_similarity_parallel(lst1, lst2):
+            if len(lst1) == 0 or len(lst2) == 0:
+                return 0
+
+            shorter, longer = (lst1, lst2) if len(lst1) <= len(lst2) else (lst2, lst1)
+            perms = permutations(longer, len(shorter))
+
+            # create processes according to the number of CPUs
+            with Pool(processes=cpu_count()) as pool:
+                similarities = pool.map(
+                    calculate_similarity_for_permutation,
+                    [(shorter, perm) for perm in perms],
+                )
+
+            # print("length of similarities", len(similarities))
+
+            # indexes = [item[0] for item in similarities]
+            # similarities = [item[1] for item in similarities]
+
+            # get max similarity and its index
+            # max_total_similarity = max(similarities)
+            # max_index = similarities.index(max_total_similarity)
+            # index = indexes[max_index]
+
+            # max_total_similarity = max(similarities)
+            # index[0] = sorted(index[0])
+            # index[1] = sorted(index[1])
+            # for i1, i2 in zip(index[0], index[1]):
+            # print(i1, i2)
+
+            # tmp_similarity = sum( calculate_similarity_single(c1, c2) for c1, c2 in zip(index[0], index[1]) ) / len(shorter)
+            # print("tmp_similarity", tmp_similarity)
+            # print("best_index", index)
+
+            return max(similarities)
+
+        # merge keys in group_generation_colors and group_golden_colors
+        merged_color_group = list(
+            set(list(group_generation_colors.keys()) + list(group_golden_colors.keys()))
+        )
+        for color in merged_color_group:
+            if color not in group_generation_colors:
+                group_generation_colors[color] = []
+            if color not in group_golden_colors:
+                group_golden_colors[color] = []
+
+        max_set_similarity = 0
+
+        for color in merged_color_group:
+            max_set_similarity += calculate_similarity_parallel(
+                group_generation_colors[color], group_golden_colors[color]
+            )
+
+        # self.metrics["similarity"] = calculate_similarity_parallel(generation_colors, golden_colors)
+        # max_set_similarity = calculate_similarity_parallel(generation_colors, golden_colors)
+        self.metrics["precision"] = (
+            max_set_similarity / len(generation_colors)
+            if len(generation_colors) != 0
+            else 0
+        )
+        if "box" in self.golden_code_file:
+            self.metrics["recall"] = (
+                max_set_similarity / len(golden_colors)
+                if len(golden_colors) != 0
+                else 0
+            )
+        else:
+            self.metrics["recall"] = max_set_similarity / len(golden_colors)
+        if self.metrics["precision"] + self.metrics["recall"] == 0:
+            self.metrics["f1"] = 0
+        else:
+            self.metrics["f1"] = (
+                2
+                * self.metrics["precision"]
+                * self.metrics["recall"]
+                / (self.metrics["precision"] + self.metrics["recall"])
+            )
+
+        return
+
+    def _get_prefix(self):
+        with open(
+            os.environ["VLMEVAL_CHARTMIMIC_UTILS_PATH"]
+            + "/evaluator/color_evaluator_prefix.py",
+            "r",
+        ) as f:
+            prefix = f.read()
+        return prefix
+
+    def _get_suffix(self, output_file):
+        return f"""
+drawed_colors = list(set(drawed_colors))
+drawed_colors = update_drawed_colors(drawed_objects)
+if len(drawed_colors) > 10:
+    drawed_colors = filter_color(drawed_colors)
+# print("drawed_colors", drawed_colors)
+# print("len(drawed_colors)", len(drawed_colors))
+# print("Length of drawed_obejcts", len(drawed_objects))
+# print("drawed_objects", drawed_objects)
+with open('{output_file}', 'w') as f:
+    f.write(str(drawed_colors))
+"""
+
+
+if __name__ == "__main__":
+    # sys.path.insert(0, '/home/yc21/project/Princess-s-CHI')
+
+    evaluator = ColorEvaluator()
+    # evaluator = TextEvaluator()
+
+    golden_code_dir = f"{os.environ['PROJECT_PATH']}/dataset/ori_500/"
+    generation_code_dir = f"{os.environ['PROJECT_PATH']}/results/chart2code_Phi-3-vision-128k-instruct_DirectAgent_results/direct/"
+
+    # list python files in the directory
+    golden_code_files = [f for f in os.listdir(golden_code_dir) if f.endswith(".py")]
+
+    # for golden_code_file in golden_code_files:
+    # print(golden_code_file)
+    # generation_code_file = generation_code_dir + golden_code_file
+    # evaluator(generation_code_file, golden_code_dir + golden_code_file)
+
+    # write a multi-processing version
+    def _muti_process_run(rank, data, num_processes):
+        for i in range(rank, len(data), num_processes):
+            golden_code_file = data[i]
+            generation_code_file = generation_code_dir + golden_code_file
+            evaluator(generation_code_file, golden_code_dir + golden_code_file)
+
+    evaluator = ColorEvaluator()
+    processes = []
+    num_processes = 20
+    for rank in range(num_processes):
+        p = Process(
+            target=_muti_process_run, args=(rank, golden_code_files, num_processes)
+        )
+        p.start()
+        processes.append(p)
+    for p in processes:
+        p.join()
+
+    # golden_code_file = f"{os.environ['PROJECT_PATH']}/dataset/ori_500/line_5.py"
+    # generation_code_file = f"{os.environ['PROJECT_PATH']}/results/chart2code_gpt-4-vision-preview_DirectAgent_results/direct/line_5.py"
+    # evaluator(generation_code_file, golden_code_file)
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/color_evaluator_prefix.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/color_evaluator_prefix.py
new file mode 100644
index 0000000000000000000000000000000000000000..69ed91e587ff28daa04d9098a353b2a37e21af06
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/color_evaluator_prefix.py
@@ -0,0 +1,835 @@
+# # flake8: noqa
+import os
+import squarify
+
+import warnings
+
+warnings.filterwarnings("ignore", category=UserWarning)
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+warnings.filterwarnings("ignore", category=FutureWarning)
+
+import sys
+
+if os.environ["VLMEVAL_CHARTMIMIC_UTILS_PATH"] not in sys.path:
+    sys.path.insert(0, os.environ["VLMEVAL_CHARTMIMIC_UTILS_PATH"])
+
+import networkx
+import matplotlib
+import matplotlib.pyplot as plt
+import numpy as np
+import networkx as nx
+from matplotlib.axes._base import _process_plot_var_args
+from matplotlib.axes._axes import Axes
+from mpl_toolkits.mplot3d import Axes3D
+import matplotlib.colors as mcolors
+import networkx.drawing.nx_pylab as nx_pylab
+from matplotlib.projections.polar import PolarAxes
+from matplotlib.image import NonUniformImage
+from matplotlib.patches import Ellipse, Circle
+from matplotlib_venn._common import VennDiagram
+import inspect
+from evaluator.color_utils import filter_color
+# from chart2code.utils.evaluator.color_utils import filter_color
+
+
+drawed_colors = []
+drawed_objects = {}
+in_decorator = False
+
+
+def convert_color_to_hex(color):
+    'Convert color from name, RGBA, or hex to a hex format.'
+    try:
+        # First, try to convert from color name to RGBA to hex
+        if isinstance(color, str):
+            # Check if it's already a hex color (start with '#' and length
+            # either 7 or 9)
+            if color.startswith('#') and (len(color) == 7 or len(color) == 9):
+                return color.upper()
+            else:
+                return mcolors.to_hex(mcolors.to_rgba(color)).upper()
+        # Then, check if it's in RGBA format
+        elif isinstance(color, (list, tuple, np.ndarray)) and (len(color) == 4 or len(color) == 3):
+            return mcolors.to_hex(color).upper()
+        else:
+            raise ValueError("Unsupported color format")
+    except ValueError as e:
+        print(color)
+        print("Error converting color:", e)
+        return None
+
+
+def log_function_specific_for_draw_networkx_labels(func):
+    def wrapper(
+        G,
+        pos,
+        labels=None,
+        font_size=12,
+        font_color="k",
+        font_family="sans-serif",
+        font_weight="normal",
+        alpha=None,
+        bbox=None,
+        horizontalalignment="center",
+        verticalalignment="center",
+        ax=None,
+        clip_on=True,
+    ):
+        global drawed_colors
+        global in_decorator
+
+        if not in_decorator:
+            in_decorator = True
+
+            func_name = inspect.getfile(func) + "/" + func.__name__
+
+            result = func(
+                G,
+                pos,
+                labels=labels,
+                font_size=font_size,
+                font_color=font_color,
+                font_family=font_family,
+                font_weight=font_weight,
+                alpha=alpha,
+                bbox=bbox,
+                horizontalalignment=horizontalalignment,
+                verticalalignment=verticalalignment,
+                ax=ax,
+                clip_on=clip_on
+            )
+
+            for item in result.values():
+                color = convert_color_to_hex(item.get_color())
+                drawed_colors.append(func_name + "--" + color)
+                drawed_objects[func_name + "--" + color] = item
+
+            in_decorator = False
+        else:
+            return func(
+                G,
+                pos,
+                labels=labels,
+                font_size=font_size,
+                font_color=font_color,
+                font_family=font_family,
+                font_weight=font_weight,
+                alpha=alpha,
+                bbox=bbox,
+                horizontalalignment=horizontalalignment,
+                verticalalignment=verticalalignment,
+                ax=ax,
+                clip_on=clip_on
+            )
+        return result
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+
+def log_function_specific_for_draw_networkx_edges(func):
+    def wrapper(
+        G,
+        pos,
+        edgelist=None,
+        width=1.0,
+        edge_color="k",
+        style="solid",
+        alpha=None,
+        arrowstyle=None,
+        arrowsize=10,
+        edge_cmap=None,
+        edge_vmin=None,
+        edge_vmax=None,
+        ax=None,
+        arrows=None,
+        label=None,
+        node_size=300,
+        nodelist=None,
+        node_shape="o",
+        connectionstyle="arc3",
+        min_source_margin=0,
+        min_target_margin=0,
+    ):
+        global drawed_colors
+        global in_decorator
+
+        if not in_decorator:
+            in_decorator = True
+
+            func_name = inspect.getfile(func) + "/" + func.__name__
+
+            result = func(
+                G,
+                pos,
+                edgelist=edgelist,
+                width=width,
+                edge_color=edge_color,
+                style=style,
+                alpha=alpha,
+                arrowstyle=arrowstyle,
+                arrowsize=arrowsize,
+                edge_cmap=edge_cmap,
+                edge_vmin=edge_vmin,
+                edge_vmax=edge_vmax,
+                ax=ax,
+                arrows=arrows,
+                label=label,
+                node_size=node_size,
+                nodelist=nodelist,
+                node_shape=node_shape,
+                connectionstyle=connectionstyle,
+                min_source_margin=min_source_margin,
+                min_target_margin=min_target_margin
+            )
+
+            if isinstance(result, list):
+                for line in result:
+                    color = convert_color_to_hex(line.get_facecolor())
+                    drawed_colors.append(func_name + "--" + color)
+                if len(result) > 0:
+                    drawed_objects[func_name + "--" + color] = result
+            else:
+                for item in result.get_edgecolors().tolist():
+                    color = convert_color_to_hex(item)
+                    drawed_colors.append(func_name + "--" + color)
+                if len(result.get_edgecolors().tolist()) > 0:
+                    drawed_objects[func_name + "--" +
+                                   color] = result  # ! Attention
+
+            in_decorator = False
+        else:
+            return func(
+                G,
+                pos,
+                edgelist=edgelist,
+                width=width,
+                edge_color=edge_color,
+                style=style,
+                alpha=alpha,
+                arrowstyle=arrowstyle,
+                arrowsize=arrowsize,
+                edge_cmap=edge_cmap,
+                edge_vmin=edge_vmin,
+                edge_vmax=edge_vmax,
+                ax=ax,
+                arrows=arrows,
+                label=label,
+                node_size=node_size,
+                nodelist=nodelist,
+                node_shape=node_shape,
+                connectionstyle=connectionstyle,
+                min_source_margin=min_source_margin,
+                min_target_margin=min_target_margin
+            )
+        return result
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+
+def log_function_specific_for_draw_networkx_nodes(func):
+    def wrapper(
+        G,
+        pos,
+        nodelist=None,
+        node_size=300,
+        node_color="#1f78b4",
+        node_shape="o",
+        alpha=None,
+        cmap=None,
+        vmin=None,
+        vmax=None,
+        ax=None,
+        linewidths=None,
+        edgecolors=None,
+        label=None,
+        margins=None,
+    ):
+        global drawed_colors
+        global in_decorator
+
+        if not in_decorator:
+            in_decorator = True
+
+            func_name = inspect.getfile(func) + "/" + func.__name__
+
+            result = func(
+                G,
+                pos,
+                nodelist=nodelist,
+                node_size=node_size,
+                node_color=node_color,
+                node_shape=node_shape,
+                alpha=alpha,
+                cmap=cmap,
+                vmin=vmin,
+                vmax=vmax,
+                ax=ax,
+                linewidths=linewidths,
+                edgecolors=edgecolors,
+                label=label,
+                margins=margins
+            )
+
+            for item in result.get_facecolors().tolist():
+                color = convert_color_to_hex(item)
+                drawed_colors.append(func_name + "--" + color)
+            drawed_objects[func_name + "--" + color] = result
+
+            in_decorator = False
+        else:
+            return func(
+                G,
+                pos,
+                nodelist=nodelist,
+                node_size=node_size,
+                node_color=node_color,
+                node_shape=node_shape,
+                alpha=alpha,
+                cmap=cmap,
+                vmin=vmin,
+                vmax=vmax,
+                ax=ax,
+                linewidths=linewidths,
+                edgecolors=edgecolors,
+                label=label,
+                margins=margins
+            )
+        return result
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+
+def log_function_for_3d(func):
+    def wrapper(*args, **kwargs):
+        global drawed_colors
+        global in_decorator
+
+        if not in_decorator:
+            in_decorator = True
+
+            func_name = inspect.getfile(func) + "/" + func.__name__
+
+            result = func(*args, **kwargs)
+
+            if func.__name__ == "scatter":
+                # check whether cmap is used
+                if "cmap" in kwargs and kwargs["cmap"] is not None:
+                    print("cmap is used", kwargs["cmap"])
+                    if isinstance(kwargs["cmap"], str):
+                        drawed_colors.append(
+                            func_name + "_3d--" + kwargs["cmap"])
+                        drawed_objects[func_name + "_3d--" +
+                                       kwargs["cmap"]] = result
+                    else:
+                        drawed_colors.append(
+                            func_name + "_3d--" + kwargs["cmap"].name)
+                        drawed_objects[func_name + "_3d--" +
+                                       kwargs["cmap"].name] = result
+                else:
+                    for item in result.get_facecolors().tolist():
+                        color = convert_color_to_hex(item)
+                        drawed_colors.append(func_name + "_3d--" + color)
+                    drawed_objects[func_name + "_3d--" +
+                                   color] = result  # ! Attention
+            elif func.__name__ == "plot":
+                for line in result:
+                    color = convert_color_to_hex(line.get_color())
+                    drawed_colors.append(func_name + "_3d--" + color)
+                    drawed_objects[func_name + "_3d--" + color] = line
+            elif func.__name__ == "plot_surface":
+                if "cmap" in kwargs and kwargs["cmap"] is not None:
+                    print("cmap is used", kwargs["cmap"])
+                    if isinstance(kwargs["cmap"], str):
+                        drawed_colors.append(
+                            func_name + "_3d--" + kwargs["cmap"])
+                        drawed_objects[func_name + "_3d--" +
+                                       kwargs["cmap"]] = result
+                    else:
+                        drawed_colors.append(
+                            func_name + "_3d--" + kwargs["cmap"].name)  # ! Attention
+                        drawed_objects[func_name + "_3d--" +
+                                       kwargs["cmap"].name] = result
+                else:
+                    colors = result.get_facecolors().tolist()
+                    drawed_colors.append(
+                        func_name +
+                        "_3d--" +
+                        convert_color_to_hex(
+                            colors[0]))
+                    # ! Attention
+                    drawed_objects[func_name + "_3d--" +
+                                   convert_color_to_hex(colors[0])] = result
+            elif func.__name__ == "bar3d":
+                colors = result.get_facecolors().tolist()
+                drawed_colors.append(
+                    func_name +
+                    "_3d--" +
+                    convert_color_to_hex(
+                        colors[0]))
+                # ! Attention
+                drawed_objects[func_name + "_3d--" +
+                               convert_color_to_hex(colors[0])] = result
+            elif func.__name__ == "bar":
+                for item in result:
+                    color = convert_color_to_hex(item.get_facecolor())
+                    drawed_colors.append(func_name + "_3d--" + color)
+                    drawed_objects[func_name + "_3d--" + color] = item
+            elif func.__name__ == "add_collection3d":
+                colors = result.get_facecolors().tolist()
+                for color in colors:
+                    drawed_colors.append(
+                        func_name + "_3d--" + convert_color_to_hex(color))
+                drawed_objects[func_name + "_3d--" +
+                               convert_color_to_hex(color)] = result
+
+            in_decorator = False
+        else:
+            return func(*args, **kwargs)
+        return result
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+
+def log_function(func):
+    def wrapper(*args, **kwargs):
+        global drawed_colors
+        global in_decorator
+
+        if not in_decorator:
+            in_decorator = True
+
+            func_name = inspect.getfile(func) + "/" + func.__name__
+
+            result = func(*args, **kwargs)
+
+            if func.__name__ == "_makeline":
+                color = convert_color_to_hex(result[1]["color"])
+                drawed_colors.append(func_name + "--" + color)
+                drawed_objects[func_name + "--" + color] = result[0]
+            elif func.__name__ == "axhline":
+                color = convert_color_to_hex(result.get_color())
+                drawed_colors.append(func_name + "--" + color)
+                drawed_objects[func_name + "--" + color] = result
+            elif func.__name__ == "axvline":
+                color = convert_color_to_hex(result.get_color())
+                drawed_colors.append(func_name + "--" + color)
+                drawed_objects[func_name + "--" + color] = result
+            elif func.__name__ == "_fill_between_x_or_y":
+                color = convert_color_to_hex(list(result.get_facecolors()[0]))
+                drawed_colors.append(func_name + "--" + color)
+                drawed_objects[func_name + "--" + color] = result
+            elif func.__name__ == "bar":
+                for item in result:
+                    color = convert_color_to_hex(
+                        list(item._original_facecolor))
+                    drawed_colors.append(func_name + "--" + color)
+                    drawed_objects[func_name + "--" + color] = item
+            elif func.__name__ == "scatter" and not isinstance(args[0], PolarAxes):
+                # check whether cmap is used
+                if "cmap" in kwargs and kwargs["cmap"] is not None:
+                    print("cmap is used", kwargs["cmap"])
+                    if isinstance(kwargs["cmap"], str):
+                        drawed_colors.append(func_name + "--" + kwargs["cmap"])
+                        drawed_objects[func_name + "--" +
+                                       kwargs["cmap"]] = result
+                    else:
+                        drawed_colors.append(
+                            func_name + "--" + kwargs["cmap"].name)  # ! Attention
+                        drawed_objects[func_name + "--" +
+                                       kwargs["cmap"].name] = result
+                else:
+                    if len(result.get_facecolor()) != 0:
+                        color = convert_color_to_hex(
+                            list(result.get_facecolor()[0]))
+                        drawed_colors.append(func_name + "--" + color)
+                        drawed_objects[func_name + "--" + color] = result
+            elif func.__name__ == "pie":
+                for item in result[0]:
+                    color = convert_color_to_hex(item.get_facecolor())
+                    drawed_colors.append(func_name + "--" + color)
+                    drawed_objects[func_name + "--" + color] = item
+            elif func.__name__ == "axvspan":
+                color = convert_color_to_hex(result.get_facecolor())
+                drawed_colors.append(func_name + "--" + color)
+                drawed_objects[func_name + "--" + color] = result
+            elif func.__name__ == "axhspan":
+                color = convert_color_to_hex(result.get_facecolor())
+                drawed_colors.append(func_name + "--" + color)
+                drawed_objects[func_name + "--" + color] = result
+            elif func.__name__ == "hlines":
+                for item in result.get_edgecolors():
+                    color = convert_color_to_hex(list(item))
+                    drawed_colors.append(func_name + "--" + color)
+                drawed_objects[func_name + "--" +
+                               color] = result   # ! Attention
+            elif func.__name__ == "vlines":
+                for item in result.get_edgecolors():
+                    color = convert_color_to_hex(list(item))
+                    drawed_colors.append(func_name + "--" + color)
+                drawed_objects[func_name + "--" +
+                               color] = result   # ! Attention
+            elif func.__name__ == "boxplot":
+                for item in result["boxes"]:
+                    if isinstance(item, matplotlib.patches.PathPatch):
+                        color = convert_color_to_hex(
+                            list(item.get_facecolor()))
+                        drawed_colors.append(func_name + "--" + color)
+                        drawed_objects[func_name + "--" +
+                                       color] = item  # ! Attention
+            elif func.__name__ == "violinplot":
+                for item in result["bodies"]:
+                    color = convert_color_to_hex(list(item.get_facecolor()[0]))
+                    drawed_colors.append(func_name + "--" + color)
+                    drawed_objects[func_name + "--" +
+                                   color] = item  # ! Attention
+            elif func.__name__ == "hist":
+                tops, bins, patches = result
+                if not isinstance(patches, matplotlib.cbook.silent_list):
+                    for item in patches:
+                        color = convert_color_to_hex(
+                            list(item.get_facecolor()))
+                        drawed_colors.append(func_name + "--" + color)
+                        drawed_objects[func_name + "--" + color] = item
+                else:
+                    for container in patches:
+                        for item in container:
+                            color = convert_color_to_hex(
+                                list(item.get_facecolor()))
+                            drawed_colors.append(func_name + "--" + color)
+                            drawed_objects[func_name + "--" + color] = item
+            elif func.__name__ == "quiver":
+                for item in result.get_facecolors().tolist():
+                    color = convert_color_to_hex(item)
+                    drawed_colors.append(func_name + "--" + color)
+                drawed_objects[func_name + "--" +
+                               color] = result  # ! Attention
+            elif func.__name__ == "plot" and len(args) > 0 and isinstance(args[0], PolarAxes):
+                lines = result
+                for line in lines:
+                    color = convert_color_to_hex(line.get_color())
+                    # print("color", color)
+                    drawed_colors.append(func_name + "_polar" + "--" + color)
+                    drawed_objects[func_name + "_polar" + "--" + color] = line
+            elif func.__name__ == "scatter" and isinstance(args[0], PolarAxes):
+                # check whether cmap is used
+                if "cmap" in kwargs and kwargs["cmap"] is not None:
+                    print("cmap is used", kwargs["cmap"])
+                    if isinstance(kwargs["cmap"], str):
+                        drawed_colors.append(
+                            func_name + "_polar" + "--" + kwargs["cmap"])
+                        drawed_objects[func_name +
+                                       "_polar--" + kwargs["cmap"]] = result
+                    else:
+                        drawed_colors.append(
+                            func_name + "_polar" + "--" + kwargs["cmap"].name)
+                        drawed_objects[func_name + "_polar" +
+                                       "--" + kwargs["cmap"].name] = result
+                else:
+                    if len(result.get_facecolor()) != 0:
+                        color = convert_color_to_hex(
+                            list(result.get_facecolor()[0]))
+                        drawed_colors.append(
+                            func_name + "_polar" + "--" + color)
+                        drawed_objects[func_name + "_polar" +
+                                       "--" + color] = result  # ! Attention
+            elif func.__name__ == "plot" and "squarify" in func_name:
+                # get ax
+                ax = result
+                # get container
+                containers = ax.containers
+                for container in containers:
+                    for item in container:
+                        color = convert_color_to_hex(
+                            list(item.get_facecolor()))
+                        drawed_colors.append(
+                            func_name + "_squarify" + "--" + color)
+                        drawed_objects[func_name +
+                                       "_squarify" + "--" + color] = item
+            elif func.__name__ == "imshow":
+                colormap = result.get_cmap().name
+                drawed_colors.append(func_name + "--" + colormap)
+                drawed_objects[func_name + "--" +
+                               colormap] = result  # ! Attention
+            elif func.__name__ == "pcolor":
+                colormap = result.get_cmap().name
+                drawed_colors.append(func_name + "--" + colormap)
+                drawed_objects[func_name + "--" +
+                               colormap] = result  # ! Attention
+            elif func.__name__ == "contour":
+                colormap = result.get_cmap().name
+                drawed_colors.append(func_name + "--" + colormap)
+                drawed_objects[func_name + "--" +
+                               colormap] = result  # ! Attention
+            elif func.__name__ == "contourf":
+                colormap = result.get_cmap().name
+                drawed_colors.append(func_name + "--" + colormap)
+                drawed_objects[func_name + "--" +
+                               colormap] = result  # ! Attention
+            elif func.__name__ == "fill":
+                patches = result
+                for patch in patches:
+                    color = convert_color_to_hex(list(patch.get_facecolor()))
+                    drawed_colors.append(func_name + "--" + color)
+                    drawed_objects[func_name + "--" + color] = patch
+            elif func.__name__ == "__init__" and isinstance(args[0], NonUniformImage):
+                colormap = args[0].get_cmap().name
+                drawed_colors.append(func_name + "--" + colormap)
+                drawed_objects[func_name + "--" + colormap] = args[0]
+            elif func.__name__ == "broken_barh":
+                colors = result.get_facecolors().tolist()
+                for color in colors:
+                    drawed_colors.append(
+                        func_name + "--" + convert_color_to_hex(color))
+                drawed_objects[func_name + "--" +
+                               convert_color_to_hex(color)] = result
+            elif func.__name__ == "__init__" and isinstance(args[0], Ellipse):
+                color = convert_color_to_hex(args[0].get_facecolor())
+                drawed_colors.append(func_name + "--" + color)
+                drawed_objects[func_name + "--" + color] = args[0]
+            elif func.__name__ == "tripcolor":
+                colormap = result.get_cmap().name
+                drawed_colors.append(func_name + "--" + colormap)
+                drawed_objects[func_name + "--" +
+                               colormap] = result  # ! Attention
+            elif func.__name__ == "__init__" and isinstance(args[0], VennDiagram):
+                for item in args[0].patches:
+                    color = convert_color_to_hex(item.get_facecolor())
+                    drawed_colors.append(func_name + "--" + color)
+                drawed_objects[func_name + "--" + color] = args[0]
+            elif func.__name__ == "__init__" and isinstance(args[0], Circle):
+                color = convert_color_to_hex(args[0].get_facecolor())
+                drawed_colors.append(func_name + "--" + color)
+                drawed_objects[func_name + "--" + color] = args[0]
+            in_decorator = False
+        else:
+            return func(*args, **kwargs)
+        return result
+
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+
+def update_drawed_colors(drawed_obejcts):
+    drawed_colors = []
+    for name, obj in drawed_objects.items():
+        func_name = name.split("--")[0]
+        color = name.split("--")[1]
+
+        if "/_makeline" in func_name:
+            color = convert_color_to_hex(obj.get_color())
+            drawed_colors.append(func_name + "--" + color)
+        elif "/axhline" in func_name:
+            color = convert_color_to_hex(obj.get_color())
+            drawed_colors.append(func_name + "--" + color)
+        elif "/axvline" in func_name:
+            color = convert_color_to_hex(obj.get_color())
+            drawed_colors.append(func_name + "--" + color)
+        elif "/_fill_between_x_or_y" in func_name:
+            color = convert_color_to_hex(list(obj.get_facecolors()[0]))
+            drawed_colors.append(func_name + "--" + color)
+        elif "/bar" in func_name and "_3d" not in func_name:
+            color = convert_color_to_hex(list(obj._original_facecolor))
+            if color is not None:
+                drawed_colors.append(func_name + "--" + color)
+        elif "/scatter" in func_name and "polar" not in func_name and "3d" not in func_name:
+            # check whether cmap is used by checking whether color is hex
+            if color.startswith("#") is False:
+                drawed_colors.append(func_name + "--" + color)
+            else:
+                if len(obj.get_facecolor()) != 0:
+                    color = convert_color_to_hex(list(obj.get_facecolor()[0]))
+                    drawed_colors.append(func_name + "--" + color)
+        elif "/pie" in func_name:
+            color = convert_color_to_hex(obj.get_facecolor())
+            drawed_colors.append(func_name + "--" + color)
+        elif "/axvspan" in func_name:
+            color = convert_color_to_hex(obj.get_facecolor())
+            drawed_colors.append(func_name + "--" + color)
+        elif "/axhspan" in func_name:
+            color = convert_color_to_hex(obj.get_facecolor())
+            drawed_colors.append(func_name + "--" + color)
+        elif "/hlines" in func_name:
+            for item in obj.get_edgecolors():
+                color = convert_color_to_hex(list(item))
+                drawed_colors.append(func_name + "--" + color)
+        elif "/vlines" in func_name:
+            for item in obj.get_edgecolors():
+                color = convert_color_to_hex(list(item))
+                drawed_colors.append(func_name + "--" + color)
+        elif "/boxplot" in func_name:
+            color = convert_color_to_hex(list(obj.get_facecolor()))
+            drawed_colors.append(func_name + "--" + color)
+        elif "/violinplot" in func_name:
+            color = convert_color_to_hex(list(obj.get_facecolor()[0]))
+            drawed_colors.append(func_name + "--" + color)
+        elif "/hist" in func_name:
+            color = convert_color_to_hex(list(obj.get_facecolor()))
+            drawed_colors.append(func_name + "--" + color)
+        elif "/quiver" in func_name:
+            for item in obj.get_facecolors().tolist():
+                color = convert_color_to_hex(item)
+                drawed_colors.append(func_name + "--" + color)
+        elif "/plot" in func_name and "polar" in func_name:
+            color = convert_color_to_hex(obj.get_color())
+            drawed_colors.append(func_name + "_polar--" + color)
+        elif "/scatter" in func_name and "polar" in func_name:
+            # check whether cmap is used by checking whether color is hex
+            if color.startswith("#") is False:
+                drawed_colors.append(func_name + "_polar--" + color)
+            else:
+                if len(obj.get_facecolor()) != 0:
+                    color = convert_color_to_hex(list(obj.get_facecolor()[0]))
+                    drawed_colors.append(func_name + "_polar--" + color)
+        elif "/plot" in func_name and "_squarify" in func_name:
+            color = convert_color_to_hex(list(obj.get_facecolor()))
+            drawed_colors.append(func_name + "--" + color)
+        elif "/imshow" in func_name:
+            colormap = obj.get_cmap().name
+            drawed_colors.append(func_name + "--" + colormap)
+        elif "/pcolor" in func_name:
+            colormap = obj.get_cmap().name
+            drawed_colors.append(func_name + "--" + colormap)
+        elif "/contour" in func_name:
+            colormap = obj.get_cmap().name
+            drawed_colors.append(func_name + "--" + colormap)
+        elif "/contourf" in func_name:
+            colormap = obj.get_cmap().name
+            drawed_colors.append(func_name + "--" + colormap)
+        elif "/fill" in func_name:
+            color = convert_color_to_hex(list(obj.get_facecolor()))
+            drawed_colors.append(func_name + "--" + color)
+        elif "/__init__" in func_name and isinstance(obj, NonUniformImage):
+            colormap = obj.get_cmap().name
+            drawed_colors.append(func_name + "--" + colormap)
+        elif "/broken_barh" in func_name:
+            colors = obj.get_facecolors().tolist()
+            for color in colors:
+                drawed_colors.append(
+                    func_name + "--" + convert_color_to_hex(color))
+        elif "/__init__" in func_name and isinstance(obj, Ellipse):
+            color = convert_color_to_hex(obj.get_facecolor())
+            drawed_colors.append(func_name + "--" + color)
+        elif "/tripcolor" in func_name:
+            colormap = obj.get_cmap().name
+            drawed_colors.append(func_name + "--" + colormap)
+        elif "/__init__" in func_name and isinstance(obj, VennDiagram):
+            for item in obj.patches:
+                color = convert_color_to_hex(item.get_facecolor())
+                drawed_colors.append(func_name + "--" + color)
+        elif "/__init__" in func_name and isinstance(obj, Circle):
+            color = convert_color_to_hex(obj.get_facecolor())
+            drawed_colors.append(func_name + "--" + color)
+        elif "/scatter" in func_name and "3d" in func_name:
+            # check whether cmap is used by checking whether color is hex
+            if color.startswith("#") is False:
+                drawed_colors.append(func_name + "_3d--" + color)
+            else:
+                for item in obj.get_facecolors().tolist():
+                    color = convert_color_to_hex(item)
+                    drawed_colors.append(func_name + "_3d--" + color)
+        elif "/plot" in func_name and "3d" in func_name and "plot_surface" not in func_name:
+            color = convert_color_to_hex(obj.get_color())
+            drawed_colors.append(func_name + "_3d--" + color)
+        elif "/plot_surface" in func_name:
+            if color.startswith("#") is False:
+                drawed_colors.append(func_name + "_3d--" + color)
+            else:
+                colors = obj.get_facecolors().tolist()
+                drawed_colors.append(
+                    func_name +
+                    "_3d--" +
+                    convert_color_to_hex(
+                        colors[0]))
+        elif "/bar3d" in func_name:
+            colors = obj.get_facecolors().tolist()
+            drawed_colors.append(
+                func_name +
+                "_3d--" +
+                convert_color_to_hex(
+                    colors[0]))
+        elif "/bar" in func_name and "3d" in func_name:
+            color = convert_color_to_hex(obj.get_facecolor())
+            drawed_colors.append(func_name + "_3d--" + color)
+        elif "/add_collection3d" in func_name:
+            colors = obj.get_facecolors().tolist()
+            for color in colors:
+                drawed_colors.append(
+                    func_name + "_3d--" + convert_color_to_hex(color))
+        elif "/draw_networkx_labels" in func_name:
+            color = convert_color_to_hex(obj.get_color())
+            drawed_colors.append(func_name + "--" + color)
+        elif "/draw_networkx_edges" in func_name:
+            if isinstance(obj, list):
+                for line in obj:
+                    color = convert_color_to_hex(line.get_facecolor())
+                    drawed_colors.append(func_name + "--" + color)
+            else:
+                for item in obj.get_edgecolors().tolist():
+                    color = convert_color_to_hex(item)
+                    drawed_colors.append(func_name + "--" + color)
+        elif "/draw_networkx_nodes" in func_name:
+            for item in obj.get_facecolors().tolist():
+                color = convert_color_to_hex(item)
+                drawed_colors.append(func_name + "--" + color)
+
+    drawed_colors = list(set(drawed_colors))
+
+    return drawed_colors
+
+
+_process_plot_var_args._makeline = log_function(
+    _process_plot_var_args._makeline)
+Axes.bar = log_function(Axes.bar)
+Axes.scatter = log_function(Axes.scatter)
+Axes.axhline = log_function(Axes.axhline)
+Axes.axvline = log_function(Axes.axvline)
+Axes._fill_between_x_or_y = log_function(Axes._fill_between_x_or_y)
+Axes.pie = log_function(Axes.pie)
+Axes.axvspan = log_function(Axes.axvspan)
+Axes.axhspan = log_function(Axes.axhspan)
+Axes.hlines = log_function(Axes.hlines)
+Axes.vlines = log_function(Axes.vlines)
+Axes.boxplot = log_function(Axes.boxplot)
+Axes.violinplot = log_function(Axes.violinplot)
+Axes.hist = log_function(Axes.hist)
+# Axes.plot = log_function(Axes.plot)
+PolarAxes.plot = log_function(PolarAxes.plot)
+Axes.quiver = log_function(Axes.quiver)
+Axes.imshow = log_function(Axes.imshow)
+Axes.pcolor = log_function(Axes.pcolor)
+Axes.contour = log_function(Axes.contour)
+Axes.contourf = log_function(Axes.contourf)
+Axes.fill = log_function(Axes.fill)
+NonUniformImage.__init__ = log_function(NonUniformImage.__init__)
+Ellipse.__init__ = log_function(Ellipse.__init__)
+Axes.broken_barh = log_function(Axes.broken_barh)
+
+nx_pylab.draw_networkx_nodes = log_function_specific_for_draw_networkx_nodes(
+    nx_pylab.draw_networkx_nodes)
+nx_pylab.draw_networkx_edges = log_function_specific_for_draw_networkx_edges(
+    nx_pylab.draw_networkx_edges)
+nx_pylab.draw_networkx_labels = log_function_specific_for_draw_networkx_labels(
+    nx_pylab.draw_networkx_labels)
+
+nx.draw_networkx_nodes = log_function_specific_for_draw_networkx_nodes(
+    nx.draw_networkx_nodes)
+nx.draw_networkx_edges = log_function_specific_for_draw_networkx_edges(
+    nx.draw_networkx_edges)
+nx.draw_networkx_labels = log_function_specific_for_draw_networkx_labels(
+    nx.draw_networkx_labels)
+
+
+squarify.plot = log_function(squarify.plot)
+
+Axes3D.scatter = log_function_for_3d(Axes3D.scatter)
+Axes3D.plot = log_function_for_3d(Axes3D.plot)
+Axes3D.plot_surface = log_function_for_3d(Axes3D.plot_surface)
+Axes3D.bar3d = log_function_for_3d(Axes3D.bar3d)
+Axes3D.bar = log_function_for_3d(Axes3D.bar)
+Axes3D.add_collection3d = log_function_for_3d(Axes3D.add_collection3d)
+
+Axes.tripcolor = log_function(Axes.tripcolor)
+
+VennDiagram.__init__ = log_function(VennDiagram.__init__)
+
+Circle.__init__ = log_function(Circle.__init__)
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/color_utils.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/color_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..52687f57fafc21ff4127e74c1263e63652beb7e0
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/color_utils.py
@@ -0,0 +1,85 @@
+import numpy as np
+
+# This is a patch for color map, which is not updated for newer version of
+# numpy
+
+
+def patch_asscalar(a):
+    return a.item()
+
+
+setattr(np, "asscalar", patch_asscalar)
+
+
+def hex_to_rgb(hex_color):
+    hex_color = hex_color.lstrip('#')
+    return tuple(int(hex_color[i:i + 2], 16) for i in (0, 2, 4))
+
+
+def rgb_to_lab(rgb):
+    """
+    Convert an RGB color to Lab color space.
+    RGB values should be in the range [0, 255].
+    """
+    # Create an sRGBColor object from RGB values
+    from colormath.color_objects import sRGBColor, LabColor
+    from colormath.color_conversions import convert_color
+    rgb_color = sRGBColor(rgb[0], rgb[1], rgb[2], is_upscaled=True)
+
+    # Convert to Lab color space
+    lab_color = convert_color(rgb_color, LabColor)
+
+    return lab_color
+
+
+def calculate_similarity_single(c1, c2):
+    if c1.startswith("#") and c2.startswith("#"):
+        # c1 = rgb2lab(np.array([hex_to_rgb(c1)]))
+        # c2 = rgb2lab(np.array([hex_to_rgb(c2)]))
+        c1 = hex_to_rgb(c1)
+        c2 = hex_to_rgb(c2)
+        lab1 = rgb_to_lab(c1)
+        lab2 = rgb_to_lab(c2)
+        # return max(0, 1 - deltaE_cie76(c1, c2)[0] / 100)
+        from colormath.color_diff import delta_e_cie2000
+        return max(0, 1 - (delta_e_cie2000(lab1, lab2) / 100))
+    elif not c1.startswith("#") and not c2.startswith("#"):
+
+        return 1 if c1 == c2 else 0
+    else:
+        return 0
+
+
+def filter_color(color_list):
+    filtered_color_list = []
+    len_color_list = len(color_list)
+    for i in range(len_color_list):
+        if i != 0:
+            put_in = True
+            for item in filtered_color_list:
+                similarity = calculate_similarity_single(
+                    color_list[i].split("--")[1], item.split("--")[1])
+                if similarity > 0.7:
+                    put_in = False
+                    break
+            if put_in:
+                filtered_color_list.append(color_list[i])
+        else:
+            filtered_color_list.append(color_list[i])
+    # print("Filtered color list: ", filtered_color_list)
+    return filtered_color_list
+
+
+def group_color(color_list):
+    color_dict = {}
+
+    for color in color_list:
+        chart_type = color.split("--")[0]
+        color = color.split("--")[1]
+
+        if chart_type not in color_dict:
+            color_dict[chart_type] = [color]
+        else:
+            color_dict[chart_type].append(color)
+
+    return color_dict
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/grid_evaluator.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/grid_evaluator.py
new file mode 100644
index 0000000000000000000000000000000000000000..0066c59163d88580fa89b4df9afeb9c656014549
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/grid_evaluator.py
@@ -0,0 +1,181 @@
+# flake8: noqa
+from typing import List, Tuple
+# from dotenv import load_dotenv
+# load_dotenv()
+
+import os
+# sys.path.insert(0, os.environ["PROJECT_PATH"])
+
+from ..eval_configs.global_config import run_script_safe
+
+
+
+class GridEvaluator:
+
+    def __init__(self) -> None:
+        self.metrics = {
+            "precision": 0,
+            "recall": 0,
+            "f1": 0
+        }
+
+    def __call__(self, generation_code_file, golden_code_file):
+        generation_grids = self._log_legends(generation_code_file)
+        golden_grids = self._log_legends(golden_code_file)
+
+        self._calculate_metrics(generation_grids, golden_grids)
+
+        # redunant_file = os.environ["PROJECT_PATH"] + "/" + os.path.basename(golden_code_file).replace(".py", ".pdf")
+        # os.remove(redunant_file)
+        # print(self.metrics)
+
+    def _log_legends(self, code_file):
+        """
+        Get legend objects of the code
+        """
+
+        with open(code_file, 'r') as f:
+            lines = f.readlines()
+        code = ''.join(lines)
+
+        prefix = self._get_prefix()
+        output_file = code_file.replace(".py", ".txt")
+        suffix = self._get_suffix(output_file)
+        code = prefix + code + suffix
+
+        code_log_texts_file = code_file.replace(".py", "_log_legends.py")
+        with open(code_log_texts_file, 'w') as f:
+            f.write(code)
+
+        # os.system(f"python3 {code_log_texts_file}")
+        success = run_script_safe(code_log_texts_file)
+        if not success:
+            print("Skip downstream logic due to previous failure.")
+            # optionally return default result or continue
+
+        with open(output_file, 'r') as f:
+            texts = f.read()
+            texts = eval(texts)
+
+        os.remove(code_log_texts_file)
+        os.remove(output_file)
+
+        # pdf_file = re.findall(r"plt\.savefig\('(.*)'\)", code)
+        # if len(pdf_file) != 0:
+        # pdf_file = pdf_file[0]
+        # if os.path.basename(pdf_file) == pdf_file:
+        # os.remove(pdf_file)
+
+        return texts
+
+    def _calculate_metrics(
+            self,
+            generation_grids: List[Tuple],
+            golden_grids: List[Tuple]):
+        """
+        Calculate the metrics
+
+        Args:
+            - generation_grids: List of tuples of texts, [(x, y, x_rel, y_rel, text), ...]
+            - golden_grids: List of tuples of texts, [(x, y, x_rel, y_rel, text), ...]
+        """
+        if len(generation_grids) == 0 or len(golden_grids) == 0:
+            self.metrics["precision"] = 0
+            self.metrics["recall"] = 0
+            self.metrics["f1"] = 0
+            return
+
+        len_generation = len(generation_grids)
+        len_golden = len(golden_grids)
+
+        n_correct = 0
+        for t in golden_grids:
+            if t in generation_grids:
+                n_correct += 1
+                generation_grids.remove(t)
+
+        self.metrics["precision"] = n_correct / len_generation
+        self.metrics["recall"] = n_correct / len_golden
+        if self.metrics["precision"] + self.metrics["recall"] == 0:
+            self.metrics["f1"] = 0
+        else:
+            self.metrics["f1"] = 2 * self.metrics["precision"] * \
+                self.metrics["recall"] / (self.metrics["precision"] + self.metrics["recall"])
+
+        return
+
+    def _get_prefix(self):
+        sys_to_add = os.environ["VLMEVAL_CHARTMIMIC_UTILS_PATH"]
+        # assert sys_to_add not empty
+        assert sys_to_add != "", "VLMEVAL_CHARTMIMIC_UTILS_PATH is not set"
+        return f"""
+import warnings
+warnings.filterwarnings("ignore", category=UserWarning)
+
+if "{sys_to_add}" not in sys.path:
+    sys.path.insert(0, "{sys_to_add}")
+
+import eval_configs.global_config as global_config
+global_config.reset_texts()
+from matplotlib.backends.backend_pdf import RendererPdf
+
+grid_visibility = []
+"""
+
+    def _get_suffix(self, output_file):
+        return f"""
+
+all_axes = plt.gcf().get_axes()
+
+for ax in all_axes:
+    subplot_spec = ax.get_subplotspec()
+    row = subplot_spec.rowspan.start
+    col = subplot_spec.colspan.start
+    x_grid_visible = any(line.get_visible() for line in ax.get_xgridlines())
+    y_grid_visible = any(line.get_visible() for line in ax.get_ygridlines())
+
+    grid_visibility.append(
+        dict(
+            row=row,
+            col=col,
+            x_grid_visible=x_grid_visible,
+            y_grid_visible=y_grid_visible
+        )
+    )
+
+# sort the grid visibility by row and col
+grid_visibility = sorted(grid_visibility, key=lambda x: (x['row'], x['col']))
+
+# Since there can be twin axes, we need to merge the grid visibility, if they are in the same row and col, use "or" to merge
+grid_visibility_merged = []
+for i, grid in enumerate(grid_visibility):
+    if i == 0:
+        grid_visibility_merged.append(grid)
+        continue
+
+    last_grid = grid_visibility_merged[-1]
+    if last_grid['row'] == grid['row'] and last_grid['col'] == grid['col']:
+        last_grid['x_grid_visible'] = last_grid['x_grid_visible'] or grid['x_grid_visible']
+        last_grid['y_grid_visible'] = last_grid['y_grid_visible'] or grid['y_grid_visible']
+    else:
+        grid_visibility_merged.append(grid)
+
+grid_visibility = grid_visibility_merged
+
+# print(grid_visibility)
+with open('{output_file}', 'w') as f:
+    f.write(str(grid_visibility))
+"""
+
+
+if __name__ == "__main__":
+    # sys.path.insert(0, '/home/yc21/project/Princess-s-CHI')
+
+    evaluator = GridEvaluator()
+
+    for idx in range(1, 40):
+        print(f"Processing {idx}")
+        generation_code_file = f"/home/yc21/project/Princess-s-CHI/dataset/line/line_{idx}.py"
+        golden_code_file = f"/home/yc21/project/Princess-s-CHI/results/chart2code_gpt_DirectAgent_results/direct/line_{idx}.py"
+        evaluator(generation_code_file, golden_code_file)
+        print()
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/layout_evaluator.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/layout_evaluator.py
new file mode 100644
index 0000000000000000000000000000000000000000..39b7b7adae81c1ada529d6d1c737592dba7edc36
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/layout_evaluator.py
@@ -0,0 +1,166 @@
+# flake8: noqa
+from typing import List, Tuple
+# from dotenv import load_dotenv
+# load_dotenv()
+
+import os
+# sys.path.insert(0, os.environ["PROJECT_PATH"])
+
+from ..eval_configs.global_config import run_script_safe
+
+
+class LayoutEvaluator:
+
+    def __init__(self) -> None:
+        self.metrics = {
+            "precision": 0,
+            "recall": 0,
+            "f1": 0
+        }
+
+    def __call__(self, generation_code_file, golden_code_file):
+        generation_layouts = self._log_layouts(generation_code_file)
+        golden_layouts = self._log_layouts(golden_code_file)
+
+        self._calculate_metrics(generation_layouts, golden_layouts)
+
+        # redunant_file = os.environ["PROJECT_PATH"] + "/" + os.path.basename(golden_code_file).replace(".py", ".pdf")
+        # os.remove(redunant_file)
+
+        # print(self.metrics)
+
+    def _log_layouts(self, code_file):
+        """
+        Get objects of the code
+        """
+
+        with open(code_file, 'r') as f:
+            lines = f.readlines()
+        code = ''.join(lines)
+
+        prefix = self._get_prefix()
+        output_file = code_file.replace(".py", "_log_layouts.txt")
+        if "/graph" in code_file:
+            suffix = self._get_suffix_special_for_graph(output_file)
+        else:
+            suffix = self._get_suffix(output_file)
+
+        code = prefix + code + suffix
+
+        code_log_texts_file = code_file.replace(".py", "_log_layouts.py")
+        with open(code_log_texts_file, 'w') as f:
+            f.write(code)
+
+        # os.system(f"python3 {code_log_texts_file}")
+        success = run_script_safe(code_log_texts_file)
+        if not success:
+            print("Skip downstream logic due to previous failure.")
+            # optionally return default result or continue
+
+        if os.path.exists(output_file):
+            with open(output_file, 'r') as f:
+                texts = f.read()
+                texts = eval(texts)
+            os.remove(output_file)
+        else:
+            texts = []
+        os.remove(code_log_texts_file)
+
+        return texts
+
+    def _calculate_metrics(
+            self,
+            generation_layouts: List[Tuple],
+            golden_layouts: List[Tuple]):
+        """
+        Calculate the metrics
+
+        Args:
+            - generation_layouts: List of tuples of texts, [(x, y, x_rel, y_rel, text), ...]
+            - golden_layouts: List of tuples of texts, [(x, y, x_rel, y_rel, text), ...]
+        """
+        if len(generation_layouts) == 0 or len(golden_layouts) == 0:
+            self.metrics["precision"] = 0
+            self.metrics["recall"] = 0
+            self.metrics["f1"] = 0
+            return
+
+        len_generation = len(generation_layouts)
+        len_golden = len(golden_layouts)
+
+        n_correct = 0
+        for t in golden_layouts:
+            if t in generation_layouts:
+                n_correct += 1
+                generation_layouts.remove(t)
+
+        self.metrics["precision"] = n_correct / len_generation
+        self.metrics["recall"] = n_correct / len_golden
+        if self.metrics["precision"] + self.metrics["recall"] == 0:
+            self.metrics["f1"] = 0
+        else:
+            self.metrics["f1"] = 2 * self.metrics["precision"] * \
+                self.metrics["recall"] / (self.metrics["precision"] + self.metrics["recall"])
+
+        return
+
+    def _get_prefix(self):
+        return """
+import warnings
+warnings.filterwarnings("ignore", category=UserWarning)
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+warnings.filterwarnings("ignore", category=FutureWarning)
+
+"""
+
+    def _get_suffix(self, output_file):
+        return f"""
+
+def get_gridspec_layout_info(fig):
+    layout_info = {{}}
+    for ax in fig.axes:
+        spec = ax.get_subplotspec()
+        if spec is None:
+            continue
+        gs = spec.get_gridspec()
+        nrows, ncols = gs.get_geometry()
+        row_start, row_end = spec.rowspan.start, spec.rowspan.stop - 1  # Zero-based and inclusive
+        col_start, col_end = spec.colspan.start, spec.colspan.stop - 1  # Zero-based and inclusive
+        layout_info[ax] = dict(nrows=nrows, ncols=ncols, row_start=row_start, row_end=row_end, col_start=col_start, col_end=col_end)
+    # print(layout_info)
+    layout_info = list(layout_info.values())
+    return layout_info
+
+layout_info = get_gridspec_layout_info(fig=plt.gcf())
+with open('{output_file}', 'w') as f:
+    f.write(str(layout_info))
+"""
+
+    def _get_suffix_special_for_graph(self, output_file):
+        return f"""
+def get_gridspec_layout_info(fig):
+    layout_info = {{}}
+    for ax in fig.axes:
+        layout_info[ax] = dict(nrows=1, ncols=1, row_start=0, row_end=1, col_start=0, col_end=1)
+    # print(layout_info)
+    layout_info = list(layout_info.values())
+    return layout_info
+
+layout_info = get_gridspec_layout_info(fig=plt.gcf())
+with open('{output_file}', 'w') as f:
+    f.write(str(layout_info))
+"""
+
+
+if __name__ == "__main__":
+
+    evaluator = LayoutEvaluator()
+
+    for idx in range(60, 61):
+        print(f"Processing {idx}")
+        # print("Processing Golden Code")
+        golden_code_file = f"{os.environ['PROJECT_PATH']}/dataset/ori/line_{idx}.py"
+        # print("Processing Generation Code")
+        generation_code_file = f"{os.environ['PROJECT_PATH']}/results/chart2code_gpt_ScaffoldAgent_results/scaffold/line_{idx}.py"
+        evaluator(generation_code_file, golden_code_file)
+        print()
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/legend_evaluator.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/legend_evaluator.py
new file mode 100644
index 0000000000000000000000000000000000000000..93474e0da971473d424c99415b13a9b04a03700d
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/legend_evaluator.py
@@ -0,0 +1,194 @@
+# flake8: noqa
+from typing import List, Tuple
+# from dotenv import load_dotenv
+# load_dotenv()
+
+import os
+# sys.path.insert(0, os.environ["PROJECT_PATH"])
+
+from ..eval_configs.global_config import run_script_safe
+
+
+
+class LegendEvaluator:
+
+    def __init__(self, use_position=True) -> None:
+        self.use_position = use_position
+        self.metrics = {
+            "precision": 0,
+            "recall": 0,
+            "f1": 0
+        }
+
+    def __call__(self, generation_code_file, golden_code_file):
+        generation_texts = self._log_legends(generation_code_file)
+        golden_texts = self._log_legends(golden_code_file)
+
+        self._calculate_metrics(generation_texts, golden_texts)
+
+        # redunant_file = os.environ["PROJECT_PATH"] + "/" + os.path.basename(golden_code_file).replace(".py", ".pdf")
+        # os.remove(redunant_file)
+        # print(self.metrics)
+
+    def _log_legends(self, code_file):
+        """
+        Get legend objects of the code
+        """
+
+        with open(code_file, 'r') as f:
+            lines = f.readlines()
+        code = ''.join(lines)
+
+        prefix = self._get_prefix()
+        output_file = code_file.replace(".py", ".txt")
+        suffix = self._get_suffix(output_file)
+        code = prefix + code + suffix
+
+        code_log_texts_file = code_file.replace(".py", "_log_legends.py")
+        with open(code_log_texts_file, 'w') as f:
+            f.write(code)
+
+        # os.system(f"python3 {code_log_texts_file}")
+        success = run_script_safe(code_log_texts_file)
+        if not success:
+            print("Skip downstream logic due to previous failure.")
+            # optionally return default result or continue
+
+        with open(output_file, 'r') as f:
+            texts = f.read()
+            texts = eval(texts)
+
+        os.remove(code_log_texts_file)
+        os.remove(output_file)
+
+        # pdf_file = re.findall(r"plt\.savefig\('(.*)'\)", code)
+        # if len(pdf_file) != 0:
+        # pdf_file = pdf_file[0]
+        # if os.path.basename(pdf_file) == pdf_file:
+        # os.remove(pdf_file)
+
+        return texts
+
+    def _calculate_metrics(
+            self,
+            generation_texts: List[Tuple],
+            golden_texts: List[Tuple]):
+        """
+        Calculate the metrics
+
+        Args:
+            - generation_texts: List of tuples of texts, [(x, y, x_rel, y_rel, text), ...]
+            - golden_texts: List of tuples of texts, [(x, y, x_rel, y_rel, text), ...]
+        """
+        if len(generation_texts) == 0 or len(golden_texts) == 0:
+            self.metrics["precision"] = 0
+            self.metrics["recall"] = 0
+            self.metrics["f1"] = 0
+            return
+
+        len_generation = len(generation_texts)
+        len_golden = len(golden_texts)
+
+        if not self.use_position:
+            generation_texts = [t[-1] for t in generation_texts]
+            golden_texts = [t[-1] for t in golden_texts]
+
+            n_correct = 0
+            for t in golden_texts:
+                if t in generation_texts:
+                    n_correct += 1
+                    generation_texts.remove(t)
+
+        else:
+            generation_texts = [t[2:] for t in generation_texts]
+            golden_texts = [t[2:] for t in golden_texts]
+
+            n_correct = 0
+            for t1 in golden_texts:
+                for t2 in generation_texts:
+                    # text must be equal, but x_rel and y_rel can be in a range
+                    if t1[-1] == t2[-1] and abs(t1[0] - t2[0]
+                                                ) <= 10 and abs(t1[1] - t2[1]) <= 10:
+                        # print("matched:", t2)
+                        n_correct += 1
+                        generation_texts.remove(t2)
+                        break
+
+        self.metrics["precision"] = n_correct / len_generation
+        self.metrics["recall"] = n_correct / len_golden
+        if self.metrics["precision"] + self.metrics["recall"] == 0:
+            self.metrics["f1"] = 0
+        else:
+            self.metrics["f1"] = 2 * self.metrics["precision"] * \
+                self.metrics["recall"] / (self.metrics["precision"] + self.metrics["recall"])
+
+        return
+
+    def _get_prefix(self):
+        sys_to_add = os.environ["VLMEVAL_CHARTMIMIC_UTILS_PATH"]
+        # assert sys_to_add not empty
+        assert sys_to_add != "", "VLMEVAL_CHARTMIMIC_UTILS_PATH is not set"
+        return f"""
+import warnings
+warnings.filterwarnings("ignore", category=UserWarning)
+
+if "{sys_to_add}" not in sys.path:
+    sys.path.insert(0, "{sys_to_add}")
+
+import eval_configs.global_config as global_config
+global_config.reset_texts()
+from matplotlib.backends.backend_pdf import RendererPdf
+
+drawed_legend_texts = []
+drawed_texts = []
+
+def log_function(func):
+    def wrapper(*args, **kwargs):
+        global drawed_texts
+
+        object = args[0]
+        x = args[2]
+        y = args[3]
+        x_rel = ( x / object.width / 72 ) * 100
+        y_rel = ( y / object.height / 72 ) * 100
+        s = args[4]
+
+        drawed_texts.append( (x, y, x_rel, y_rel, s) )
+        return func(*args, **kwargs)
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+RendererPdf.draw_text = log_function(RendererPdf.draw_text)
+"""
+
+    def _get_suffix(self, output_file):
+        return f"""
+
+all_axes = plt.gcf().get_axes()
+legends = [ax.get_legend() for ax in all_axes if ax.get_legend() is not None]
+for legend in legends:
+    for t in legend.get_texts():
+        drawed_legend_texts.append(t.get_text())
+
+new_drawed_legend_texts = []
+for t1 in drawed_legend_texts:
+    for t2 in drawed_texts:
+        if t1 == t2[-1]:
+            new_drawed_legend_texts.append(t2)
+            break
+drawed_legend_texts = new_drawed_legend_texts
+
+with open('{output_file}', 'w') as f:
+    f.write(str(drawed_legend_texts))
+"""
+
+
+if __name__ == "__main__":
+    # sys.path.insert(0, '/home/yc21/project/Princess-s-CHI')
+
+    evaluator = LegendEvaluator()
+
+    generation_code_file = "/home/yc21/project/Princess-s-CHI/dataset/line/line_9.py"
+    golden_code_file = "/home/yc21/project/Princess-s-CHI/results/chart2code_gpt_DirectAgent_results/direct/line_9.py"
+
+    evaluator(generation_code_file, golden_code_file)
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/text_evaluator.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/text_evaluator.py
new file mode 100644
index 0000000000000000000000000000000000000000..58cf06679f458070efd74212cc4e250f19f7e4ad
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/text_evaluator.py
@@ -0,0 +1,202 @@
+# flake8: noqa
+from typing import List, Tuple
+# from dotenv import load_dotenv
+# load_dotenv()
+
+import os
+from ..eval_configs.global_config import run_script_safe
+
+
+
+class TextEvaluator:
+
+    def __init__(self, use_position=False, use_axs=True) -> None:
+        self.metrics = {
+            "precision": 0,
+            "recall": 0,
+            "f1": 0
+        }
+        self.use_position = use_position
+        self.use_axs = use_axs
+
+    def __call__(self, generation_code_file, golden_code_file):
+        generation_texts = self._log_texts(generation_code_file)
+        golden_texts = self._log_texts(golden_code_file)
+
+        self._calculate_metrics(generation_texts, golden_texts)
+
+        # [TAG] What is this for?
+        # print(f"os.getcwd(): {os.getcwd()}")
+        # breakpoint()
+        # redunant_file = os.environ["PROJECT_PATH"] + "/" + os.path.basename(golden_code_file).replace(".py", ".pdf")
+        # os.remove(redunant_file)
+        # print(self.metrics)
+
+    def _log_texts(self, code_file):
+        """
+        Get text objects of the code
+        """
+
+        with open(code_file, 'r') as f:
+            lines = f.readlines()
+        code = ''.join(lines)
+
+        prefix = self._get_prefix()
+        output_file = code_file.replace(".py", "_log_texts.txt")
+        suffix = self._get_suffix(output_file)
+        code = prefix + code + suffix
+
+        if not self.use_axs:
+            # find plt.savefig and append code before it
+            savefig_idx = code.find("plt.savefig")
+            ax_ticks_deletion_code = self._get_ax_ticks_deletion_code()
+            code = code[:savefig_idx] + \
+                ax_ticks_deletion_code + code[savefig_idx:]
+
+        code_log_texts_file = code_file.replace(".py", "_log_texts.py")
+        with open(code_log_texts_file, 'w') as f:
+            f.write(code)
+
+        # os.system(f"python3 {code_log_texts_file}")
+        success = run_script_safe(code_log_texts_file)
+        if not success:
+            print("Skip downstream logic due to previous failure.")
+            # optionally return default result or continue
+
+        if os.path.exists(output_file):
+            with open(output_file, 'r') as f:
+                texts = f.read()
+                texts = eval(texts)
+            os.remove(output_file)
+        else:
+            texts = []
+        os.remove(code_log_texts_file)
+
+        # pdf_file = re.findall(r"plt\.savefig\('(.*)'\)", code)
+        # if len(pdf_file) != 0:
+        # pdf_file = pdf_file[0]
+        # if os.path.basename(pdf_file) == pdf_file:
+        # os.remove(pdf_file)
+
+        return texts
+
+    def _calculate_metrics(
+            self,
+            generation_texts: List[Tuple],
+            golden_texts: List[Tuple]):
+        """
+        Calculate the metrics
+
+        Args:
+            - generation_texts: List of tuples of texts, [(x, y, x_rel, y_rel, text), ...]
+            - golden_texts: List of tuples of texts, [(x, y, x_rel, y_rel, text), ...]
+        """
+        if len(generation_texts) == 0 or len(golden_texts) == 0:
+            self.metrics["precision"] = 0
+            self.metrics["recall"] = 0
+            self.metrics["f1"] = 0
+            return
+
+        len_generation = len(generation_texts)
+        len_golden = len(golden_texts)
+
+        if not self.use_position:
+            generation_texts = [t[-1] for t in generation_texts]
+            golden_texts = [t[-1] for t in golden_texts]
+
+            n_correct = 0
+            for t in golden_texts:
+                if t in generation_texts:
+                    n_correct += 1
+                    generation_texts.remove(t)
+
+        else:
+            generation_texts = [t[2:] for t in generation_texts]
+            golden_texts = [t[2:] for t in golden_texts]
+
+            n_correct = 0
+            for t1 in golden_texts:
+                for t2 in generation_texts:
+                    # text must be equal, but x_rel and y_rel can be in a range
+                    if t1[-1] == t2[-1] and abs(t1[0] - t2[0]
+                                                ) <= 10 and abs(t1[1] - t2[1]) <= 10:
+                        # print("matched:", t2)
+                        n_correct += 1
+                        generation_texts.remove(t2)
+                        break
+
+        self.metrics["precision"] = n_correct / len_generation
+        self.metrics["recall"] = n_correct / len_golden
+        if self.metrics["precision"] + self.metrics["recall"] == 0:
+            self.metrics["f1"] = 0
+        else:
+            self.metrics["f1"] = 2 * self.metrics["precision"] * \
+                self.metrics["recall"] / (self.metrics["precision"] + self.metrics["recall"])
+
+        return
+
+    def _get_prefix(self):
+        sys_to_add = os.environ["VLMEVAL_CHARTMIMIC_UTILS_PATH"]
+        # assert sys_to_add not empty
+        assert sys_to_add != "", "VLMEVAL_CHARTMIMIC_UTILS_PATH is not set"
+        return f"""
+import warnings
+warnings.filterwarnings("ignore", category=UserWarning)
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+warnings.filterwarnings("ignore", category=FutureWarning)
+
+import sys
+if "{sys_to_add}" not in sys.path:
+    sys.path.insert(0, "{sys_to_add}")
+
+import eval_configs.global_config as global_config
+global_config.reset_texts()
+from matplotlib.backends.backend_pdf import RendererPdf
+
+drawed_texts = []
+
+def log_function(func):
+    def wrapper(*args, **kwargs):
+        global drawed_texts
+
+        object = args[0]
+        x = args[2]
+        y = args[3]
+        x_rel = ( x / object.width / 72 ) * 100
+        y_rel = ( y / object.height / 72 ) * 100
+        s = args[4]
+
+        drawed_texts.append( (x, y, x_rel, y_rel, s) )
+        return func(*args, **kwargs)
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+RendererPdf.draw_text = log_function(RendererPdf.draw_text)
+"""
+
+    def _get_suffix(self, output_file):
+        return f"""
+# print("drawed_texts", drawed_texts)
+with open('{output_file}', 'w') as f:
+    f.write(str(drawed_texts))
+"""
+
+    def _get_ax_ticks_deletion_code(self):
+        return """
+all_axes = plt.gcf().get_axes()
+for ax in all_axes:
+    ax.set_xticks([])
+    ax.set_yticks([])
+"""
+
+
+if __name__ == "__main__":
+    # sys.path.insert(0, '/home/yc21/project/Princess-s-CHI')
+
+    evaluator = TextEvaluator(use_axs=False)
+    # evaluator = TextEvaluator()
+
+    generation_code_file = "/home/yc21/project/Princess-s-CHI/dataset/line/line_7.py"
+    golden_code_file = "/home/yc21/project/Princess-s-CHI/results/chart2code_gpt_DirectAgent_results/direct/line_7.py"
+
+    evaluator(generation_code_file, golden_code_file)
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/crpe.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/crpe.py
new file mode 100644
index 0000000000000000000000000000000000000000..ec89792ca621c321758f49cc3fc43434f87a77ac
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/crpe.py
@@ -0,0 +1,13 @@
+import json
+import argparse
+from collections import defaultdict
+
+
+def is_correct(predict, answer):
+    # predict是标准答案 answer是预测
+    if len(answer) == 1:
+        return answer[0] == predict[0]
+    elif len(answer) != 1 and answer[0] in ['A', 'B', 'C', 'D']:
+        return answer[0] == predict[0]
+    elif len(answer) != 1 and answer[0] not in ['A', 'B', 'C', 'D']:
+        return predict[4:].lower() in answer.lower()
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/mathverse.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/mathverse.py
new file mode 100644
index 0000000000000000000000000000000000000000..f650a1dd3012a96978f1f9beb188957070c83b94
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/mathverse.py
@@ -0,0 +1,193 @@
+from ...smp import *
+from ...utils import can_infer
+
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+def get_gpt4_extract_ICE():
+    example_1 = """
+1.
+Model response: 'Rounded to two decimal places, the perimeter of the sector is approximately:\n\n(-2, 1)'
+Extracted Answer: (-2, 1)
+""" # noqa
+
+    example_2 = """
+2.
+Model response: 'at those points.\n\nTherefore, the correct option that represents the meaning of the intersection points of the graphs is:\n\nD. They give the solutions to the equation $f(t)=g(t)$.",'
+Extracted Answer: D
+""" # noqa
+
+    example_3 = """
+3.
+Model response: ' at 1 (there's a closed circle at y = 1), the range in interval notation is \\((-4, 1]\\).\n\nFinal values:\nDomain: \\((-3, 3]\\)\nRange: \\((-4, 1]\\)'
+Extracted Answer: Domain: \\((-3, 3]\\)\nRange: \\((-4, 1]\\)
+""" # noqa
+
+    example_4 = """
+4.
+Model response: 'As it stands, I cannot provide the correct option letter because there isn't enough information to solve for 'y'.'
+Extracted Answer: null
+""" # noqa
+
+    example_5 = """
+5.
+Model response: 'Given that AB = 17.6 meters, we can now substitute into the equation:\n\nd = 17.6 / cos(38\u00b0)\n\nTherefore, to one decimal place, the distance d between Ned and Bart is approximately 22.3 meters.'
+Extracted answer: 22.3
+""" # noqa
+
+    example_6 = """
+6.
+Model response:  have all the coefficients for the quadratic function:\n\\( f(x) = ax^2 + bx + c \\)\n\\( f(x) = -1x^2 - 2x + 1 \\)\n\nTherefore, the equation for the graphed function \\( f \\) is:\n\\( f(x) = -x^2 - 2x + 1 \\)"'
+Extracted answer: f(x) = -x^2 - 2x + 1
+""" # noqa
+
+    return [example_1, example_2, example_3, example_4, example_5, example_6]
+
+
+def get_gpt4_score_ICE():
+    example_1 = """
+[Question]: Write the set of numbers represented on the number line in interval notation.
+[Standard Answer]: (-2,1]
+[Model_answer] : Extracted Answer: \\((-2, 1)\\)
+Judgement: 0
+""" # noqa
+
+    example_2 = """
+[Question]: As shown in the figure, circle O has a radius 1.0, if angle BAC = 60.0, then the length of BC is ()\nChoices:\nA:2\nB:2\u221a{{3}}\nC:\u221a{{3}}\nD:2\u221a{{2}}
+[Standard Answer]: C
+[Model_answer] : B:2\u221a{{3}}
+Judgement: 0
+""" # noqa
+
+    example_3 = """
+[Question]: Find the domain and range of the function f using interval notation.
+[Standard Answer]: domain: [-4, 0) and range: (-3, 1]
+[Model_answer] : Range: \\((-4, 1]\\)
+Judgement: 0
+""" # noqa
+
+    example_4 = """
+[Question]: As shown in the figure, circle O has a radius 1.0, if angle BAC = 60.0, then the length of BC is ()\nChoices:\nA:2\nB:2\u221a{{3}}\nC:\u221a{{3}}\nD:2\u221a{{2}}
+[Standard Answer]: C
+[Model_answer] : null
+Judgement: 0
+""" # noqa
+
+    return [example_1, example_2, example_3, example_4]
+
+
+def build_mathverse_gpt4_extract_prompt(line):
+    task_description = """
+I am providing you a response from a model to a math problem, termed 'Model Response'. You should extract the answer from the response as 'Extracted Answer'. Directly output the extracted answer with no explanation.\n\n
+""" # noqa
+    prediction = str(line['prediction'])
+    demo_prompt = task_description
+    examples = get_gpt4_extract_ICE()
+    for example in examples:
+        demo_prompt += example + '\n\n'
+    test_prompt = f"Model response: '{prediction}'\nExtracted Answer: "
+    full_prompt = f'{demo_prompt}7.\n{test_prompt}'
+
+    return full_prompt
+
+
+def build_mathverse_gpt4_score_prompt(line):
+    task_description = """
+Below are two answers to a math question. Question is [Question], [Standard Answer] is the standard answer to the question, and [Model_answer] is the answer extracted from a model's output to this question.  Determine whether these two answers are consistent.
+Please note that only when the [Model_answer] completely matches the [Standard Answer] means they are consistent. For non-multiple-choice questions, if the meaning is expressed in the same way, it is also considered consistent, for example, 0.5m and 50cm.
+If they are consistent, Judement is 1; if they are different, Judement is 0.\n\n
+""" # noqa
+    question_for_eval = line['question_for_eval']
+    extract = line['extract']
+    answer = line['answer']
+    demo_prompt = task_description
+    examples = get_gpt4_score_ICE()
+    for example in examples:
+        demo_prompt += example + '\n\n'
+    test_prompt = f"""
+    [Question]: {question_for_eval}
+    [Standard Answer]: {answer}
+    [Model_answer] : {extract}
+    Judgement:"""
+    full_prompt = f'{demo_prompt}{test_prompt}'
+
+    return full_prompt
+
+
+def post_check_score(line, prefetch=False):
+    ans = str(line['answer']).strip()
+    response = str(line['extract']).strip()
+
+    if response == ans:
+        return response if prefetch else True
+    else:
+        return False
+
+
+def MathVerse_auxeval_extract(model, line):
+    prompt = build_mathverse_gpt4_extract_prompt(line)
+    log = ''
+    retry = 5
+    for i in range(retry):
+        prediction = line['prediction']
+        res = model.generate(prompt, temperature=i * 0.5)
+
+        if FAIL_MSG in res:
+            log += f'Try {i}: output is {prediction}, failed to parse.\n'
+        else:
+            log += 'Succeed'
+            return dict(log_extract=log, extract=res)
+    log += 'All 5 retries failed.\n'
+    return dict(log_extract=log, extract='')
+
+
+def MathVerse_auxeval_score(model, line):
+    prompt = build_mathverse_gpt4_score_prompt(line)
+    log = ''
+    retry = 5
+    if post_check_score(line, prefetch=True):
+        res = post_check_score(line, prefetch=True)
+        return dict(log_score='Prefetch succeed', score=True)
+    for i in range(retry):
+        prediction = line['prediction']
+        res = model.generate(prompt, temperature=i * 0.5)
+
+        if FAIL_MSG in res or res.strip() not in ['0', '1']:
+            log += f'Try {i}: output is {prediction}, res is {res}, failed to parse.\n'
+        else:
+            log += 'Succeed'
+            return dict(log_score=log, score=int(res) == 1)
+    log += 'All 5 retries failed.\n'
+    return dict(log_score=log, score=False)
+
+
+def MathVerse_acc(result_file):
+    df = load(result_file)
+
+    df['metadata'] = df['metadata'].apply(lambda x: x.replace("'", '"'))
+    df['metadata'] = df['metadata'].apply(json.loads)
+    df_metadata = pd.json_normalize(df['metadata'])
+    df = pd.concat([df.drop('metadata', axis=1), df_metadata], axis=1)
+
+    subset = list(set(df['problem_version']))
+
+    res = defaultdict(list)
+    for p in subset:
+        if p != 'Overall':
+            sub = df[df['problem_version'] == p]
+        else:
+            sub = cp.deepcopy(df)
+        res['split'].append(p)
+        # Overall Acc
+        res['Overall'].append(np.mean(sub['score']) * 100)
+        # Subject
+        subjects = set(df['subject'])
+        for k in subjects:
+            res[k].append(np.mean(sub[sub['subject'] == k]['score']) * 100)
+        # Subfield
+        subfields = set(df['subfield'])
+        for k in subfields:
+            res[k].append(np.mean(sub[sub['subfield'] == k]['score']) * 100)
+
+    return pd.DataFrame(res)
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/__pycache__/utils.cpython-310.pyc b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/__pycache__/utils.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ddb79692ac233771c4adda095a7d16ca3d3d1a24
Binary files /dev/null and b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/__pycache__/utils.cpython-310.pyc differ
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/parsing/__pycache__/answer_str_parse.cpython-310.pyc b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/parsing/__pycache__/answer_str_parse.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..56c42c104eca9a7d9907af48cca7f237344ee4ab
Binary files /dev/null and b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/parsing/__pycache__/answer_str_parse.cpython-310.pyc differ
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/parsing/__pycache__/dummy_parse.cpython-310.pyc b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/parsing/__pycache__/dummy_parse.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eff3a117ef1ed57419a6128bc9baa531bf04c886
Binary files /dev/null and b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/parsing/__pycache__/dummy_parse.cpython-310.pyc differ
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/parsing/__pycache__/json_parse.cpython-310.pyc b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/parsing/__pycache__/json_parse.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ee48ed6e5fe48bd8ae034279baa0a56233fefd91
Binary files /dev/null and b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/parsing/__pycache__/json_parse.cpython-310.pyc differ
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/parsing/common/__pycache__/parsers.cpython-310.pyc b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/parsing/common/__pycache__/parsers.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a8aa21d6b9bc45be5f7ada55a75093c239b78111
Binary files /dev/null and b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/parsing/common/__pycache__/parsers.cpython-310.pyc differ
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/parsing/common/__pycache__/utils.cpython-310.pyc b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/parsing/common/__pycache__/utils.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..775f03a34c21008d148dd8ed338ebe644f380497
Binary files /dev/null and b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/parsing/common/__pycache__/utils.cpython-310.pyc differ
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/parsing/common/parsers.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/parsing/common/parsers.py
new file mode 100644
index 0000000000000000000000000000000000000000..b3d652a83365b1ef162642390007f6c3651f7702
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/parsing/common/parsers.py
@@ -0,0 +1,145 @@
+import ast
+import json
+import re
+import regex  # Supports the non-standard ?R regex operator
+from typing import List
+from .utils import extract_code_block_content, extract_answer_at_beginning_of_line
+
+
+PARSING_TIMEOUT = 0.1
+
+
+def parse_json(response: str):
+    """Parse the JSON object, including nested JSON strings."""
+
+    response_ = extract_answer_at_beginning_of_line(response)
+
+    # If it's wrapped in code block like json, drop it
+    response_, _ = extract_code_block_content(response_, "json")
+
+    # Regular expression to match JSON-like structures, including nested quotes
+    json_pattern = r"(\{(?:[^{}]|(?R))*\}|\[(?:[^{}]|(?R))*\])"
+    string_pattern = r'"(?:\\.|[^"\\])*"'
+
+    # Find all potential JSON objects
+    try:
+        potential_jsons = regex.findall(
+            json_pattern, response_, timeout=PARSING_TIMEOUT
+        )
+    except TimeoutError:
+        if response_.startswith("["):
+            return []
+        return {}
+
+    valid_jsons = []
+
+    for potential_json in potential_jsons:
+        # Replace escaped quotes with a placeholder
+        potential_json = potential_json.replace('\\"', "__DOUBLE_QUOTE__")
+        potential_json = potential_json.replace("\\'", "__SINGLE_QUOTE__")
+
+        # Find all string literals
+        strings = regex.findall(string_pattern, potential_json)
+
+        # Process each string literal
+        for s in strings:
+            # Unescape the string content
+            unescaped = (
+                s[1:-1]
+                .replace("__DOUBLE_QUOTE__", '"')
+                .replace("__SINGLE_QUOTE__", "'")
+            )
+            # Try to parse it as JSON
+            try:
+                parsed = json.loads(unescaped)
+                if isinstance(parsed, (dict, list)):
+                    # If it's a valid JSON object or array, replace it in the original string
+                    potential_json = potential_json.replace(s, json.dumps(parsed))
+            except json.JSONDecodeError:
+                pass
+
+        # Restore escaped quotes
+        potential_json = potential_json.replace("__DOUBLE_QUOTE__", '\\"')
+        potential_json = potential_json.replace("__SINGLE_QUOTE__", "\\'")
+
+        try:
+            # Attempt to parse the potential JSON
+            json_object = json.loads(potential_json)
+            valid_jsons.append(json_object)
+        except json.JSONDecodeError:
+            # try to update single quote to double quote for some special failure case
+            # caused by quote's type
+            potential_json_ = re.sub(r"(?<!\w)\'|\'(?!\w)", '"', potential_json)
+            try:
+                json_object = json.loads(potential_json_)
+                valid_jsons.append(json_object)
+            except json.JSONDecodeError:
+                # If parsing still fails, it's not a valid JSON object
+                pass
+
+        try:
+            # Attempt to parse the Python structure
+            valid_jsons.append(ast.literal_eval(potential_json))
+            continue
+        except (SyntaxError, ValueError):
+            pass
+        # Escape the backslashes.
+        potential_json = potential_json.replace('\\"', '\\\\"')
+        potential_json = potential_json.replace("\\'", "\\\\'")
+        try:
+            # Attempt to parse the Python structure
+            valid_jsons.append(ast.literal_eval(potential_json))
+        except (SyntaxError, ValueError):
+            pass
+
+    # Return the last valid JSON if any, otherwise an empty dict or list
+    if valid_jsons:
+        return valid_jsons[-1]
+    if response_.startswith("["):
+        return []
+    return {}
+
+
+def parse_nested_str_list(input_string):
+    # Add quotation marks around the words in the string
+    quoted_string = re.sub(r"(\w+)", r'"\1"', input_string)
+
+    # Safely evaluate the string as a Python object
+    try:
+        python_object = ast.literal_eval(quoted_string)
+        return python_object
+    except (ValueError, SyntaxError) as e:
+        print(f"Failed to convert string to Python object: {e}")
+        return input_string
+
+
+def parse_syllable_ranges(input_str: str) -> List[List[int]]:
+    """Convert a bunch of syllable ranges into a list of intervals.
+
+    Examples:
+        parse_syllable_ranges('[7,10][7, 10][5,7][5,7][7,10]')
+        >>> [[7, 10], [7, 10], [5, 7], [5, 7], [7, 10]]
+        parse_syllable_ranges('575 575')
+        >>> [[5, 5], [7, 7], [5, 5], [0, 0], [5, 5], [7, 7], [5, 5]]
+        parse_syllable_ranges('[11]5')
+        >>> [[11, 11], [5, 5]]
+    """
+
+    def convert_to_range(match):
+        match = match.strip("[]")
+        if "," in match:
+            start, end = map(int, match.split(","))
+            return [start, end]
+        elif match == " ":
+            return [0, 0]
+        else:
+            num = int(match)
+            return [num, num]
+
+    # Split the input string into chunks
+    chunks = re.findall(r"(?:\[\d+(?:,\s*\d+)?\]|\d| )", input_str.strip())
+
+    # Convert each chunk to a range and create the result list
+    result = [convert_to_range(chunk) for chunk in chunks]
+
+    return result
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/parsing/common/utils.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/parsing/common/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..75e6f5fae8e1e319faafa511a5838c31d6ef28e3
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/parsing/common/utils.py
@@ -0,0 +1,138 @@
+import re
+import ast
+
+
+def extract_code_block_content(
+    response,
+    code_type=None,
+    is_ascii_art: bool = False,
+    should_remove_surrounding_whitespace=True,
+):
+    # If code_type is specified, construct the pattern to match that specific code block
+    if code_type:
+        pattern = rf"```{code_type}\s*\n*(.*?)\s*```"
+    elif is_ascii_art:
+        if not response.strip() or len(response) > 10000:
+            # handle the special case of pure whitespace or super long empty string
+            response = response.rstrip()
+        if should_remove_surrounding_whitespace:
+            pattern = r"```\w*(?:\s*\n+)?(.*?)\s*```"
+        else:
+            pattern = r"```\w*(?:\s*\n+)?(.*?)(?:\n+\s*)?```"
+    else:
+        # If code_type is None, match any code block
+        pattern = r"```\w*\s*\n*(.*?)\s*```"
+
+    # Search for the code block in the response
+    match = re.search(pattern, response, flags=re.DOTALL)
+
+    if match:
+        # If a match is found, return the content inside the code block
+        if is_ascii_art:
+            return match.group(1), True
+        else:
+            return match.group(1).strip(), True
+    else:
+        # If no code block is found, return the original string
+        return response, False
+
+
+def extract_answer_content(
+    response, is_ascii_art=False, should_remove_surrounding_whitespace=True
+):
+    if is_ascii_art:
+        match = re.search(r"\*\*?Answer:(.*?)\*\*?|\bAnswer:(.*)", response, re.DOTALL)
+    else:
+        match = re.search(
+            r"\*\*?Answer:\s*(.*?)\*\*?|\bAnswer:\s*(.*)", response, re.DOTALL
+        )
+    if match:
+        # Extract the content after "Answer:"
+        response = match.group(1) or match.group(
+            2
+        )  # Return the first capturing group or second if the first is None
+        if response is None:
+            response = ""
+    if is_ascii_art:
+        # Reduce anything that is more than one blank line to a single blank line.
+        response = re.sub(r"^\s*$(\n^\s*$)+", "", response, flags=re.MULTILINE)
+
+        if should_remove_surrounding_whitespace:
+            # Remove trailing whitespace
+            response = response.rstrip()
+        else:
+            # Remove trailing blank lines
+            response = re.sub(r"(\n\s*)+$", "", response)
+        # Remove leading blank lines
+        response = re.sub(r"^(\s*\n)+", "", response)
+    else:
+        response = response.strip()
+
+    return response
+
+
+def extract_answer_at_beginning_of_line(response):
+    # Regular expression to match either "Answer:" or "**Answer:**" at the beginning of a new line
+    match = re.search(r"^(?:\*\*Answer:|Answer:)\s*(.+)", response, re.MULTILINE)
+
+    if match:
+        # Return the content after "Answer:" or "**Answer: **"
+        return match.group(1).strip()
+    else:
+        # Return None if no match is found
+        return response.strip()
+
+
+def drop_additional_text(result):
+    # Heuristic to catch multiple-choice queries. Does not use metadata.json.
+    result_first_paragraph = result.split("\n\n")[0].strip()
+    potential_ans_in_single_line = re.search(
+        r"^(?:(?:[a-zA-Z0-9_-]+)(?:,\s*[a-zA-Z0-9_-]+)*|(?:[a-zA-Z0-9_-]+)\.|\((?:[a-zA-Z0-9_-]+)\)$)",
+        result_first_paragraph,
+    )
+
+    only_return_first_paragraph = (
+        potential_ans_in_single_line
+        and result_first_paragraph.strip() != ""
+        and not _is_multiline_answer(result)
+    )
+
+    if only_return_first_paragraph:
+        return result_first_paragraph
+    else:
+        return result
+
+
+def _is_multiline_answer(text):
+    # Split the text into lines
+    lines = text.splitlines()
+
+    # Find the "Answer:" line
+    for i, line in enumerate(lines):
+        stripped_line = line.strip()
+        if stripped_line != "":
+            # Check if the next line (second line after "Answer:") is blank
+            if i + 1 < len(lines) and lines[i + 1].strip() == "":
+                return False  # Second line is blank, single-line answer,
+                # remaining parts are additional
+            return True  # Second line is not blank, multi-line answer
+
+    return False  # empty result found, treat as single-line
+
+
+def evaluate_as_string(s):
+    try:
+        # Try to evaluate the string using ast.literal_eval
+        evaluated = ast.literal_eval(s)
+        # If it's a valid Python string, return it
+        if isinstance(evaluated, str):
+            return evaluated
+        else:
+            # If it's not a string, return the original input
+            return s
+    except (ValueError, SyntaxError):
+        # If it's not valid, return the original input
+        return s
+    except MemoryError:
+        # the result overflows, simply return an empty string
+        return ""
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/ascii_art_gpt4o_judge.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/ascii_art_gpt4o_judge.py
new file mode 100644
index 0000000000000000000000000000000000000000..412d7a11492e1423561938ddb2fc671a941f1ad0
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/ascii_art_gpt4o_judge.py
@@ -0,0 +1,126 @@
+"""Return if two ASCII art images depict the same thing."""
+
+import logging
+from numbers import Number
+import os
+import requests
+from .common.conversions import ascii_text_to_image
+from .vlm_as_judge import OpenAIVLMJudger
+"""Return if two ASCII art images depict the same thing."""
+
+
+class AsciiArtGPT4OJudge(OpenAIVLMJudger):
+    """A GPT-4o judge for assessing if two ASCII art images depict the same thing."""
+
+    def __init__(self, metric_config, model="gpt-4o-2024-08-06"):
+        self.eval_prompt = """Determine if the following two ASCII art images depict the same object.
+        Your answer should be either "yes" or "no", but without the quotation marks."""
+        super().__init__(
+            metric_config,
+            model,
+        )
+
+    def encode_image(self, image):
+        """Encode an image into base64 and return its mime type."""
+        mime_type = "image/jpeg"
+        image_format = "JPEG"
+
+        if image.mode == "RGBA":
+            image = self._rgba_to_rgb(image)
+
+        if self.resize and max(image.size) > self.max_side:
+            image = self._resize_image(image)
+            encoded_image = self._encode_image(image, image_format)
+        else:
+            encoded_image = self._encode_image(image, image_format)
+
+        return encoded_image, mime_type
+
+    def create_image_content(self, image):
+        base64_image, mime_type = self.encode_image(image)
+        return {
+            "type": "image_url",
+            "image_url": {"url": f"data:{mime_type};base64,{base64_image}"},
+        }
+
+    def prepare_eval_prompt(self, images):
+        """Prepare the evaluation prompt."""
+        content = []
+        for image_path in images:
+            content.append(self.create_image_content(image_path))
+
+        content.append({"type": "text", "text": self.eval_prompt})
+        return content
+
+    def query(self, images):
+        """Query GPT4o to determine if the ASCII images show the same thing."""
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+        }
+
+        context = self.prepare_eval_prompt(images)
+
+        query_payload = {
+            "model": self.model,
+            "messages": [{"role": "user", "content": context}],
+            "temperature": 0.0,
+        }
+
+        response_data = None
+        while response_data is None:
+            try:
+                response = requests.post(
+                    self.url,
+                    headers=headers,
+                    json=query_payload,
+                )
+            except (requests.exceptions.JSONDecodeError, requests.exceptions.ConnectionError) as e:
+                print(f'Error in requests: {e}')
+                print('Retry...')
+                continue
+
+            response_ = response.json()
+            if "error" in response_:
+                error_info = response_["error"]
+                print(
+                    f"Got error with type: {error_info['type']}. Message: {error_info['message']}"
+                )
+                print("Retry...")
+            else:
+                response_data = response_
+                break
+
+        total_tokens = response_data.get("usage", {}).get("total_tokens", "N/A")
+
+        if response_data and "choices" in response_data:
+            choices = response_data["choices"]
+            if choices and "message" in choices[0]:
+                message_content = choices[0]["message"]["content"]
+                print(
+                    f"gpt-4o judge results: {message_content}; tokens:{total_tokens}"
+                )
+        else:
+            print("gpt-4o judge query failed...")
+            message_content = ""
+
+        return message_content
+
+
+class AsciiArtVLMJudgeScore:
+    """Compute the cosine similarity between two pieces of ASCII art."""
+
+    def __init__(self, metric_config):
+        self.model = AsciiArtGPT4OJudge(metric_config)
+
+    def match(self, response, correct_answer) -> Number:
+        """Compute the cosine similarity between two pieces of ASCII art."""
+        if not isinstance(response, str) or not isinstance(correct_answer, str):
+            return 0
+        if not response:
+            return 0
+        response_image = ascii_text_to_image(response, 224, 224)
+        correct_answer_image = ascii_text_to_image(correct_answer, 224, 224)
+
+        eval_results = self.model.query([response_image, correct_answer_image])
+        return 1 if "yes" in eval_results.lower() else 0
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/common/conversions.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/common/conversions.py
new file mode 100644
index 0000000000000000000000000000000000000000..932132323d2c78e0fb8f07cd421bc034bad6cf95
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/common/conversions.py
@@ -0,0 +1,244 @@
+import ast
+import json
+import re
+from matplotlib import font_manager
+from PIL import Image, ImageDraw, ImageFont
+from ...parsing.common.parsers import parse_json
+from numbers import Number
+from typing import Tuple, Union
+
+
+def freeze_structure(obj):
+    """Freeze a structure and make it hashable."""
+    if isinstance(obj, dict):
+        return frozenset((k, freeze_structure(v)) for k, v in obj.items())
+    elif isinstance(obj, (list, tuple)):
+        return tuple(freeze_structure(item) for item in obj)
+    elif isinstance(obj, set):
+        return frozenset(obj)
+    else:
+        return obj
+
+
+def cast_to_set(object) -> set:
+    """Try to cast an object as a set."""
+    object = freeze_structure(object)
+    if isinstance(object, (frozenset, set, tuple)):
+        return set(object)
+    return str_to_set(object)
+
+
+def cast_to_dict(object) -> dict:
+    """Try to cast an object as a dict."""
+    if isinstance(object, dict):
+        return {key: cast_to_dict(val) for key, val in object.items()}
+    elif isinstance(object, str):
+        extract_json_attempt = parse_json(object)
+        if extract_json_attempt:
+            return extract_json_attempt
+        return object
+    else:
+        return object
+
+
+def str_to_iterable(func, iterable_str):
+    """Converts a string representation of an iterable to an iterable."""
+    if not isinstance(iterable_str, str):
+        return func()
+
+    iterable_str = iterable_str.strip(" ")
+    if not iterable_str:
+        return func()
+
+    is_in_iterable = True
+    if iterable_str[0] == "(":
+        if not iterable_str.endswith(")"):
+            return func()
+    elif iterable_str[0] == "{":
+        if not iterable_str.endswith("}"):
+            return func()
+    elif iterable_str[0] == "[":
+        if not iterable_str.endswith("]"):
+            return func()
+    else:
+        is_in_iterable = False
+
+    # We may have a nested object, so try to use eval first
+    try:
+        eval_ = ast.literal_eval(iterable_str)
+        if eval_ is None:
+            return ""
+        if isinstance(eval_, (int, float)):
+            eval_ = [
+                eval_,
+            ]
+        return func(eval_)
+    except (SyntaxError, ValueError):
+        if is_in_iterable:
+            iterable_str = iterable_str[1:-1]
+        items = [item.strip() for item in iterable_str.split(",")]
+        return func(items)
+
+
+def str_to_set(iterable_str) -> set:
+    """Converts a string representation of an iterable to a set."""
+    return str_to_iterable(set, iterable_str)
+
+
+def str_to_list(iterable_str) -> set:
+    """Converts a string representation of an iterable to a set."""
+    return str_to_iterable(list, iterable_str)
+
+
+def str_to_bboxes(bbox_list) -> list:
+    if not isinstance(bbox_list, str):
+        return []
+    try:
+        bboxes = ast.literal_eval(bbox_list)
+    except (SyntaxError, ValueError):
+        try:
+            bboxes = json.loads(bbox_list)
+        except json.JSONDecodeError:
+            return []
+
+    if len(bboxes) == 4 and isinstance(bboxes[0], Number):
+        bboxes = [bboxes]
+
+    if not isinstance(bboxes, (tuple | list)):
+        return []
+
+    new_bboxes = []
+    for bbox in bboxes:
+        if not isinstance(bbox, (tuple, list)) or len(bbox) != 4:
+            continue
+        if any(not isinstance(coord, (float, int)) for coord in bbox):
+            continue
+        new_bboxes.append(bbox)
+    return new_bboxes
+
+
+def str_to_coords(coord_list, dim=2) -> list:
+    if not isinstance(coord_list, str):
+        return []
+    try:
+        coords = ast.literal_eval(coord_list)
+    except SyntaxError:
+        try:
+            coords = json.loads(coord_list)
+        except json.JSONDecodeError:
+            return []
+
+    new_coords = []
+    for coord in coords:
+        if not isinstance(coord, (tuple, list)) or len(coord) != dim:
+            continue
+        if any(not isinstance(coord, (float, int)) for coord in coord):
+            continue
+        new_coords.append(coord)
+    return new_coords
+
+
+def parse_point_2d_from_xml(xml_string) -> Union[Tuple[float, float], None]:
+    """Parse an (x, y) point from XML formatted like this: <point>x, y</point>"""
+    if not isinstance(xml_string, str):
+        return None
+
+    point_pattern = re.compile(r"<point>(.*?)<\/point>")
+    matches = point_pattern.findall(xml_string)
+    if len(matches) >= 2:
+        return None
+
+    if matches:
+        coords = matches[0].split(",")
+        if len(coords) != 2:
+            return None
+        try:
+            return tuple(float(coord.strip()) for coord in coords)
+        except ValueError:
+            return None
+
+
+def parse_bboxes_from_xml(xml_string: str) -> list:
+
+    if not isinstance(xml_string, str):
+        return []
+
+    bbox_pattern = re.compile(r"<box>(.*?)<\/box>")
+    matches = bbox_pattern.findall(xml_string)
+
+    new_bboxes = []
+    for match in matches:
+
+        coords = match.split(",")
+        if len(coords) != 4:
+            continue
+        try:
+            bbox = tuple(float(coord.strip()) for coord in coords)
+        except ValueError:
+            continue
+
+        if len(bbox) == 4 and all(isinstance(coord, float) for coord in bbox):
+            new_bboxes.append(bbox)
+
+    return new_bboxes
+
+
+MONOSPACE_FONTS = ("Courier New", "DejaVu Sans Mono", "Consolas", "SF Mono")
+
+MONOSPACE_FONT_FILES = []
+for font_name in MONOSPACE_FONTS:
+    try:
+        MONOSPACE_FONT_FILES.append(
+            font_manager.findfont(font_name, fallback_to_default=False)
+        )
+    except ValueError:
+        continue
+
+
+def ascii_text_to_image(
+    text,
+    width,
+    height,
+    font_size=20,
+    padding=10,
+    line_spacing=1,
+    bg_color="white",
+    text_color="black",
+):
+    """Convert ASCII text into an image."""
+    # Split the text into lines
+    lines = text.splitlines()
+
+    # Calculate initial image size based on text
+    char_width = font_size * 0.6  # Approximate width of a character
+    init_width = int(max(len(line) for line in lines) * char_width + 2 * padding)
+    init_height = int(
+        (len(lines) * font_size * line_spacing) + 2 * padding
+    )  # 1.2 for line spacing
+
+    # Create a new image with the calculated size
+    image = Image.new("RGB", (init_width, init_height), color=bg_color)
+    draw = ImageDraw.Draw(image)
+
+    # Load a monospace font
+    font = None
+    for font_name in MONOSPACE_FONT_FILES:
+        try:
+            font = ImageFont.truetype(font_name, font_size)
+            break
+        except IOError:
+            continue
+    if font is None:
+        raise ValueError("Cannot properly render ASCII art: missing monospace font.")
+
+    # Draw each line of text
+    y_text = padding
+    for line in lines:
+        draw.text((padding, y_text), line, font=font, fill=text_color)
+        y_text += font_size * line_spacing  # Move to the next line
+
+    # Resize the image to the specified dimensions
+    image = image.resize((width, height), Image.Resampling.LANCZOS)
+
+    # Convert the image to a NumPy array
+    return image
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/common/metrics.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/common/metrics.py
new file mode 100644
index 0000000000000000000000000000000000000000..8b7b2807910413593187c94c91259fb1b16d5151
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/common/metrics.py
@@ -0,0 +1,102 @@
+from collections.abc import Iterable
+import math
+from numbers import Number
+
+
+def calculate_iou(predicted: Iterable[Number], target: Iterable[Number]):
+    """Calculate the IoU between predicted and target bounding boxes."""
+
+    def box_area(box):
+        return (box[2] - box[0]) * (box[3] - box[1])
+
+    def box_iou(box1, box2):
+        # Calculate intersection coordinates
+        x1 = max(box1[0], box2[0])
+        y1 = max(box1[1], box2[1])
+        x2 = min(box1[2], box2[2])
+        y2 = min(box1[3], box2[3])
+
+        # Calculate intersection area
+        intersection = max(0, x2 - x1) * max(0, y2 - y1)
+
+        # Calculate union area
+        box1_area = box_area(box1)
+        box2_area = box_area(box2)
+        union = box1_area + box2_area - intersection
+
+        # Calculate IoU
+        iou = intersection / union if union > 0 else 0
+        return iou
+
+    # Calculate IoU for each pair of predicted and target boxes
+    iou_scores = []
+    for pred_box in predicted:
+        best_iou = 0
+        for target_box in target:
+            iou = box_iou(pred_box, target_box)
+            best_iou = max(best_iou, iou)
+        iou_scores.append(best_iou)
+
+    return iou_scores
+
+
+def set_relevance_score(denominator_fn, predicted: Iterable, target: Iterable) -> float:
+    """Calculate the relevance score."""
+    pred = set(predicted)
+    tget = set(target)
+    denominator = denominator_fn(pred, tget)
+    if not denominator:
+        return 1
+    return len(pred & tget) / denominator
+
+
+def _union_denominator(pred: set, tget: set) -> int:
+    return len(pred | tget)
+
+
+def _pred_denominator(pred: set, _: set) -> int:
+    return len(pred)
+
+
+def _tget_denominator(_: set, tget: set) -> int:
+    return len(tget)
+
+
+def jaccard_index(predicted: Iterable, target: Iterable) -> float:
+    """Calculate the Jaccard Index."""
+    return set_relevance_score(_union_denominator, predicted, target)
+
+
+def set_precision(predicted: Iterable, target: Iterable) -> float:
+    """Calculate the precision, using sets."""
+    return set_relevance_score(_pred_denominator, predicted, target)
+
+
+def set_recall(predicted: Iterable, target: Iterable) -> float:
+    """Calculate the recall, using sets."""
+    return set_relevance_score(_tget_denominator, predicted, target)
+
+
+def longest_common_prefix(list1: list, list2: list) -> list:
+    """Return the longest common prefix."""
+    index_first_difference = next(
+        (i for i, (a, b) in enumerate(zip(list1, list2)) if a != b),
+        min(len(list1), len(list2)),
+    )
+    return list1[:index_first_difference]
+
+
+def mse(predicted: Number, target: Number) -> Number:
+    """Return the mean squared error."""
+    return (predicted - target) ** 2
+
+
+def point_distance(predicted: tuple[float, ...], target: tuple[float, ...]):
+    """Return the distance between two points."""
+    if len(predicted) != len(target):
+        raise ValueError(
+            "point_distance: Predicted and target points have different dimensions."
+        )
+    return math.sqrt(
+        sum((comp_res - comp_tar) ** 2 for comp_res, comp_tar in zip(predicted, target))
+    )
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/common/transformations.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/common/transformations.py
new file mode 100644
index 0000000000000000000000000000000000000000..380d26e061de532af3fd75705c07a896d5b08b63
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/common/transformations.py
@@ -0,0 +1,120 @@
+"""Like-to-like data transformations."""
+
+import re
+import unicodedata
+
+
+def remove_def_indef_articles(text: str) -> str:
+    """Remove definite and indefinite articles."""
+    text_list = [t for t in text.split(" ") if t.lower() not in {"the", "a"}]
+    return " ".join(text_list)
+
+
+def replace_macrons_with_latex_overline(text: str) -> str:
+    """Replace letters with macrons with the LaTeX bar."""
+    result = []
+    for char in text:
+        if char.isalpha():
+            decomposed = unicodedata.normalize("NFD", char)
+            if len(decomposed) > 1 and decomposed[1] == "\u0304":  # Macron accent
+                result.append(f"\\overline{{{decomposed[0]}}}")
+            else:
+                result.append(char)
+        elif char != "\u0304":
+            result.append(char)
+        else:
+            result[-1] = f"\\overline{{{result[-1]}}}"
+
+    return "".join(result)
+
+
+def fix_overline_underscores(text: str) -> str:
+    """Puts underscores that are outside \overline within overline."""
+    pattern = r"\\overline\{([^}]*)\}_([^{}\\ ]*)"
+    return re.sub(pattern, r"\\overline{\1_\2}", text)
+
+
+# Dictionary mapping Unicode Greek letters to LaTeX equivalents
+greek_to_latex = {
+    # Lowercase Greek letters
+    "α": "\\alpha",
+    "β": "\\beta",
+    "γ": "\\gamma",
+    "δ": "\\delta",
+    "ε": "\\epsilon",
+    "ζ": "\\zeta",
+    "η": "\\eta",
+    "θ": "\\theta",
+    "ι": "\\iota",
+    "κ": "\\kappa",
+    "λ": "\\lambda",
+    "μ": "\\mu",
+    "ν": "\\nu",
+    "ξ": "\\xi",
+    "ο": "\\omicron",
+    "π": "\\pi",
+    "ρ": "\\rho",
+    "σ": "\\sigma",
+    "τ": "\\tau",
+    "υ": "\\upsilon",
+    "φ": "\\phi",
+    "χ": "\\chi",
+    "ψ": "\\psi",
+    "ω": "\\omega",
+    # Uppercase Greek letters
+    "Α": "\\Alpha",
+    "Β": "\\Beta",
+    "Γ": "\\Gamma",
+    "Δ": "\\Delta",
+    "Ε": "\\Epsilon",
+    "Ζ": "\\Zeta",
+    "Η": "\\Eta",
+    "Θ": "\\Theta",
+    "Ι": "\\Iota",
+    "Κ": "\\Kappa",
+    "Λ": "\\Lambda",
+    "Μ": "\\Mu",
+    "Ν": "\\Nu",
+    "Ξ": "\\Xi",
+    "Ο": "\\Omicron",
+    "Π": "\\Pi",
+    "Ρ": "\\Rho",
+    "Σ": "\\Sigma",
+    "Τ": "\\Tau",
+    "Υ": "\\Upsilon",
+    "Φ": "\\Phi",
+    "Χ": "\\Chi",
+    "Ψ": "\\Psi",
+    "Ω": "\\Omega",
+}
+
+
+def replace_greek_letters(text: str) -> str:
+    """Replace Greek letters in Unicode with their LaTeX equivalents."""
+    return re.sub(r"[α-ωΑ-Ω]", lambda match: greek_to_latex[match.group()] + " ", text)
+
+
+def remove_latex_math_delimiters(latex_str):
+    # Pattern to match \begin{...}[...] and \end{...}[...] commands
+    env_pattern = r"\\(begin|end)\{.*?\}(?:\[[^\[\]]*\])?"
+    latex_str = re.sub(env_pattern, "", latex_str)
+
+    # Remove \( and \)
+    inline_math_pattern = r"\\\(|\\\)"
+    latex_str = re.sub(inline_math_pattern, "", latex_str)
+
+    # Remove \[ and \]
+    display_math_pattern = r"\\\[|\\\]"
+    latex_str = re.sub(display_math_pattern, "", latex_str)
+
+    return latex_str
+
+
+def normalize_latex(text: str) -> str:
+    """Normalize the LaTeX expression."""
+    text = text.replace("\\bar", "\\overline")
+    text = replace_macrons_with_latex_overline(text)
+    text = fix_overline_underscores(text)
+    text = replace_greek_letters(text)
+    text = remove_latex_math_delimiters(text)
+    return text
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/dict_equality.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/dict_equality.py
new file mode 100644
index 0000000000000000000000000000000000000000..326e0bd34a31a70f574d2dfa46b08f19cd6e9e96
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/dict_equality.py
@@ -0,0 +1,44 @@
+from .common.conversions import cast_to_dict
+from .simple_str_match import ExactStrMatch
+
+
+class DictEquality:
+    """Calculates the exact string match across the dict.
+
+    1. Calculates the exact match for all keys in the solution
+    2. Calculates the total, then divides by the size of the solution
+    """
+
+    @classmethod
+    def match(cls, responses, targets) -> float:
+        """Return the aggregated Jaccard index between targets and responses."""
+        responses = cast_to_dict(responses)
+        targets = cast_to_dict(targets)
+
+        if not isinstance(responses, dict):
+            return 0
+
+        return 1 if responses == targets else 0
+
+
+class DictPrecision:
+
+    @classmethod
+    def match(cls, responses, targets) -> float:
+        """Return the aggregated Jaccard index between targets and responses."""
+        responses = cast_to_dict(responses)
+        targets = cast_to_dict(targets)
+
+        if not isinstance(responses, dict):
+            return 0
+
+        if len(responses) == 0:
+            return 0
+
+        matched = 0
+        for key, val in responses.items():
+            if key in targets:
+                if ExactStrMatch.match(val, targets[key]):
+                    matched += 1
+
+        return matched / len(responses)
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/dict_exact_match_agg_recall.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/dict_exact_match_agg_recall.py
new file mode 100644
index 0000000000000000000000000000000000000000..5f1901e56df6348cc8a08857aaec8dc069252637
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/dict_exact_match_agg_recall.py
@@ -0,0 +1,27 @@
+from .common.conversions import cast_to_dict
+from .exact_str_match import ExactStrMatch
+
+
+class DictExactStrMatchAggRecall:
+    """Calculates the exact string match across the dict.
+
+    1. Calculates the exact match for all keys in the solution
+    2. Calculates the total, then divides by the size of the solution
+    """
+
+    @classmethod
+    def match(cls, responses, targets) -> float:
+        """Return the aggregated Jaccard index between targets and responses."""
+        responses = cast_to_dict(responses)
+        targets = cast_to_dict(targets)
+
+        if not isinstance(responses, dict):
+            return 0
+
+        num_keys = 0
+        total_score = 0
+        for key, answer in targets.items():
+            total_score += ExactStrMatch.match(responses.get(key), answer)
+            num_keys += 1
+
+        return total_score / num_keys
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/general_numerical_match.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/general_numerical_match.py
new file mode 100644
index 0000000000000000000000000000000000000000..fe3ea14c3cedfc5a4a065b638a0ace44f406d9c3
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/general_numerical_match.py
@@ -0,0 +1,253 @@
+import re
+from .simple_str_match import SimpleStrMatch
+
+from sympy.parsing.latex import parse_latex
+import math
+import multiprocessing
+
+import signal
+
+
+class TimeoutException(Exception):
+    pass
+
+
+def timeout_handler(signum, frame):
+    raise TimeoutException()
+
+
+E = 2.718
+
+############## Begin
+# Numerical comparison from https://github.com/TIGER-AI-Lab/MAmmoTH/blob/main/math_eval/number_utils.py
+
+
+def run_eval(expression, output):
+    try:
+        # Safely evaluate the expression
+        result = eval(expression)
+        output.put(result)
+    except Exception as e:
+        output.put(e)
+
+
+def eval_with_timeout(expression, timeout=5):
+    # Create a multiprocessing.Queue to receive the output
+    output = multiprocessing.Queue()
+
+    # Define and start the process
+    process = multiprocessing.Process(target=run_eval, args=(expression, output))
+    process.start()
+
+    # Wait for the process to complete or timeout
+    process.join(timeout)
+
+    if process.is_alive():
+        # Terminate the process
+        process.terminate()
+        process.join()
+        return "Timeout or error during evaluation"
+
+    # Get result from the queue
+    try:
+        return output.get_nowait()
+    except Exception as e:
+        return "Error retrieving result"
+
+
+def compare_two_list(pred, gt):
+    if not isinstance(pred, list):
+        return False
+    elif len(pred) != len(gt):
+        return False
+    elif any([not isinstance(x, (int, float)) for x in pred]):
+        return False
+    else:
+        pred = sorted(pred)
+        gt = sorted(gt)
+        return all([compare_two_numbers(p, g) for p, g in zip(pred, gt)])
+
+
+def compare_two_numbers(p, gt):
+    try:
+        if math.isnan(p):
+            return False
+        else:
+            return within_eps(pred=p, gt=gt)
+    except Exception:
+        return False
+
+
+def within_eps(pred: float, gt: float):
+    eps = abs(gt) * 0.01
+    if pred >= gt - eps and pred <= gt + eps:
+        return True
+    else:
+        return False
+
+
+def clean_units(pred_str: str):
+    """Clean the units in the number."""
+
+    def convert_pi_to_number(code_string):
+        code_string = code_string.replace("\\pi", "π")
+        # Replace \pi or π not preceded by a digit or } with 3.14
+        code_string = re.sub(r"(?<![\d}])\\?π", "3.14", code_string)
+        # Replace instances where π is preceded by a digit but without a multiplication symbol, e.g., "3π" -> "3*3.14"
+        code_string = re.sub(r"(\d)(\\?π)", r"\1*3.14", code_string)
+        # Handle cases where π is within braces or followed by a multiplication symbol
+        # This replaces "{π}" with "3.14" directly and "3*π" with "3*3.14"
+        code_string = re.sub(r"\{(\\?π)\}", "3.14", code_string)
+        code_string = re.sub(r"\*(\\?π)", "*3.14", code_string)
+        return code_string
+
+    pred_str = convert_pi_to_number(pred_str)
+    pred_str = pred_str.replace("%", "/100")
+    pred_str = pred_str.replace("$", "")
+    pred_str = pred_str.replace("¥", "")
+    pred_str = pred_str.replace("°C", "")
+    pred_str = pred_str.replace(" C", "")
+    pred_str = pred_str.replace("°", "")
+    return pred_str
+
+
+def number_it(num):
+    if isinstance(num, (int, float)):
+        return num
+
+    num = clean_units(num)
+    try:
+        num = str(parse_latex(num))
+    except Exception:
+        pass
+
+    if floatify(num) is not None:
+        return floatify(num)
+    else:
+        try:
+            num = eval_with_timeout(num)
+            if isinstance(num, list) or isinstance(num, tuple):
+                return num  # return num list
+            if floatify(num) is not None:
+                return floatify(num)
+            else:
+                return None
+        except Exception:
+            return None
+
+
+def floatify(num: str):
+    try:
+        num = float(num)
+        if num.is_integer():
+            return round(num)
+        else:
+            return num
+    except Exception:
+        return None
+
+
+def remove_latex_math_brackets(latex_str):
+    """
+    Removes LaTeX math mode delimiters (\( ... \) and \[ ... \]) from a string
+    while preserving the contents inside the delimiters.
+    If no such delimiters are found, the original string is returned.
+    """
+    # Regex pattern for inline math \( ... \)
+    inline_pattern = re.compile(r"\\\((.*?)\\\)")
+    # Regex pattern for TeX inline math $...$
+    tex_inline_pattern = re.compile(r"$(.*?)$")
+    # Regex pattern for display math \[ ... \]
+    display_pattern = re.compile(r"\\\[(.*?)\\\]")
+
+    latex_patterns = (inline_pattern, tex_inline_pattern, display_pattern)
+
+    if any(pattern.search(latex_str) for pattern in latex_patterns):
+        # Remove inline math mode brackets
+        latex_str = inline_pattern.sub(r"\1", latex_str)
+        # Remove display math mode brackets
+        latex_str = display_pattern.sub(r"\1", latex_str)
+    return latex_str
+
+
+def parse_assignment(expression):
+    # match the content after "=", "≈", or "\approx"
+    pattern = r"(?:=|≈|\\approx)\s*(.+)"
+
+    match = re.search(pattern, expression)
+    if match:
+        # Return the content after the sign
+        return match.group(1).strip()
+    else:
+        return expression
+
+
+############## End
+
+
+class GeneralSingleNumericalMatch:
+    """
+    Extract the results from ```\\boxed{xxxx}``` and match with the anaswer
+    """
+
+    @classmethod
+    def match(cls, responses, targets) -> float:
+        if not isinstance(responses, str):
+            responses = str(responses)
+        responses = remove_latex_math_brackets(responses)
+        responses = parse_assignment(responses)
+        targets = remove_latex_math_brackets(targets)
+        targets = parse_assignment(targets)
+        res = number_it(responses)
+        tgt = number_it(targets)
+
+        if res is not None and tgt is not None:
+            if (
+                isinstance(res, list)
+                and isinstance(tgt, list)
+                or isinstance(res, tuple)
+                and isinstance(tgt, tuple)
+            ):
+                score = float(compare_two_list(res, tgt))
+            else:
+                score = float(compare_two_numbers(res, tgt))
+        else:
+            score = SimpleStrMatch.match(responses, targets)
+
+        return score
+
+
+class BoxedSingleNumericalMatch:
+    """
+    Extract the results from ```\\boxed{xxxx}``` and match with the anaswer
+    """
+
+    @staticmethod
+    def parse_boxed_content(text):
+        ###
+        #   Pattern: r'\\boxed\{((?:[^\{\}]+|\{[^\{\}]*\})*)\}':
+        #    \\boxed\{: Matches the literal \boxed{.
+        #    ((?:[^\{\}]+|\{[^\{\}]*\})*): This part matches the content inside the \boxed{}.
+        #    (?:...): A non-capturing group that allows us to match both non-brace content and brace-enclosed content.
+        #    [^\{\}]+: Matches any content that is not an opening { or closing } brace.
+        #    \{[^\{\}]*\}: Matches balanced braces containing non-nested content (e.g., {5} or {3} in the LaTeX expression \frac{5}{3}).
+        ###
+        pattern = r"\\boxed\{((?:[^\{\}]+|\{[^\{\}]*\})*)\}"
+        match = re.search(pattern, text)
+        return match.group(1) if match else text
+
+    @classmethod
+    def match(cls, responses, targets, timeout_duration=10) -> float:
+        if not isinstance(responses, str):
+            responses = str(responses)
+        signal.signal(signal.SIGALRM, timeout_handler)
+        signal.alarm(timeout_duration)  # Set the timeout duration in seconds
+        try:
+            parsed_res = cls.parse_boxed_content(responses)
+            targets = cls.parse_boxed_content(targets)
+            score = GeneralSingleNumericalMatch.match(parsed_res, targets)
+            return score
+        except TimeoutException:
+            return SimpleStrMatch.match(responses, targets)
+        finally:
+            signal.alarm(0)
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/longest_common_list_prefix_ratio.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/longest_common_list_prefix_ratio.py
new file mode 100644
index 0000000000000000000000000000000000000000..ebe652dda47c7525c2a78e0b6496a374fca8b100
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/longest_common_list_prefix_ratio.py
@@ -0,0 +1,15 @@
+from .common.conversions import str_to_list
+from .common.metrics import longest_common_prefix
+
+
+class LongestCommonListPrefixRatio:
+    """Determines how much of the first part of the list
+    was predicted correctly.
+    """
+
+    @classmethod
+    def match(cls, responses, targets) -> int:
+        """Exact match between targets and responses."""
+        responses = str_to_list(responses)
+        targets = str_to_list(targets)
+        return len(longest_common_prefix(responses, targets)) / len(targets)
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/mse.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/mse.py
new file mode 100644
index 0000000000000000000000000000000000000000..c342240c11d45fc8ff9ba963146686dbedabcadd
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/mse.py
@@ -0,0 +1,64 @@
+import ast
+import numpy as np
+import math
+from .common.metrics import mse
+from .common.conversions import str_to_list
+
+
+class MSE:
+    """Mean Squared Error."""
+
+    @staticmethod
+    def match(response: str, correct_answer: str) -> int:
+        """Return the mean squared error."""
+        try:
+            return mse(ast.literal_eval(response), ast.literal_eval(correct_answer))
+        except (SyntaxError, ValueError):
+            return 0
+
+
+class NormalizedRMSE:
+    """Mean Squared Error."""
+
+    MIN = 0.0
+    MAX = 0.1
+
+    @classmethod
+    def match(cls, response: str, correct_answer: str) -> int:
+        """Return the mean squared error."""
+        try:
+            mse_val = mse(ast.literal_eval(response), ast.literal_eval(correct_answer))
+            rmse = np.clip(np.sqrt(mse_val), cls.MIN, cls.MAX)
+            norm_rmse = 1 - (rmse - cls.MIN) / (cls.MAX - cls.MIN)
+            return norm_rmse
+        except (SyntaxError, ValueError):
+            return 0
+
+
+class AngleSeqFloatRMSE:
+    """Whether the sequence of numbers is close enough to the real answer."""
+
+    MIN = 0.0
+    MAX = 10.0
+
+    @classmethod
+    def match(cls, responses, targets) -> float:
+        """Determines whether the sequence of floats are close enough to the real answer."""
+        responses = str_to_list(responses)
+        targets = str_to_list(targets)
+
+        if len(responses) != len(targets):
+            return 0
+
+        try:
+            res = np.array(responses)
+            tgt = np.array(targets)
+            rmse = np.sqrt(mse(res, tgt)).sum() / len(targets)
+        except:  # cannot obtain the rmse from the response, return 0
+            return 0
+
+        rmse = np.clip(rmse, cls.MIN, cls.MAX)
+        norm_rmse = 1 - (rmse - cls.MIN) / (cls.MAX - cls.MIN)
+        if math.isnan(norm_rmse):
+            return 0
+        return norm_rmse
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/multi_ref_phrase.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/multi_ref_phrase.py
new file mode 100644
index 0000000000000000000000000000000000000000..5645be8981c0e4a67daeba9beba461543521bdfd
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/multi_ref_phrase.py
@@ -0,0 +1,26 @@
+from numbers import Number
+from .common.conversions import str_to_iterable
+from .simple_str_match import SimpleStrMatch
+
+
+def replace_potential_chinese_comma(input_string):
+    return input_string.replace("，", ",")
+
+
+class MultipleReferencePhraseEval:
+    """
+    Check the response with multiple correct references
+    As long as one is matched, the score is 1, otherwise the score is 0
+    """
+
+    @staticmethod
+    def match(response, targets) -> Number:
+        targets = replace_potential_chinese_comma(targets)
+        refs = str_to_iterable(list, targets)
+        matched = False
+        for ref in refs:
+            str_ref = ref if isinstance(ref, str) else str(ref)
+            if SimpleStrMatch.match(response, str_ref):
+                matched = True
+                break
+        return 1 if matched else 0
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/nbbox_iou.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/nbbox_iou.py
new file mode 100644
index 0000000000000000000000000000000000000000..3e4021030de1969885b302bd9ad5e2e825de4ce1
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/nbbox_iou.py
@@ -0,0 +1,104 @@
+import logging
+import ast
+from .common.conversions import str_to_bboxes
+from .common.metrics import calculate_iou
+import numpy as np
+
+
+class NbboxIouTuple:
+    """Calculates the IoU, for all bounding boxes, for all predicted bounding boxes.
+    For each predicted bounding box, it uses the IoU with the target bounding box with
+    the highest IoU.
+
+    Assumes that co-ordinates are normalized between 0 and 1 and that the bounding boxes
+    are of the form (x1, y1, x2, y2), where (x1, y1) is the top-left corner and (x2, y2)
+    is the bottom-right.
+    """
+
+    @classmethod
+    def match(cls, responses, targets) -> float:
+        """Exact match between targets and responses."""
+        logging.debug(f"{responses=}, {targets=}")
+        if not isinstance(responses, (tuple | list)):
+            responses = str_to_bboxes(responses)
+        if not isinstance(targets, (tuple | list)):
+            targets = str_to_bboxes(targets)
+
+        try:
+            iou_scores = calculate_iou(responses, targets)
+        except:
+            return 0
+
+        if not iou_scores:
+            return 0
+
+        # Take the mean IoU score for now.
+        return sum(iou_scores) / len(iou_scores)
+
+
+class NbboxIouSingle:
+    """
+    Single bbox IoU metric
+    """
+
+    @classmethod
+    def match(cls, responses, targets) -> float:
+        """Exact match between targets and responses."""
+        logging.debug(f"{responses=}, {targets=}")
+        targets = ast.literal_eval(targets)
+        try:
+            responses = ast.literal_eval(responses)
+        except SyntaxError:
+            return 0
+
+        try:
+            iou_scores = calculate_iou(
+                [
+                    responses,
+                ],
+                [
+                    targets,
+                ],
+            )
+            if not iou_scores:
+                return 0
+        except:
+            return 0
+
+        # Take the mean IoU score for now.
+        return sum(iou_scores) / len(iou_scores)
+
+
+class NbboxIouSequence:
+    """
+    Metric for a sequence of bboxes (used for single object tracking).
+    The number of predicted boxes must match the ground truth.
+    """
+
+    @classmethod
+    def match(cls, responses, targets) -> float:
+        """Exact match between targets and responses."""
+        if not isinstance(responses, (tuple | list)):
+            responses = str(responses) if not isinstance(responses, str) else responses
+            responses = str_to_bboxes(responses)
+        if not isinstance(targets, (tuple | list)):
+            targets = str_to_bboxes(targets)
+
+        if len(targets) != len(responses):
+            return 0
+
+        scores = []
+        for res, tgt in zip(responses, targets):
+            scores.append(
+                calculate_iou(
+                    [
+                        res,
+                    ],
+                    [
+                        tgt,
+                    ],
+                )
+            )
+        avg_iou = np.mean(scores)
+
+        return avg_iou
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/near_str_match.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/near_str_match.py
new file mode 100644
index 0000000000000000000000000000000000000000..ad41909878f921a4dc676bccd69d0a2e07bb9ede
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/near_str_match.py
@@ -0,0 +1,23 @@
+import rapidfuzz
+import unidecode
+from .common.transformations import remove_def_indef_articles
+
+
+def approximate(text: str) -> str:
+    """Return an approximation of the original string."""
+    return unidecode.unidecode(remove_def_indef_articles(text)).lower()
+
+
+class NearStrMatch:
+    """Near string matching."""
+
+    @staticmethod
+    def match(response, correct_answer: str, threshold=0.9) -> int:
+        """Simple string match between response and correct_answer."""
+        if not isinstance(response, str) or not isinstance(correct_answer, str):
+            return 0
+        response = approximate(response)
+        correct_answer = approximate(correct_answer)
+        return rapidfuzz.distance.DamerauLevenshtein.normalized_similarity(
+            response, correct_answer, score_cutoff=threshold
+        )
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/number_rel_diff_ratio.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/number_rel_diff_ratio.py
new file mode 100644
index 0000000000000000000000000000000000000000..070023f2ab3516866eb121cd1121df67eac6ae55
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/number_rel_diff_ratio.py
@@ -0,0 +1,22 @@
+import ast
+import math
+from numbers import Number
+
+
+class NumberRelDiffRatio:
+    """Number relative difference ratio scoring = min(0, 1 - |pred - gt| / gt)"""
+
+    @staticmethod
+    def match(response: str | Number, correct_answer: str) -> int:
+        """Return the relative difference ratio."""
+        try:
+            if isinstance(response, Number):
+                pred = response
+            else:
+                pred = ast.literal_eval(response)
+            if not isinstance(pred, Number):
+                return 0
+            gt = ast.literal_eval(correct_answer)
+            return max(0, 1 - math.fabs((pred - gt) / gt))
+        except (SyntaxError, ValueError):
+            return 0
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/positive_int_match.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/positive_int_match.py
new file mode 100644
index 0000000000000000000000000000000000000000..bd72d416dd22de6228a00e530174038cd9bbd08d
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/positive_int_match.py
@@ -0,0 +1,31 @@
+import ast
+
+
+class PositiveIntMatch:
+    """Positive int matching."""
+
+    @staticmethod
+    def match(response: str, correct_answer: str) -> int:
+        """If the correct answer or response is a positive integer, then it returns if the predicted and correct answers are identical.
+
+        Otherwise, it returns -1.
+        """
+        try:
+            response_obj = ast.literal_eval(response)
+        except (SyntaxError, ValueError):
+            return 0
+
+        if not correct_answer:
+            return 0
+
+        correct_answer_obj = ast.literal_eval(correct_answer)
+
+        assert isinstance(correct_answer_obj, int)
+        if not isinstance(response_obj, int):
+            return 0
+
+        # We only want to score the fields with a positive amount
+        if correct_answer_obj <= 0 and response_obj <= 0:
+            return -1
+
+        return 1 if response_obj == correct_answer_obj else 0
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/set_precision.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/set_precision.py
new file mode 100644
index 0000000000000000000000000000000000000000..b030131f3fc04c2aa619195f5df385721ac0678f
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/set_precision.py
@@ -0,0 +1,16 @@
+from .common.conversions import cast_to_set
+from .common.metrics import set_precision
+
+
+class SetPrecision:
+    """Calculates the set precision for iterables."""
+
+    @classmethod
+    def match(cls, responses, targets) -> float:
+        """Exact match between targets and responses."""
+        if responses is None:
+            return 0
+        responses = cast_to_set(responses)
+        targets = cast_to_set(targets)
+
+        return set_precision(responses, targets)
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/symbolic_planning.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/symbolic_planning.py
new file mode 100644
index 0000000000000000000000000000000000000000..165a43d4ed4d01e2a27cd49155d433c43d650b07
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/symbolic_planning.py
@@ -0,0 +1,266 @@
+import re
+
+PARAM_LIST_MATCHER = re.compile(r"((?:\?\S+\s*)+)(?:-\s+([^\?$]+)\s*)?")
+PARAM_NAME_MATCHER = re.compile(r"\?([^\s\?\)]+)\s*")
+
+
+##### Parsing functions and parentheses matching
+def parse_pddl_param_list(s):
+    s = s.strip()
+    assert s[0] == "(" and s[-1] == ")"
+    s = s[1:-1]
+    param_type_dict = {}
+    for params, p_type in PARAM_LIST_MATCHER.findall(s):
+        for p in PARAM_NAME_MATCHER.findall(params):
+            p_type = p_type.strip()
+            if p_type.startswith("("):
+                p_type = p_type[1:-1].strip()
+                assert "either"
+                param_type_dict[p] = re.split(r"\s+", p_type)[1:]
+            else:
+                param_type_dict[p] = p_type
+    return s.split("?")[0].strip(), param_type_dict
+
+
+def parse_outer_inner_str(s, str_ender, inner_starter, inner_ender):
+    inner_count = 0
+    start_id = 0
+    matched_str = []
+    for i, c in enumerate(s):
+        if inner_count == 0 and c == str_ender:
+            return s[: i + 1], matched_str, i + 1
+        elif c == inner_starter:
+            if inner_count == 0:
+                start_id = i
+            inner_count += 1
+        elif c == inner_ender:
+            inner_count -= 1
+            if inner_count == 0:
+                matched_str.append(s[start_id : i + 1])
+    return s, matched_str, len(s)
+
+
+def parse_pddl_attr_from_string(
+    s,
+    attr_starter="(:",
+    attr_ender=")",
+    inner_starter="(",
+    inner_ender=")",
+    overlap=False,
+):
+    s_attr = s.split(attr_starter)
+    if len(s_attr) == 1:
+        return "", []
+    elif len(s_attr) == 2:
+        outer_str, inner_str, _ = parse_outer_inner_str(
+            s_attr[1], attr_ender, inner_starter, inner_ender
+        )
+        return attr_starter + outer_str, inner_str
+    else:
+        matched_dict = {}
+        outer_list = []
+        if not overlap:
+            while len(s.split(attr_starter)) > 1:
+                s = s.split(attr_starter, 1)[1]
+                name = re.split(r"\s+", s.strip())[0]
+                outer_str, inner_str, end_point = parse_outer_inner_str(
+                    s, attr_ender, inner_starter, inner_ender
+                )
+                outer_list.append(attr_starter + outer_str)
+                matched_dict[name] = inner_str
+                s = s[end_point:]
+        else:
+            for seg in s_attr[1:]:
+                name = re.split(r"\s+", seg.strip())[0]
+                outer_str, inner_str, _ = parse_outer_inner_str(
+                    seg, attr_ender, inner_starter, inner_ender
+                )
+                outer_list.append(attr_starter + outer_str)
+                matched_dict[name] = inner_str
+        return outer_list, matched_dict
+
+
+def remove_type_in_cnf(s):
+    s_split_type = s.split(" - ")
+    if len(s_split_type) > 1:
+        for i in range(1, len(s_split_type)):
+            if len(s_split_type[i].strip().split(")")[0].split()) == 1:
+                s_split_type[i] = ")" + s_split_type[i].strip().split(")", 1)[1]
+            else:
+                s_split_type[i] = " " + s_split_type[i].strip().split(" ", 1)[1]
+        return "".join(s_split_type).strip()
+    else:
+        return s
+
+
+def split_cnf_by_parentheses(s):
+    assert s.startswith("(and")
+    matches = set()
+    p_count = 0
+    clause_start_id = 0
+    for i in range(len(s)):
+        if s[i] == "(":
+            p_count += 1
+            if p_count == 2:
+                clause_start_id = i
+        elif s[i] == ")":
+            p_count -= 1
+            if p_count == 0:
+                break
+            elif p_count == 1:
+                matches.add(remove_type_in_cnf(s[clause_start_id : i + 1]))
+    return matches
+
+
+##### End of parsing functions
+
+
+####### Domain (the env for each planning task)
+class Domain:
+    def __init__(self, name, domain_pddl):
+        # self.name = name
+
+        # Domain files
+        self.domain_pddl = domain_pddl
+        self.action_name, self.action_params, self.action_params_dict = (
+            self.get_domain_action()
+        )
+        self.gt_cond_dict = self.parse_gt_pre_post_cond()
+
+    def get_domain_action(self):
+        action_pddl_str_list, all_actions = parse_pddl_attr_from_string(
+            self.domain_pddl, attr_starter="(:action"
+        )
+        action_name, action_params, action_params_dict = [], [], []
+        for action_pddl_str, (name, action_attr) in zip(
+            action_pddl_str_list, all_actions.items()
+        ):
+            assert len(action_attr) == 3
+            param_str, pre_cond_str, post_cond_str = action_attr
+            action_name.append(name)
+            action_params.append(param_str)
+            action_params_dict.append(parse_pddl_param_list(param_str)[1])
+        return action_name, action_params, action_params_dict
+
+    def parse_gt_pre_post_cond(self):
+        cond_dict = {}
+        for a in self.action_name:
+            act_str = self.domain_pddl.split(f"(:action {a}")[1]
+            for postfix in ["pre", "post"]:
+                split_tag = ":precondition" if postfix == "pre" else ":effect"
+                cond_str = act_str.split(split_tag)[1].strip()
+                if cond_str.startswith("(and"):
+                    cond_dict[f"{a}_{postfix}"] = split_cnf_by_parentheses(cond_str)
+                else:
+                    cond_dict[f"{a}_{postfix}"] = {cond_str.split(")")[0].strip() + ")"}
+                cond_dict[f"{a}_{postfix}"] = sorted(
+                    list(cond_dict[f"{a}_{postfix}"]),
+                    key=lambda x: 0 if x.startswith("(not ") else 1,
+                )
+        return cond_dict
+
+
+##### Transition functions
+def construct_param_to_obj(domain, action):
+    action = action[1:-1]
+    a_name = action.split(" ")[0].strip()
+    objs = action.split(" ")[1:]
+    a_index = domain.action_name.index(a_name)
+    assert len(objs) == len(domain.action_params_dict[a_index])
+    return {p: obj for p, obj in zip(domain.action_params_dict[a_index], objs)}, a_name
+
+
+def state_transition(current_state, effects, param_to_obj):
+    for obj_cond in effects:
+        for param in param_to_obj:
+            obj_cond = re.sub(
+                r"\?{}(?=[^\w-])".format(param), param_to_obj[param], obj_cond
+            )
+        _, reversed_cond = parse_pddl_attr_from_string(obj_cond, attr_starter="(not ")
+        if reversed_cond:
+            assert len(reversed_cond) == 1
+            if reversed_cond[0] in current_state:
+                current_state.remove(reversed_cond[0])
+        elif obj_cond.strip() not in current_state:
+            current_state.append(obj_cond)
+    return current_state
+
+
+def check_pre_conds_satisfy(current_state, pre_conds, param_to_obj):
+    for obj_cond in pre_conds:
+        for param in param_to_obj:
+            obj_cond = re.sub(
+                r"\?{}(?=[^\w-])".format(param), param_to_obj[param], obj_cond
+            )
+        if (obj_cond.startswith("(not ") and obj_cond in current_state) or (
+            not obj_cond.startswith("(not ") and obj_cond not in current_state
+        ):
+            return False
+    return True
+
+
+##### End of transition functions
+
+
+class SymbolicPlanningMetricTest:
+    """An example metric for symbolic planning tasks"""
+
+    @classmethod
+    def match(cls, response, eval_context, task_info=None):
+        ## Initialize domain
+        # task_name = task_info["task_name"]
+        domain_pddl = eval_context["domain_pddl"]
+        domain = Domain(" ", domain_pddl)
+
+        ## Parse trajectory, setup initial and goal state
+        # response = eval_context["gt_plan"]  # for debug
+        match response:
+            case str():
+                candidates = response.split("\n")
+            case tuple() | list():
+                candidates = list(response)
+            case _:
+                raise ValueError(
+                    f"`response` has unsupported type: {type(response)=}, {response=}"
+                )
+        cand_traj = [cand_a.strip() for cand_a in candidates if cand_a.startswith("(")]
+        try:
+            task_pddl = eval_context["task_pddl"]
+            cur_state = parse_pddl_attr_from_string(task_pddl, attr_starter="(:init")[1]
+            goal_state = parse_pddl_attr_from_string(task_pddl, attr_starter="(and")[1]
+        except IndexError:
+            score = 0
+            return score
+
+        score = 1
+        try:
+            ## State transitions and check if satisfy the preconditions
+            for cand_a in cand_traj:
+                param_to_obj, a_name = construct_param_to_obj(domain, cand_a)
+                if not check_pre_conds_satisfy(
+                    cur_state, domain.gt_cond_dict[f"{a_name}_pre"], param_to_obj
+                ):
+                    print(f"precondition of the action {cand_a} is not satisfied!")
+                    score = 0
+                    break
+                cur_state = state_transition(
+                    cur_state, domain.gt_cond_dict[f"{a_name}_post"], param_to_obj
+                )
+
+            ## Check if goal conditions are reached in the final state
+            if score == 1:
+                for g_state in goal_state:
+                    if (g_state.startswith("(not ") and g_state in cur_state) or (
+                        not g_state.startswith("(not ") and g_state not in cur_state
+                    ):
+                        print(f"goal state {g_state} is not reached!")
+                        score = 0
+                        break
+        except ValueError:
+            # grammar error in execution
+            score = 0
+        except AssertionError:
+            # assertion error in functions
+            score = 0
+
+        return score
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/unsupported_scoring.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/unsupported_scoring.py
new file mode 100644
index 0000000000000000000000000000000000000000..baebd51e48a2e78f85c34f595b83a87c6d417889
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/unsupported_scoring.py
@@ -0,0 +1,7 @@
+class UnsupportedScoring:
+    """Unsupported scoring."""
+
+    @staticmethod
+    def match(response: str, correct_answer: str) -> int:
+        """Default response for unimplemented metrics."""
+        return -1
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/vlm_as_judge.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/vlm_as_judge.py
new file mode 100644
index 0000000000000000000000000000000000000000..e911d416b96aa2b6cca26b9ab1eab42a8e908304
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/vlm_as_judge.py
@@ -0,0 +1,236 @@
+import abc
+import base64
+import os
+import requests
+import re
+from io import BytesIO
+from mimetypes import guess_type
+from PIL import Image
+
+
+class OpenAIVLMJudger(abc.ABC):
+    """
+        The OpenAI model class for calling GPT4o or textonly gpt as the juedge
+    for open-ended generation tasks
+    """
+
+    def __init__(
+        self,
+        metric_config,
+        model="gpt-4o-2024-08-06",
+        resize=True,
+        max_side=1000,
+    ):
+        if metric_config is not None and metric_config != {}:
+            self.judge_model_type = metric_config["judge_model_type"]
+            self.eval_prompt = metric_config["eval_criteria_prompt"]
+            self.reference_type = metric_config["reference_type"]
+            self.template_mapping = metric_config["template_mapping"]
+
+        self.api_key = os.getenv("OPENAI_API_KEY")
+        self.url = os.getenv("OPENAI_API_BASE")
+        self.model = model
+        self.resize = resize
+        self.max_side = max_side
+
+        # if os.getenv("MEGABENCH_OPEN_API_KEY") is not None:
+        #     self.api_key = os.getenv("MEGABENCH_OPEN_API_KEY")
+        #     self.url = os.getenv("MEGABENCH_OPEN_API_URL")
+        #     if os.getenv("MEGABENCH_OPEN_API_MODEL") is not None:
+        #         self.model = os.getenv("MEGABENCH_OPEN_API_MODEL")
+        #     assert self.url, "You must set up the API URL for evaluating the Open tasks using your own API"
+
+    @staticmethod
+    def _update_image_path(image_path):
+        hf_home = os.getenv("HF_HOME", "~/.cache/huggingface")
+        base_cache_dir = os.path.expanduser(hf_home)
+        image_path = image_path.replace('./data/', f'{base_cache_dir}/megabench_data/data/')
+        return image_path
+
+    def create_image_content(self, image_path):
+        image_path = self._update_image_path(image_path)
+        base64_image, mime_type = self.encode_image(image_path)
+        return {
+            "type": "image_url",
+            "image_url": {"url": f"data:{mime_type};base64,{base64_image}"},
+        }
+
+    @property
+    def url(self) -> str:
+        """The server URL. We use OpenAI API by default. """
+        return self._url if hasattr(self, '_url') else "https://api.openai.com/v1/chat/completions"
+
+    @url.setter
+    def url(self, value: str) -> None:
+        """Set the server URL."""
+        self._url = value
+
+    @staticmethod
+    def _rgba_to_rgb(image):
+        background = Image.new("RGBA", image.size, (255, 255, 255, 255))
+        return Image.alpha_composite(background, image).convert("RGB")
+
+    def _resize_image(self, image):
+        resize_scale = self.max_side / max(image.size)
+        new_size = (
+            int(image.size[0] * resize_scale),
+            int(image.size[1] * resize_scale),
+        )
+        return image.resize(new_size)
+
+    def _encode_image(self, image, image_format):
+        with BytesIO() as output:
+            image.convert("RGB").save(output, format=image_format)
+            base64_encoded_data = base64.b64encode(output.getvalue()).decode("utf-8")
+        return base64_encoded_data
+
+    def encode_image(self, image_path, max_side=None):
+        mime_type, _ = guess_type(image_path)
+        if mime_type is None:
+            mime_type = "image/jpeg"
+        image_format = mime_type.split("/")[-1].upper() if mime_type else "JPEG"
+
+        image = Image.open(image_path)
+        # Handle the alpha channel
+        if image.mode == "RGBA":
+            image = self._rgba_to_rgb(image)
+        if not max_side and self.max_side:
+            max_side = self.max_side
+
+        if self.resize and max(image.size) > self.max_side:
+            image = self._resize_image(image)
+        encoded_image = self._encode_image(image, image_format)
+
+        return encoded_image, mime_type
+
+    def prepare_eval_prompt(
+        self, reference, response, images, question, eval_context=None
+    ):
+        content = []
+        if self.judge_model_type == "with image":
+            for image_path in images:
+                content.append(self.create_image_content(image_path))
+
+        prompt_mapping = {}
+        for key, val in self.template_mapping.items():
+            if val == "model_output":
+                prompt_mapping[key] = response
+            elif val == "example_question":
+                prompt_mapping[key] = question
+            elif val.split(".")[0] == "answers":
+                if isinstance(reference, str):
+                    prompt_mapping[key] = reference
+                else:
+                    # 如果是字典，则按原来的逻辑处理
+                    key_name = val.split(".")[1]
+                    prompt_mapping[key] = reference.get(key_name, '')
+            elif val.split(".")[0] == "eval_context":
+                key_name = val.split(".")[1]
+                prompt_mapping[key] = eval_context[key_name]
+
+        full_eval_prompt = self.eval_prompt.format(**prompt_mapping)
+
+        content.append({"type": "text", "text": full_eval_prompt})
+        return content
+
+    def query(self, reference_info, response, images, question, eval_context=None):
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+        }
+
+        context = self.prepare_eval_prompt(
+            reference_info, response, images, question, eval_context
+        )
+
+        query_payload = {
+            "model": self.model,
+            "messages": [{"role": "user", "content": context}],
+            "temperature": 0.0,
+        }
+
+        response_data = None
+        while response_data is None:
+            try:
+                response = requests.post(
+                    self.url,
+                    headers=headers,
+                    json=query_payload,
+                )
+                response_ = response.json()
+            except (requests.exceptions.JSONDecodeError, requests.exceptions.ConnectionError) as e:
+                print(f'Error in requests: {e}')
+                print('Retry...')
+                continue
+
+            if "error" in response_:
+                error_info = response_["error"]
+                print(
+                    f"Got error with type: {error_info['type']}. Message: {error_info['message']}"
+                )
+                if (
+                    error_info["message"]
+                    == """Sorry! We've encountered an issue with repetitive patterns in your prompt.
+                    Please try again with a different prompt."""
+                ):
+                    print(query_payload)
+                    # If the model's response has too many repetitive tokens, then we give it a score of 0.
+                    print("gpt-4o judge query failed...")
+                    return f"**Score explanation**: {error_info['message']}\n\n**Score**: 0"
+                print("Retry...")
+            else:
+                response_data = response_
+                break
+
+        total_tokens = response_data.get("usage", {}).get("total_tokens", "N/A")
+
+        # Extracting the 'content' field from the response
+        if response_data and "choices" in response_data:
+            choices = response_data["choices"]
+            if choices and "message" in choices[0]:
+                message_content = choices[0]["message"]["content"]
+                print(
+                    f"gpt-4o judge results: {message_content}; tokens:{total_tokens}"
+                )
+        else:
+            print("gpt-4o judge query failed...")
+            message_content = ""
+
+        return message_content
+
+
+class VLMJudgeScore:
+    """Using GPT-4o as a adjuge to evaluate open-ended generation tasks"""
+
+    def __init__(self, metric_config):
+        self.model = OpenAIVLMJudger(metric_config)
+
+    def parse_results(self, eval_results):
+        """
+        This parsing function is based on the output prompt setting in the
+        file "gpt4o_judge_prompt.json"
+        """
+        score_pattern = r"\*\*Score\*\*\s*:\s*(\d+)"
+        explanation_pattern = r"\*\*Score explanation\*\*\s*:\s*(.*)"
+
+        # Extract the score
+        score_match = re.search(score_pattern, eval_results)
+        score = int(score_match.group(1)) if score_match else None
+
+        # Extract the score explanation
+        explanation_match = re.search(explanation_pattern, eval_results, re.DOTALL)
+        explanation = explanation_match.group(1).strip() if explanation_match else ""
+        info_str = f"Score: {score}; Explanation: {explanation}"
+        if score is None:
+            return 0, f"Score is NULL: {eval_results};"
+
+        return score / 10.0, info_str
+
+    def match(
+        self, response, reference_dict, images, question, eval_context=None
+    ) -> int:
+        eval_results = self.model.query(
+            reference_dict, response, images, question, eval_context
+        )
+        score = self.parse_results(eval_results)
+        return score
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/xml_norm_point_distance.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/xml_norm_point_distance.py
new file mode 100644
index 0000000000000000000000000000000000000000..e189596c8205ec0556c5b3aeebdee42894f0a16a
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/xml_norm_point_distance.py
@@ -0,0 +1,37 @@
+"""Return the normalized point distance."""
+
+from .common.conversions import parse_point_2d_from_xml
+from .common.metrics import point_distance
+
+
+class XmlNormPointDistance:
+    """Determines the distance between two points in XML notation.
+
+    Assumes that co-ordinates are normalized between 0 and 1 and that the 2D point is
+    of the form <point>x, y</point>.
+    """
+
+    @classmethod
+    def parse_2d_point(cls, point) -> tuple[float, float]:
+        """Parse a 2D point encoded in XML as <point>x, y</point>."""
+        if not isinstance(point, (tuple | list)):
+            point = parse_point_2d_from_xml(point)
+            if not point:
+                raise ValueError("Point could not be parsed from XML string.")
+        elif len(point) != 2:
+            raise ValueError("Point is not 2D.")
+        if not all(0 <= comp <= 1 for comp in point):
+            raise ValueError("Point is not normalized.")
+        return tuple(point)
+
+    @classmethod
+    def match(cls, responses, targets) -> float:
+        """Determine the normalized distance between two points."""
+        try:
+            responses = cls.parse_2d_point(responses)
+            targets = cls.parse_2d_point(targets)
+        except ValueError:
+            return 0
+
+        # Instead of normalizing by 1/sqrt(2), we just set it to 0 if the distance is above 1.
+        return max(0, 1 - point_distance(responses, targets))
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/mme_reasoning.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/mme_reasoning.py
new file mode 100644
index 0000000000000000000000000000000000000000..cf2d14d31c781d7cd812e15c00d1f603fc1b2176
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/mme_reasoning.py
@@ -0,0 +1,1200 @@
+from ...smp import *
+import json
+import sympy
+import re
+import pandas as pd
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+id_answer_pair_prompt = """Please read the following example. Then extract the answer from the model response and type it at the end of the prompt.
+Example:
+    Question: Each cycle represents a number. You need to find out what the three numbers are. Give a possible answer in the format 'cycle id:number'
+    Model Response: The possible answer is: A:5, B:1, C:2
+    Extracted answer (json format):
+        {{
+            "A":5,
+            "B":1,
+            "C":2
+        }}
+
+Please extract the answer for the following response:
+    Question: {question}
+    Model Response: {response}
+    You should only output the json without any other texts.
+"""
+
+# id: number, answer: letter
+id_answer_pair_prompt_reverse = """Please read the following example. Then extract the answer from the model response and type it at the end of the prompt.
+Example:
+    Question: Each cycle (id from 1 to 3) represents a letter. You need to find out what the three numbers are. Give a possible answer in the format 'cycle id:letter'
+    Model Response: The possible answer is: 1:A, 2:B, 3:C
+    Extracted answer (json format):
+        {{
+            "1":"A",
+            "2":"B",
+            "3":"C"
+        }}
+
+Please extract the answer for the following response:
+    Question: {question}
+    Model Response: {response}
+    You should only output the json without any other texts.
+"""
+
+coordinate_answer_prompt = """Please read the following example. Then extract the answer from the model response and type it at the end of the prompt.
+Example1:
+    Question: According to the clues, find the corresponding position. Answer in '(row id (A-C), column id (1-3))' format.
+    Model Response: The possible answer is: (A, 1)
+    Extracted answer (json format):
+        [
+            {{
+                "row": "A",
+                "column": 1
+            }}
+        ]
+Example2:
+    Question: According to the clues, find the two corresponding position. Answer in '(row id (A-C), column id (1-3))' format.
+    Model Response: The possible answer is: (A, 1), (B, 3)
+    Extracted answer (json format):
+        [
+            {{
+                "row": "A",
+                "column": 1
+            }},
+            {{
+                "row": "B",
+                "column": 3
+            }}
+        ]
+
+Please extract the answer for the following response:
+    Question: {question}
+    Model Response: {response}
+    You should only output the json without any other texts.
+"""
+
+multiple_answer_prompt = """Please read the following example. Then extract the answer from the model response and type it at the end of the prompt.
+Example1:
+    Question: There are six balls (A-F), find two balls that have lower weight. Answer in ball id.
+    Model Response: The possible answer is: A, C
+    Extracted answer (json format):
+        {{
+            "id": ["A", "C"]
+        }}
+Example2:
+    Question: There are six balls (A-F), find a ball that have lower weight. Answer in ball id.
+    Model Response: The possible answer is: A
+    Extracted answer (json format):
+        {{
+            "id": ["A"]
+        }}
+Please extract the answer for the following response:
+    Question: {question}
+    Model Response: {response}
+    You should only output the json without any other texts.
+"""
+
+formula_extraction_prompt = """Please extract the mathematical formula from the following model response and type it at the end of the prompt.
+Example:
+    Question: What is the right equation to solve the problem?
+    Model Response: The right equation to solve the problem is: 2 + 3 = 7
+    Extracted answer (json format):
+        {{
+            "equation": "2 + 3 = 7"
+        }}
+Please extract the answer for the following response:
+    Question: {question}
+    Model Response: {response}
+    You should only output the json without any other texts.
+"""
+
+choice_prompt = """Please read the following example. Then extract the answer from the model response and type it at the end of the prompt.
+Example1:
+    Question: Which answer is right?\n A.1\n B.2\n C.3\n D.4\n Please answer the question and provide the correct option letter, e.g., A, B, C, D, at the end.
+    Model Response: The possible answer is: A
+    Extracted answer: A
+Example2:
+    Question: Which answer is right?\n A.1\n B.2\n C.3\n D.4\n Please answer the question and provide all correct option letter, e.g., A, B, C, D, at the end. Find all possible answers.
+    Model Response: The possible answer is: A, C
+    Extracted answer: [A, C]
+
+Please extract the answer for the following response:
+    Question: {question}
+    Model Response: {response}
+    Extracted answer:
+    You should only output the answer without any other texts.
+"""
+
+open_question_prompt = """Please read the following example. Then extract the answer from the model response and type it at the end of the prompt.
+Example1:
+    Question: What value should be? Please answer the question and provide the final value, e.g., 2, 2.10, -3, at the end.
+    Model Response: The possible value is -4
+    Extracted answer: -4
+Example2:
+    Question: What value should be? Please answer the question and provide the final value, e.g., 2, 2.10, -3, at the end.
+    Model Response: The possible value is $2\sqrt{{3}}$
+    Extracted answer: 2\sqrt{{3}}
+Example3:
+    Question: What value should be? Please answer the question and provide the final value, e.g., 2, 2.10, -3, at the end.
+    Model Response: The possible value is 3.28
+    Extracted answer: 3.28
+
+Please extract the answer for the following response:
+    Question: {question}
+    Model Response: {response}
+    Extracted answer:
+    You should only output the answer without any other texts.
+"""
+
+hashi_extraction_prompt = """Extract all bridge connections from the Hashi puzzle solution text and format them as a structured JSON list. Follow these rules:
+
+1. **Input**:
+   - `solution`: Text describing bridges between islands using various formats (e.g., "c1 - c3", "a1到g1", "between b2 and b4").
+
+2. **Output Requirements**:
+   - Return a JSON list of dictionaries in this format:
+     ```JSON
+     [{{"start": "a1", "end": "b1", "number": 2}}, ...]
+     ```
+   - Include ALL bridges explicitly described in `solution`.
+   - Use 1-based row numbers and letter-based columns (e.g., "c3" not "3c").
+   - Normalize coordinate formats (e.g., "(1,c)" → "c1", "d,4" → "d4").
+
+3. **Parsing Rules**:
+   - Capture bridge counts (1 or 2) from phrases like:
+     - "two bridges"
+     - "1 bridge"
+     - "double bridge"
+   - Handle directional phrases:
+     - "from X to Y"
+     - "X connects to Y"
+     - "X-Y bridge"
+
+4. **Edge Cases**:
+   - The bridge corresponding to the following plot will be skipped directly:
+     - No bridges can be parsed
+     - Ambiguous connections (unclear start/end)
+     - Invalid coordinate formats
+
+**Response Format**:
+1. Return ONLY the JSON list.
+2. Do not include any additional text, explanations, or formatting beyond the JSON list.
+
+**Examples**:
+Solution:
+"Draw two bridges from a1 to b1, and one bridge between f6-f8"
+Output:
+[{{"start": "a1", "end": "b1", "number": 2}}, {{"start": "f6", "end": "f8", "number": 1}}]
+
+Solution:
+"Connect c3 with d3 using a double bridge"
+Output:
+[{{"start": "c3", "end": "d3", "number": 2}}]
+
+Now, extract the answer of the following response:
+Solution:
+{response}
+Output:
+"""
+
+skyscraper_extraction_prompt = """Extract the final answer from the given solution. The solution will contain a detailed solution to a Sudoku-like puzzle, including step-by-step explanations and a final filled grid representation. Your task is to identify and extract only the final answer, which is presented as a matrix (list of lists or equivalent) at the end of the solution.
+
+### Requirements:
+1. Only return the final filled matrix, formatted as a JSON list of lists.
+2. Do not include any additional text, explanations, or formatting beyond the matrix itself.
+3. The final answer usually follows phrases such as 'Final Filled Grid' or 'Summary as a Single Filled Matrix'.
+
+### Example 1:
+Solution:
+To solve the 3x3 Skyscrapers puzzle, we need to place the numbers 1, 2, and 3 in each row and column while adhering to the given clues. Let's break down the solution step by step.\n\n### Step-by-Step Solution:\n\n1. **Analyze the clues:**\n   - Top row: 3, 1, 2\n   - Left column: 2, 2, 1\n   - Right column: 2, 1, 3\n   - Bottom row: 1, 2, 2\n\n2. **Start with the top row:**\n   - The top row has a clue of 3 on the left, meaning all three skyscrapers are visible. This implies the order must be 1, 2, 3 from left to right.\n   - The top row is: [1, 2, 3]\n\n3. **Analyze the left column:**\n   - The left column has a clue of 2 at the top, meaning two skyscrapers are visible. Given the top row is [1, 2, 3], the second row must start with a 3 to block the view of the third row.\n   - The left column is: [1, 3, 2]\n\n4. **Analyze the right column:**\n   - The right column has a clue of 3 at the bottom, meaning all three skyscrapers are visible. This implies the order must be 1, 2, 3 from top to bottom.\n   - The right column is: [3, 2, 1]\n\n5. **Fill in the remaining cells:**\n   - The second row has a clue of 2 on the left, and we already have a 3 in the first column. The remaining cells must be 1 and 2 in some order. Given the right column clue of 2, the second row must be [3, 1, 2].\n   - The third row has a clue of 1 on the left, meaning the first cell must be 2 to block the view of the other cells. The remaining cells must be 3 and 1 in some order. Given the right column clue of 3, the third row must be [2, 3, 1].\n\n### Final Solution:\n\nThe completed 3x3 Skyscrapers puzzle is:\n\n```\n1 2 3\n3 1 2\n2 3 1\n```\n\n### Summary as a single filled matrix:\n\n```python\n[[1, 2, 3], [3, 1, 2], [2, 3, 1]]\n```
+
+Output:
+[[1, 2, 3], [3, 1, 2], [2, 3, 1]]
+
+### Example 2:
+Solution:
+To solve the 4x4 Skyscrapers puzzle, we need to place the numbers 1, 2, 3, and 4 in each row and column while adhering to the given clues. Let's break down the solution step by step.\n\n### Step-by-Step Solution:\n\n1. **Analyze the clues:**\n   - Top row: Clue '2' on the left means we can see 2 skyscrapers from the left.\n   - Bottom row: Clue '4' on the right means we can see 4 skyscrapers from the right.\n   - Left column: Clue '2' on the top means we can see 2 skyscrapers from the top.\n   - Right column: Clue '2' on the bottom means we can see 2 skyscrapers from the bottom.\n\n2. **Start with the bottom row:**\n   - Since we can see 4 skyscrapers from the right, the bottom row must be in ascending order from left to right: [1, 2, 3, 4].\n\n3. **Fill the bottom row:**\n   - Row 4: [1, 2, 3, 4]\n\n4. **Analyze the top row:**\n   - We can see 2 skyscrapers from the left, so the tallest skyscraper (4) must be in the second position from the left to block the view of the third and fourth skyscrapers.\n   - Possible configurations: [3, 4, 1, 2] or [2, 4, 1, 3]\n\n5. **Analyze the left column:**\n   - We can see 2 skyscrapers from the top, so the tallest skyscraper (4) must be in the second position from the top to block the view of the third and fourth skyscrapers.\n   - Possible configurations: [3, 4, 1, 2] or [2, 4, 1, 3]\n\n6. **Combine the clues:**\n   - Top row: [3, 4, 1, 2]\n   - Left column: [3, 4, 1, 2]\n\n7. **Fill the remaining cells:**\n   - Row 1: [3, 4, 1, 2]\n   - Row 2: [4, 1, 2, 3]\n   - Row 3: [2, 3, 4, 1]\n   - Row 4: [1, 2, 3, 4]\n\n### Final Solution:\n\n```\n[[3, 4, 1, 2],\n [4, 1, 2, 3],\n [2, 3, 4, 1],\n [1, 2, 3, 4]]\n```\n\nThis matrix satisfies all the given clues and constraints of the Skyscrapers puzzle.
+
+Output:
+[[3, 4, 1, 2], [4, 1, 2, 3], [2, 3, 4, 1], [1, 2, 3, 4]]
+
+Now, please extract the answer for the following solution:
+Solution:
+{response}
+
+Output:
+"""
+
+sudoku_4_extraction_prompt = """Extract the final answer from the given solution. The solution will contain a detailed solution to a Sudoku-like puzzle, including step-by-step explanations and a final filled grid representation. Your task is to identify and extract only the final answer, which is presented as a matrix (list of lists or equivalent) at the end of the solution.
+
+### Requirements:
+1. Only return the final filled matrix, formatted as a JSON list of lists.
+2. Do not include any additional text, explanations, or formatting beyond the matrix itself.
+3. The final answer usually follows phrases such as 'Final Filled Grid' or 'Summary as a Single Filled Matrix'.
+
+### Example 1:
+Solution:
+To solve the given Jigsaw Sudoku puzzle, we need to ensure that each row, each column, and each 2x2 sub-grid contains the digits 1 through 4 exactly once. Let's fill in the grid step by step.\n\nStep-by-Step Solution:\n1. **Identify the given numbers and their positions:**\n   - Top row: 1, 3\n   - Second row: 3\n   - Third row: (empty)\n   - Fourth row: 2, 3, 1\n\n2. **Fill in the top row:**\n   - The top row already has 1 and 3. The remaining digits are 2 and 4.\n   - The first column already has a 3, so the first cell in the top row cannot be 3. Therefore, it must be 2.\n   - The fourth column already has a 3, so the fourth cell in the top row cannot be 3. Therefore, it must be 4.\n   - Top row: [2, 1, 4, 3]\n\n### Final Filled Matrix:\n[[2, 1, 4, 3], [1, 4, 2, 3], [4, 2, 1, 3], [2, 3, 4, 1]]
+
+Output:
+[[2, 1, 4, 3], [1, 4, 2, 3], [4, 2, 1, 3], [2, 3, 4, 1]]
+
+### Example 2:
+Solution:
+1. **Identify the given numbers and their positions:**\n   - Top row: 1, 3\n   - Second row: 3\n   - Third row: (empty)\n   - Fourth row: 2, 3, 1\n\n2. **Fill in the top row:**\n   - The top row already has 1 and 3. The remaining digits are 2 and 4.\n   - The first column already has a 3, so the first cell in the top row cannot be 3. Therefore, it must be 2.\n   - The fourth column already has a 3, so the fourth cell in the top row cannot be 3. Therefore, it must be 4.\n   - Top row: 2, 1, 4, 3\n\n3. **Fill in the second row:**\n   - The second row already has a 3. The remaining digits are 1, 2, and 4.\n   - The first column already has a 2 and a 3, so the first cell in the second row cannot be 2 or 3. Therefore, it must be 1.\n   - The second column already has a 1, so the second cell in the second row cannot be 1. Therefore, it must be 4.\n   - The fourth column already has a 3 and a 4, so the fourth cell in the second row cannot be 3 or 4. Therefore, it must be 2.\n   - Second row: 1, 4, 2, 3\n\n4. **Fill in the third row:**\n   - The third row is empty. The remaining digits are 1, 2, 3, and 4.\n   - The first column already has a 2 and a 1, so the first cell in the third row cannot be 2 or 1. Therefore, it must be 4.\n   - The second column already has a 1 and a 4, so the second cell in the third row cannot be 1 or 4. Therefore, it must be 2.\n   - The third column already has a 4 and a 2, so the third cell in the third row cannot be 4 or 2. Therefore, it must be 1.\n   - The fourth column already has a 3 and a 2, so the fourth cell in the third row cannot be 3 or 2. Therefore, it must be 3.\n   - Third row: 4, 2, 1, 3\n\n5. **Fill in the fourth row:**\n   - The fourth row already has 2, 3, and 1. The remaining digit is 4.\n   - Fourth row: 2, 3, 4, 1\n\n### Final Filled Matrix:\n```python\n[\n    [2, 1, 4, 3],\n    [1, 4, 2, 3],\n    [4, 2, 1, 3],\n    [2, 3, 4, 1]\n]\n```\n\n### Summary:\nThe completed Jigsaw Sudoku puzzle is:\n```python\n[\n    [2, 1, 4, 3],\n    [1, 4, 2, 3],\n    [4, 2, 1, 3],\n    [2, 3, 4, 1]\n]\n```
+
+Output:
+[[2, 1, 4, 3],[1, 4, 2, 3],[4, 2, 1, 3],[2, 3, 4, 1]]
+
+Now, extract the answer of the following response:
+
+Solution:
+{response}
+
+Output:
+"""
+
+sudoku_6_extraction_prompt = """Extract the final answer from the given solution. The solution will contain a detailed solution to a Sudoku-like puzzle, including step-by-step explanations and a final filled grid representation. Your task is to identify and extract only the final answer, which is presented as a matrix (list of lists or equivalent) at the end of the solution.
+
+### Requirements:
+1. Only return the final filled matrix, formatted as a JSON list of lists.
+2. Do not include any additional text, explanations, or formatting beyond the matrix itself.
+3. The final answer usually follows phrases such as 'Final Filled Grid' or 'Summary as a Single Filled Matrix'.
+
+### Example 1:
+Solution:
+To solve the given Jigsaw Sudoku puzzle, we need to ensure that each row, each column, and each 2x3 sub-grid contains the digits 1 through 6 exactly once. Let's solve it step by step.\n\n### Step-by-Step Solution:\n\n1. **Identify the sub-grids and initial constraints:**\n   - The grid is divided into 2x3 sub-grids.\n   - We need to fill in the empty cells while satisfying the Sudoku rules.\n\n2. **Fill in the first row:**\n   - The first row has the digits 2 and 4 already placed.\n   - The remaining digits are 1, 3, 5, and 6.\n   - Considering the constraints of the sub-grids and columns, we can place the digits as follows:\n     - First row: [5, 3, 2, 1, 6, 4]\n\n3. **Fill in the second row:**\n   - The second row has the digits 6 and 1 already placed.\n   - The remaining digits are 2, 3, 4, and 5.\n   - Considering the constraints, we can place the digits as follows:\n     - Second row: [4, 6, 1, 5, 3, 2]\n\n4. **Fill in the third row:**\n   - The third row has the digits 1, 3, and 6 already placed.\n   - The remaining digits are 2, 4, and 5.\n   - Considering the constraints, we can place the digits as follows:\n     - Third row: [1, 3, 5, 6, 2, 4]\n\n5. **Fill in the fourth row:**\n   - The fourth row has the digits 6, 3, and 1 already placed.\n   - The remaining digits are 2, 4, and 5.\n   - Considering the constraints, we can place the digits as follows:\n     - Fourth row: [2, 5, 6, 4, 3, 1]\n\n6. **Fill in the fifth row:**\n   - The fifth row has the digits 4 and 2 already placed.\n   - The remaining digits are 1, 3, 5, and 6.\n   - Considering the constraints, we can place the digits as follows:\n     - Fifth row: [3, 1, 4, 2, 5, 6]\n\n7. **Fill in the sixth row:**\n   - The sixth row has the digits 6 and 3 already placed.\n   - The remaining digits are 1, 2, 4, and 5.\n   - Considering the constraints, we can place the digits as follows:\n     - Sixth row: [6, 2, 1, 3, 4, 5]\n\n### Final Filled Matrix:\n\n```python\n[\n    [5, 3, 2, 1, 6, 4],\n    [4, 6, 1, 5, 3, 2],\n    [1, 3, 5, 6, 2, 4],\n    [2, 5, 6, 4, 3, 1],\n    [3, 1, 4, 2, 5, 6],\n    [6, 2, 1, 3, 4, 5]\n]\n```
+
+Output:
+[[5, 3, 2, 1, 6, 4],[4, 6, 1, 5, 3, 2],[1, 3, 5, 6, 2, 4],[2, 5, 6, 4, 3, 1],[3, 1, 4, 2, 5, 6],[6, 2, 1, 3, 4, 5]]
+
+### Example 2:
+Solution:
+To solve this 6×6 Jigsaw Sudoku puzzle, we need to ensure that:\n\n1. Each row contains the digits 1–6 exactly once.\n2. Each column contains the digits 1–6 exactly once.\n3. Each 2×3 sub-grid contains the digits 1–6 exactly once.\n\nHere is the completed solution:\n\n### Completed Sudoku Grid:\n```\n1 3 4 2 5 6\n6 2 5 1 3 4\n5 6 2 3 4 1\n3 4 6 5 1 2\n4 5 1 6 2 3\n2 1 3 4 6 5\n```\n\n### Summary as a Matrix:\n```python\n[\n    [1, 3, 4, 2, 5, 6],\n    [6, 2, 5, 1, 3, 4],\n    [5, 6, 2, 3, 4, 1],\n    [3, 4, 6, 5, 1, 2],\n    [4, 5, 1, 6, 2, 3],\n    [2, 1, 3, 4, 6, 5]\n]\n```
+
+Output:
+[[1, 3, 4, 2, 5, 6],[6, 2, 5, 1, 3, 4],[5, 6, 2, 3, 4, 1],[3, 4, 6, 5, 1, 2],[4, 5, 1, 6, 2, 3],[2, 1, 3, 4, 6, 5]]
+
+Now, extract the answer of the following response:
+
+Solution:
+{response}
+
+Output:
+"""
+
+yinyang_extraction_prompt = """Extract the final answer from the given solution. The solution will contain a detailed solution to a Sudoku-like puzzle, including step-by-step explanations and a final filled grid representation. Your task is to identify and extract only the final answer, which is presented as a matrix (list of lists or equivalent) at the end of the solution.
+
+### Requirements:
+1. Only return the final filled matrix, formatted as a JSON list of lists.
+2. Do not include any additional text, explanations, or formatting beyond the matrix itself.
+3. The final answer usually follows phrases such as 'Final Filled Grid' or 'Summary as a Single Filled Matrix'.
+
+### Example 1:
+Solution:
+To solve the Yin-Yang puzzle, we need to place black and white stones at the intersections of the grid lines while adhering to the given rules. Let's analyze the current state of the grid and determine the placement of the remaining stones.\n\n### Step-by-Step Solution:\n\n1. **Initial Setup:**\n   - The grid is a 6x6 matrix.\n   - Some cells already have black (1) and white (0) stones.\n\n2. **Rule Analysis:**\n   - All black stones must be orthogonally connected.\n   - All white stones must be orthogonally connected.\n   - No 2x2 region can be monochromatic.\n   - Existing stones cannot be moved.\n\n3. **Placement Strategy:**\n   - Start by ensuring the connectivity of black and white stones.\n   - Avoid creating monochromatic 2x2 regions.\n\n### Detailed Placement:\n\n- **Top-left corner (a1):**\n  - Place a white stone to avoid a monochromatic 2x2 region with the black stone at (b1).\n\n- **Top-right corner (f1):**\n  - Place a white stone to avoid a monochromatic 2x2 region with the black stone at (e1).\n\n- **Middle section:**\n  - Ensure connectivity of black and white stones while avoiding monochromatic 2x2 regions.\n\n### Final Matrix:\n\nAfter placing the stones according to the rules, the final matrix is:\n\n```\n[\n  [0, 1, 0, 1, 0, 0],\n  [0, 0, 1, 1, 0, 0],\n  [1, 0, 1, 0, 1, 0],\n  [0, 1, 0, 1, 0, 1],\n  [0, 0, 1, 0, 1, 0],\n  [1, 0, 0, 1, 0, 0]\n]\n```\n\n### Summary:\n\nThe completed solution for the Yin-Yang puzzle is represented as a single filled matrix:\n\n```python\n[\n  [0, 1, 0, 1, 0, 0],\n  [0, 0, 1, 1, 0, 0],\n  [1, 0, 1, 0, 1, 0],\n  [0, 1, 0, 1, 0, 1],\n  [0, 0, 1, 0, 1, 0],\n  [1, 0, 0, 1, 0, 0]\n]\n```
+
+Output:
+[[0, 1, 0, 1, 0, 0],[0, 0, 1, 1, 0, 0],[1, 0, 1, 0, 1, 0],[0, 1, 0, 1, 0, 1],[0, 0, 1, 0, 1, 0],[1, 0, 0, 1, 0, 0]]
+
+### Example 2:
+Solution:
+To solve the Yin-Yang puzzle, we need to ensure that the rules are followed:\n\n1. All black stones form a single orthogonally connected group.\n2. All white stones form a single orthogonally connected group.\n3. No 2x2 region is monochromatic.\n4. The positions of the pre-placed stones cannot be changed.\n\n### Step-by-Step Solution:\n\n#### Initial Setup:\nThe given grid is a 6x6 grid with some pre-placed black and white stones. We\'ll represent the grid as follows:\n- "1" for black stones.\n- "0" for white stones.\n- Empty cells will be filled as we solve the puzzle.\n\n#### Pre-placed Stones:\nFrom the diagram:\n- Black stones ("1") are at: (a1, b1, c1, c2, d2, d3, e3).\n- White stones ("0") are at: (a3, a4, a5, b4, b5, c4, d4, e4).\n\n#### Solving the Puzzle:\nWe will fill the remaining cells while ensuring the rules are satisfied.\n\n---\n\n### Final Solution:\nAfter solving, the completed grid is as follows:\n\n```\n1 1 1 0 0 0\n0 1 0 1 0 0\n0 1 0 1 1 0\n0 0 0 1 0 1\n0 0 0 0 0 1\n1 0 0 0 1 1\n```\n\n### Summary:\nThe solution as a 6x6 matrix is:\n\n```python\n[\n    [1, 1, 1, 0, 0, 0],\n    [0, 1, 0, 1, 0, 0],\n    [0, 1, 0, 1, 1, 0],\n    [0, 0, 0, 1, 0, 1],\n    [0, 0, 0, 0, 0, 1],\n    [1, 0, 0, 0, 1, 1]\n]\n```
+
+Output:
+[[1, 1, 1, 0, 0, 0],[0, 1, 0, 1, 0, 0],[0, 1, 0, 1, 1, 0],[0, 0, 0, 1, 0, 1],[0, 0, 0, 0, 0, 1],[1, 0, 0, 0, 1, 1]]
+
+Now, extract the answer of the following response:
+Solution:
+{response}
+
+Output:
+"""
+
+points24_prompt = """
+Please read the following examples. Then extract the final formula from the answer to the 24-point game, and type it at the end of the prompt. In the cards, K stands for 13, Q stands for 12, J stands for 11, and A stands for 1. Note you need to use * to represent multiplication sign, / to represent division sign.
+Example1:
+    Question: Given four playing cards (A, 8, 9, K), each with a value, use any combination of addition, subtraction, multiplication, and division to make the number 24. You must use each card exactly once. Give the final answer as a formula.
+    Model Response: The possible answer is (K - 9 - A) × 8 = 24
+    Extracted answer: (13-9-1)*8=24
+Example2:
+    Question: Given four playing cards (3, 8, 9, A), each with a value, use any combination of addition, subtraction, multiplication, and division to make the number 24. You must use each card exactly once. Give the final answer as a formula.
+    Model Response: The possible answer is 9 \\div 3 \\times A \\times 8 = 24
+    Extracted answer: 9/3*1*8=24
+
+Please extract the final formula from for the following response:
+    Question: {question}
+    Model Response: {response}
+    Extracted answer:
+    You should only output the final formula from without any other texts.
+"""
+
+mme_reasoning_eval_prompts = {
+    "id_answer_pair_prompt": id_answer_pair_prompt,
+    "id_answer_pair_prompt_reverse": id_answer_pair_prompt_reverse,
+    "coordinate_answer_prompt": coordinate_answer_prompt,
+    "multiple_answer_prompt": multiple_answer_prompt,
+    "formula_extraction_prompt": formula_extraction_prompt,
+    "choice_prompt": choice_prompt,
+    "open_question_prompt": open_question_prompt,
+    "hashi_extraction_prompt": hashi_extraction_prompt,
+    "skyscraper_extraction_prompt": skyscraper_extraction_prompt,
+    "sudoku_4_extraction_prompt": sudoku_4_extraction_prompt,
+    "sudoku_6_extraction_prompt": sudoku_6_extraction_prompt,
+    "yinyang_extraction_prompt": yinyang_extraction_prompt,
+    "points24_prompt": points24_prompt
+}
+
+def calculate_answer_function_1(response_dict, answer_dict=None):
+    try:
+        expect_keys = ['A', 'B', 'C']
+        for k in expect_keys:
+            if k not in response_dict.keys():
+                return False
+        if response_dict["A"] / response_dict['B'] == 3 and response_dict["C"] / response_dict['B'] == 2:
+            return True
+        else:
+            return False
+    except:
+        return False
+
+def calculate_answer_function_2(response_dict, answer_dict=None):
+    try:
+        expect_keys = ['A', 'B', 'C', 'D', 'E', 'F']
+        for k in expect_keys:
+            if k not in response_dict.keys():
+                return False
+        if response_dict['A'] + response_dict['B'] + response_dict['C'] != 25:
+            return False
+        if response_dict['C'] + response_dict['E'] + response_dict['F'] != 25:
+            return False
+        if response_dict['A'] + response_dict['D'] + response_dict['F'] != 25:
+            return False
+        return True
+    except:
+        return False
+
+def calculate_answer_function_3(response_dict, answer_dict=None):
+    expect_keys = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O']
+    for k in expect_keys:
+        if k not in response_dict.keys():
+            return False
+    values = set(response_dict.values())
+    expect_values = set(range(1, 16))
+    if values != expect_values:
+        return False
+    diamond_list = [
+        ['A', 'D', 'E', 'H'],
+        ['C', 'E', 'G', 'H'],
+        ['I', 'G', 'J', 'H'],
+        ['N', 'M', 'J', 'H'],
+        ['O', 'M', 'H', 'L'],
+        ['K', 'L', 'H', 'F'],
+        ['B', 'F', 'H', 'D']
+    ]
+    for diamond in diamond_list:
+        total_value = 0
+        for key in diamond:
+            total_value += response_dict[key]
+        if total_value != 30:
+            return False
+    return True
+
+def calculate_answer_function_4(response_dict, answer_dict=None):
+    expect_keys = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I']
+    for k in expect_keys:
+        if k not in response_dict.keys():
+            return False
+    values = set(response_dict.values())
+    expect_values = set(range(1, 10))
+    if values != expect_values:
+        return False
+    line_list = [
+        ['A', 'B', 'E', 'D'],
+        ['B', 'C', 'E', 'F'],
+        ['D', 'E', 'G', 'H'],
+        ['E', 'F', 'H', 'I'],
+        ['B', 'D', 'H', 'F'],
+        ['A', 'C', 'I', 'G']
+    ]
+    for line in line_list:
+        total_value = 0
+        for key in line:
+            total_value += response_dict[key]
+        if total_value != 20:
+            return False
+    return True
+
+def calculate_answer_function_5(response_dict, answer_dict=None):
+    expect_keys = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q']
+    for k in expect_keys:
+        if k not in response_dict.keys():
+            return False
+    values = list(response_dict.values())
+    for v in values:
+        if v not in [20, 15, 10, 5]:
+            return False
+    num_dict = {}
+    for v in values:
+        num_dict[v] = num_dict.get(v, 0) + 1
+    if num_dict.get(20, 0) > 5 or num_dict.get(15, 0) > 3 or num_dict.get(10, 0) > 3 or num_dict.get(5, 0) > 6:
+        return False
+
+    line_list = [
+        ['A', 'B', 'C'],
+        ['A', 'G', 'O'],
+        ['O', 'P', 'Q'],
+        ['C', 'K', 'Q'],
+        ['A', 'D', 'I', 'N', 'Q'],
+        ['C', 'F', 'I', 'L', 'O'],
+        ['B', 'E', 'I', 'M', 'P'],
+        ['G', 'H', 'I', 'J', 'K'],
+
+    ]
+    for line in line_list:
+        total_value = 0
+        for key in line:
+            total_value += response_dict[key]
+        if total_value != 55:
+            return False
+    return True
+
+def calculate_answer_function_6(response_dict, answer_dict=None):
+    expect_keys = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S']
+    for k in expect_keys:
+        if k not in response_dict.keys():
+            return False
+    values = set(response_dict.values())
+    expect_values = set(range(1, 20))
+    if values != expect_values:
+        return False
+    line_list = [
+        ['A', 'J', 'S'],
+        ['C', 'J', 'Q'],
+        ['E', 'J', 'O'],
+        ['G', 'J', 'M'],
+        ['I', 'J', 'K'],
+        ['L', 'J', 'H'],
+        ['N', 'J', 'F'],
+        ['P', 'J', 'D'],
+        ['R', 'J', 'B']
+    ]
+    for line in line_list:
+        total_value = 0
+        for key in line:
+            total_value += response_dict[key]
+        if total_value != 30:
+            return False
+    return True
+
+def calculate_answer_function_7(response_dict, answer_dict=None):
+    expect_keys = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L']
+    for k in expect_keys:
+        if k not in response_dict.keys():
+            return False
+    values = set(response_dict.values())
+    expect_values = set(range(1, 13))
+    if values != expect_values:
+        return False
+    line_list = [
+        ['A', 'C', 'F', 'H'],
+        ['A', 'D', 'G', 'K'],
+        ['B', 'C', 'D', 'E'],
+        ['H', 'I', 'J', 'K'],
+        ['B', 'F', 'I', 'L'],
+        ['E', 'G', 'J', 'L']
+    ]
+    for line in line_list:
+        total_value = 0
+        for key in line:
+            total_value += response_dict[key]
+        if total_value != 26:
+            return False
+    return True
+
+def calculate_answer_function_8(response_dict, answer_dict=None):
+    expect_keys = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M']
+    for k in expect_keys:
+        if k not in response_dict.keys():
+            return False
+    values = list(response_dict.values())
+    for v in values:
+        if v < 1 or v > 15:
+            return False
+    if len(values) != len(set(values)):
+        return False
+    line_list = [
+        ['A', 'B', 'C'],
+        ['A', 'F', 'K'],
+        ['B', 'D', 'E'],
+        ['B', 'E', 'H'],
+        ['C', 'H', 'M'],
+        ['D', 'G', 'J'],
+        ['E', 'G', 'I'],
+        ['F', 'I', 'L'],
+        ['H', 'J', 'I'],
+        ['K', 'L', 'M']
+    ]
+    for line in line_list:
+        total_value = 0
+        for key in line:
+            total_value += response_dict[key]
+        if total_value != 20:
+            return False
+    return True
+
+def calculate_answer_function_9(response_dict, answer_dict=None):
+    expect_keys = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S']
+    for k in expect_keys:
+        if k not in response_dict.keys():
+            return False
+    values = set(response_dict.values())
+    expect_values = set(range(1, 20))
+    if values != expect_values:
+        return False
+
+    line_list = [
+        ['A', 'B', 'C'],
+        ['A', 'D', 'H'],
+        ['A', 'E', 'J'],
+        ['C', 'F', 'J'],
+        ['C', 'G', 'L'],
+        ['H', 'I', 'J'],
+        ['H', 'M', 'Q'],
+        ['J', 'K', 'L'],
+        ['J', 'N', 'Q'],
+        ['J', 'O', 'S'],
+        ['L', 'P', 'S'],
+        ['Q', 'R', 'S']
+    ]
+    for line in line_list:
+        total_value = 0
+        for key in line:
+            total_value += response_dict[key]
+        if total_value != 22:
+            return False
+    return True
+
+def calculate_answer_function_10(response_dict, answer_dict=None):
+    expect_keys = ['A', 'B', 'C', 'D', 'E', 'F']
+    for k in expect_keys:
+        if k not in response_dict.keys():
+            return False
+    values = set(response_dict.values())
+    expect_values = set(range(1, 7))
+    if values != expect_values:
+        return False
+    line_1 = response_dict['A'] + response_dict['B'] + response_dict['D']
+    line_2 = response_dict['D'] + response_dict['E'] + response_dict['F']
+    line_3 = response_dict['A'] + response_dict['C'] + response_dict['F']
+    return line_1 == line_2 == line_3
+
+def calculate_answer_function_11(response_dict, answer_dict=None):
+    expect_keys = ['A', 'B', 'C', 'D', 'E', 'F', 'G']
+    for k in expect_keys:
+        if k not in response_dict.keys():
+            return False
+    values = set(response_dict.values())
+    expect_values = set([1, 2, 3, 5, 7, 8])
+    if values != expect_values:
+        return False
+
+    if response_dict['A'] + response_dict['C'] + 9 != 19:
+        return False
+    if response_dict['B'] + response_dict['C'] + response_dict['D'] != 19:
+        return False
+    if response_dict['F'] + response_dict['E'] + response_dict['D'] != 19:
+        return False
+    if response_dict['E'] + response_dict['G'] + 6 != 19:
+        return False
+    return True
+
+def calculate_answer_function_12(response_dict, answer_dict=None):
+    expect_keys = ['A', 'C', 'T', 'D', 'O', 'G', 'P', 'E', 'T', 'S']
+    for k in expect_keys:
+        if k not in response_dict.keys():
+            return False
+    num_1 = response_dict['C'] * 100 + response_dict['A'] * 10 + response_dict['T']
+    num_2 = response_dict['D'] * 100 + response_dict['O'] * 10 + response_dict['G']
+    num_3 = response_dict['P'] * 1000 + response_dict['E'] * 100 + response_dict['T'] * 10 + response_dict['S']
+    return num_1 + num_2 == num_3
+
+def match_answer_function(response_dict, answer_dict):
+    for key, value in answer_dict.items():
+        cur_response = response_dict.get(key, None)
+        if isinstance(cur_response, list):
+            cur_response = set(cur_response)
+        if isinstance(value, list):
+            value = set(value)
+        if cur_response != value:
+            return False
+    return True
+
+def match_coordinate_function(response_list, answer_list):
+    response_coor = []
+    for coor in response_list:
+        response_coor.append(str(coor['row']) + str(coor['column']))
+
+    answer_coor = []
+    if isinstance(answer_list, dict):
+        answer_list = [answer_list]
+    for coor in answer_list:
+        answer_coor.append(str(coor['row']) + str(coor['column']))
+
+    return response_coor == answer_coor
+
+# answer justify: answer in xxx
+def multiple_match_function(response_dict, answer_list):
+    assert len(response_dict) == 1
+    response = list(response_dict.values())[0]
+    if isinstance(response, list):
+        response = set(response)
+        answer_list = [set(ans) for ans in answer_list]
+        return response in answer_list
+    else:
+        return response in answer_list
+
+def compare_expression_function(response_dict, anwser_list):
+    extract_equation = response_dict['equation']
+    extract_expr = sympy.parse_expr(extract_equation.split('=')[0], evaluate=False)
+    is_same = False
+    for answer_eq in anwser_list:
+        if is_same == True:
+            return True
+        is_cur_same = False
+        answer_expr = sympy.parse_expr(answer_eq.split('=')[0], evaluate=False)
+        if extract_expr.func != answer_expr.func:
+            is_cur_same = False
+            continue
+
+        # for addition and multiplication, check if the set of arguments is the same
+        if extract_expr.func in (sympy.Add, sympy.Mul):
+            args1 = extract_expr.args
+            args2 = answer_expr.args
+
+            # if the number of arguments is different, the expressions are not the same
+            if len(args1) != len(args2):
+                is_cur_same = False
+                continue
+            # check if the set of arguments is the same
+            is_cur_same = (set(str(arg) for arg in args1) == set(str(arg) for arg in args2))
+        # for other functions, check if the expression is the same
+        else:
+            is_cur_same = (extract_expr == answer_expr)
+        is_same = is_cur_same
+    return is_same
+
+def choice_function(response, answer):
+    try:
+        answer = eval(answer)
+    except:
+        pass
+    if isinstance(answer, list):
+        answer = ','.join(answer)
+    else:
+        answer = str(answer)
+    response_list = [ans.strip() for ans in response.split(',')]
+    answer_list = [ans.strip() for ans in answer.split(',')]
+    return set(response_list) == set(answer_list)
+
+
+def calculate_answer_function_hashi(response_list, answer=None, special_info=None):
+    if response_list is None or special_info is None or len(response_list) == 0:
+        return False
+    bridges = response_list
+    # special_info = json.loads(special_info)
+    init_islands = special_info["init_islands"]
+    # init_islands be like:
+    # [
+    # {"cord": "b1", "requirement": 2},
+    # {"cord": "f8", "requirement": 1}
+    # ]
+
+    def is_valid_hashi(init_islands, bridges):
+        from collections import defaultdict
+
+        # Helper function to parse coordinates
+        def parse_coordinate(cord):
+            letter, number = cord[0], int(cord[1:])
+            return ord(letter) - ord('a'), number
+
+        # Rule 1: Distinct islands check
+        for bridge in bridges:
+            if bridge['start'] == bridge['end']:
+                return False, "Rule 1 violated: Bridge starts and ends at the same island."
+
+        # Group islands by coordinates for quick lookup
+        island_requirements = {island['cord']: island['requirement'] for island in init_islands}
+        existing_islands = set(island_requirements.keys())
+
+        # Check for total bridge connections per island
+        bridge_count = defaultdict(int)
+        connection_count = defaultdict(int)
+
+        # Check each bridge for validity
+        for bridge in bridges:
+            start = bridge['start']
+            end = bridge['end']
+            number = bridge['number']
+
+            # Rule 6: Island existence check
+            if start not in existing_islands or end not in existing_islands:
+                return False, f"Rule 6 violated: One or both islands ({start}, {end}) do not exist."
+
+            # Rule 3: Orthogonal Check
+            start_x, start_y = parse_coordinate(start)
+            end_x, end_y = parse_coordinate(end)
+            if start_x != end_x and start_y != end_y:
+                return False, f"Rule 3 violated: Bridge between {start} and {end} is not orthogonal."
+
+            # Rule 4: Maximum two bridges between pair of islands
+            pair = tuple(sorted([start, end]))
+            connection_count[pair] += number
+            if connection_count[pair] > 2:
+                return False, f"Rule 4 violated: More than two bridges between {start} and {end}."
+
+            # Count connections for each island
+            bridge_count[start] += number
+            bridge_count[end] += number
+
+        # Rule 5: Check if each island's requirement is met
+        for island, requirement in island_requirements.items():
+            if bridge_count[island] != requirement:
+                return False, f"Rule 5 violated: Island {island} has {bridge_count[island]} bridges, requires {requirement}."
+
+        # Rule 2: Cross-check - Ensure no crossing bridges
+        occupied_lines = set()
+        for bridge in bridges:
+            start_x, start_y = parse_coordinate(bridge['start'])
+            end_x, end_y = parse_coordinate(bridge['end'])
+
+            # Generate the line path between start and end
+            if start_x == end_x:  # Vertical line
+                y_min, y_max = sorted([start_y, end_y])
+                for y in range(y_min + 1, y_max):
+                    line_segment = (start_x, y)
+                    if line_segment in occupied_lines:
+                        return False, f"Rule 2 violated: Crossing bridge at ({chr(start_x + ord('a'))}{y})."
+                    occupied_lines.add(line_segment)
+
+            elif start_y == end_y:  # Horizontal line
+                x_min, x_max = sorted([start_x, end_x])
+                for x in range(x_min + 1, x_max):
+                    line_segment = (x, start_y)
+                    if line_segment in occupied_lines:
+                        return False, f"Rule 2 violated: Crossing bridge at ({chr(x + ord('a'))}{start_y})."
+                    occupied_lines.add(line_segment)
+
+        return True, "Hashi: All rules satisfied."
+
+    validity, message = is_valid_hashi(init_islands, bridges)
+    print(message)
+    return validity
+
+
+def calculate_answer_function_skyscraper(response_list, answer=None, special_info=None):
+    if response_list is None or special_info is None or len(response_list) == 0:
+        return False
+
+    grid = response_list
+    visible_skyscrapers = special_info["visible_skyscrapers"]
+    # visible_skyscrapers be like:
+    # [
+    #     [3,2,1],
+    #     [3,2,1],
+    #     [1,None,2],
+    #     [1,2,None]
+    # ]
+    # represent the following case:
+    # [
+    #     [None,  3,      2,      1,      None],
+    #     [3,     None,   None,   None,   1],
+    #     [2,     None,   None,   None,   None],
+    #     [1,     None,   None,   None,   2],
+    #     [None,  1,      2,      None,   None]
+    # ]
+
+
+    # Verify if the base matrix has been changed
+    base_matrix = special_info['base_matrix']
+    size = len(base_matrix)
+    for i in range(size):
+        for j in range(size):
+            if base_matrix[i][j] is not None and base_matrix[i][j]!=response_list[i][j]:
+                # print("Mismatch with base matrix")
+                return False
+
+
+    for i in range(size):
+        if len(set(grid[i])) != size or len(set(row[i] for row in grid)) != size:
+            # print("repeat height on one row or colomn")
+            return False
+
+    def count_higher_than_previous(lst, target_count):
+        count = 1  # Start with 1 since the first number is always higher than "nothing before it"
+        max_so_far = lst[0]
+        for i in range(1, len(lst)):
+            if lst[i] > max_so_far:
+                count += 1
+                max_so_far = lst[i]
+        return count == target_count
+
+    # Verify the skyscraper rule
+    hori = grid
+    vert = [[grid[j][i] for j in range(len(grid))] for i in range(len(grid[0]))]
+
+    for index, h in enumerate(visible_skyscrapers[0]):
+        if h is None:
+            continue
+        if not count_higher_than_previous(vert[index], h):
+            # print("wrong visible towers")
+            return False
+
+    for index, h in enumerate(visible_skyscrapers[1]):
+        if h is None:
+            continue
+        if not count_higher_than_previous(hori[index], h):
+            # print("wrong visible towers")
+            return False
+
+    for index, h in enumerate(visible_skyscrapers[2]):
+        if h is None:
+            continue
+        if not count_higher_than_previous(hori[index][::-1], h):
+            # print("wrong visible towers")
+            return False
+
+    for index, h in enumerate(visible_skyscrapers[3]):
+        if h is None:
+            continue
+        if not count_higher_than_previous(vert[index][::-1], h):
+            # print("wrong visible towers")
+            return False
+    # print("Skyscraper: All rules satisfied.")
+    return True
+
+
+def calculate_answer_function_sudoku_4(response_list, answer=None, special_info=None):
+    if response_list is None or special_info is None or len(response_list) == 0:
+        return False
+
+    def is_valid_sudoku_4x4(grid):
+        # Check rows and columns
+        for i in range(4):
+            if len(set(grid[i])) != 4 or len(set(row[i] for row in grid)) != 4:
+                # print("repeat numbers in row or colomn")
+                return False
+
+        # Check 2x2 sub-grids
+        sub_grids = [
+            [grid[r][c] for r in range(2) for c in range(2)],  # Top-left
+            [grid[r][c] for r in range(2) for c in range(2, 4)],  # Top-right
+            [grid[r][c] for r in range(2, 4) for c in range(2)],  # Bottom-left
+            [grid[r][c] for r in range(2, 4) for c in range(2, 4)],  # Bottom-right
+        ]
+        for sub_grid in sub_grids:
+            if len(set(sub_grid)) != 4:
+                # print("repeat numbers in sub matrix")
+                return False
+        # print("Sudoku_4: All rules satisfied.")
+        return True
+
+    try:
+        # Parse the response string into a Python list
+        grid = response_list
+        if not isinstance(grid, list) or len(grid) != 4 or not all(len(row) == 4 for row in grid):
+            return False
+
+        # Verify if the base matrix has been changed
+        base_matrix = special_info['base_matrix']
+        for i in range(4):
+            for j in range(4):
+                if base_matrix[i][j] is not None and base_matrix[i][j]!=grid[i][j]:
+                    # print("Mismatch with base matrix")
+                    return False
+
+        # Validate the Sudoku grid
+        return is_valid_sudoku_4x4(grid)
+    except (ValueError, SyntaxError):
+        return False
+
+
+def calculate_answer_function_sudoku_6(response_list, answer=None, special_info=None):
+    if response_list is None or special_info is None or len(response_list) == 0:
+        return False
+
+    def is_valid_sudoku_6x6(grid):
+        # Check rows and columns
+        for i in range(6):
+            if len(set(grid[i])) != 6 or len(set(row[i] for row in grid)) != 6:
+                return False
+
+        # Check 2x2 sub-grids
+        sub_grids = [
+            [grid[r][c] for r in range(2) for c in range(3)],  # Top-left
+            [grid[r][c] for r in range(2) for c in range(3, 6)],  # Top-right
+            [grid[r][c] for r in range(2, 4) for c in range(3)],  # Middle-left
+            [grid[r][c] for r in range(2, 4) for c in range(3, 6)],  # Middle-right
+            [grid[r][c] for r in range(4, 6) for c in range(3)],  # Bottom-left
+            [grid[r][c] for r in range(4, 6) for c in range(3, 6)],  # Bottom-right
+        ]
+        for sub_grid in sub_grids:
+            if len(set(sub_grid)) != 6:
+                return False
+        return True
+
+    try:
+        # Parse the response string into a Python list
+        grid = response_list
+        if not isinstance(grid, list) or len(grid) != 6 or not all(len(row) == 6 for row in grid):
+            return False
+
+        # Verify if the base matrix has been changed
+        base_matrix = special_info['base_matrix']
+        for i in range(6):
+            for j in range(6):
+                if base_matrix[i][j] is not None and base_matrix[i][j]!=grid[i][j]:
+                    return False
+
+        # Validate the Sudoku grid
+        return is_valid_sudoku_6x6(grid)
+    except (ValueError, SyntaxError):
+        return False
+
+
+def calculate_answer_function_yinyang(response_list, answer=None, special_info=None):
+    if response_list is None or special_info is None or len(response_list) == 0:
+        return False
+
+    def is_connected(matrix, value):
+        rows, cols = len(matrix), len(matrix[0])
+        visited = [[False for _ in range(cols)] for _ in range(rows)]
+
+        def dfs(r, c):
+            if r < 0 or r >= rows or c < 0 or c >= cols or visited[r][c] or matrix[r][c] != value:
+                return
+            visited[r][c] = True
+            for dr, dc in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
+                dfs(r + dr, c + dc)
+
+        # Find the first cell with the given value
+        for r in range(rows):
+            for c in range(cols):
+                if matrix[r][c] == value:
+                    dfs(r, c)
+                    break
+            else:
+                continue
+            break
+
+        # Check if all cells with the given value are visited
+        for r in range(rows):
+            for c in range(cols):
+                if matrix[r][c] == value and not visited[r][c]:
+                    return False
+        return True
+
+    def has_2x2_block(matrix, value):
+        rows, cols = len(matrix), len(matrix[0])
+        for r in range(rows - 1):
+            for c in range(cols - 1):
+                # Check if a 2x2 block is formed by the same value
+                if (
+                    matrix[r][c] == value and
+                    matrix[r][c + 1] == value and
+                    matrix[r + 1][c] == value and
+                    matrix[r + 1][c + 1] == value
+                ):
+                    return True
+        return False
+
+    # Check if the response is a 6x6 matrix
+    if not isinstance(response_list, list) or len(response_list) != 6 or any(len(row) != 6 for row in response_list):
+        return False
+
+    # Verify if the base matrix has been changed
+    base_matrix = special_info['base_matrix']
+    for i in range(6):
+        for j in range(6):
+            if base_matrix[i][j] is not None and base_matrix[i][j]!=response_list[i][j]:
+                print("Mismatch with base matrix")
+                return False
+
+    # Check if 0s and 1s form connected components
+    if not is_connected(response_list, 0) or not is_connected(response_list, 1):
+        print("not connected")
+        return False
+
+    # Check if there are any 2x2 blocks of 0s or 1s
+    if has_2x2_block(response_list, 0) or has_2x2_block(response_list, 1):
+        print("exist 2x2 block")
+        return False
+    print("Yinyang: All rules satisfied")
+    return True
+
+def judge_24points_function(response, answer=None, special_info=None):
+    left_formula = response.replace(' ', '').split('=')[0]
+    try:
+        if eval(left_formula) == 24:
+            numbers = re.findall(r'\d+', left_formula)
+            numbers = list(map(int, numbers))
+            numbers.sort()
+            expect_numbers = special_info['init_cards']
+            expect_numbers.sort()
+            if numbers == expect_numbers:
+                return True
+            else:
+                return False
+        else:
+            return False
+
+    except:
+        return False
+
+mme_reasoning_eval_functions = {
+    "calculate_answer_function_1": calculate_answer_function_1,
+    "calculate_answer_function_2": calculate_answer_function_2,
+    "calculate_answer_function_3": calculate_answer_function_3,
+    "calculate_answer_function_4": calculate_answer_function_4,
+    "calculate_answer_function_5": calculate_answer_function_5,
+    "calculate_answer_function_6": calculate_answer_function_6,
+    "calculate_answer_function_7": calculate_answer_function_7,
+    "calculate_answer_function_8": calculate_answer_function_8,
+    "calculate_answer_function_9": calculate_answer_function_9,
+    "calculate_answer_function_10": calculate_answer_function_10,
+    "calculate_answer_function_11": calculate_answer_function_11,
+    "calculate_answer_function_12": calculate_answer_function_12,
+    "match_answer_function": match_answer_function,
+    "multiple_match_function": multiple_match_function,
+    "compare_expression_function": compare_expression_function,
+    "match_coordinate_function": match_coordinate_function,
+    "choice_function": choice_function,
+    "calculate_answer_function_hashi": calculate_answer_function_hashi,
+    "calculate_answer_function_skyscraper": calculate_answer_function_skyscraper,
+    "calculate_answer_function_sudoku_4": calculate_answer_function_sudoku_4,
+    "calculate_answer_function_sudoku_6": calculate_answer_function_sudoku_6,
+    "calculate_answer_function_yinyang": calculate_answer_function_yinyang,
+    "judge_24points_function": judge_24points_function
+}
+
+
+def extract_json_from_response(text):
+    patterns = [
+        r'```json\s*(.*?)\s*```',
+        r'```\s*(.*?)\s*```',
+        r'```JSON\s*(.*?)\s*```'
+    ]
+    for pattern in patterns:
+        match = re.search(pattern, text, re.DOTALL)
+        if match:
+            json_str = match.group(1)
+            return json_str
+    return None
+
+
+def MMEReasoning_extract(model, line):
+    res = None
+    question, response = line['question'], line['prediction']
+    eval_function, eval_prompt = line['function_id'], line['prompt_id']
+    if eval_function == None:
+        if line['question_type'].lower() == 'choice':
+            eval_prompt, eval_function = 'choice_prompt', 'choice_function'
+        elif line['question_type'].lower() == 'open':
+            eval_prompt, eval_function = 'open_question_prompt', 'open_function'
+        else:
+            raise NotImplementedError(f"Question type that requires specifying the function_id: {line['question_type']}")
+
+    prompt = mme_reasoning_eval_prompts[eval_prompt].format(question=question, response=response)
+    log = ''
+    retry = 5
+
+    for i in range(retry):
+        prediction = line['prediction']
+        if prediction == FAIL_MSG:
+            log += f'Try {i}: output is {prediction}, failed to parse.\n'
+            return dict(log=log, res='')
+        res = model.generate(prompt, temperature=i * 0.5)
+        if eval_prompt not in ['open_question_prompt', 'choice_prompt', 'points24_prompt']:
+            try:
+                json.loads(res)
+            except:
+                try:
+                    json.loads(extract_json_from_response(res))
+                    res = extract_json_from_response(res)
+                except:
+                    continue
+
+        if FAIL_MSG in res:
+            log += f'Try {i}: output is {prediction}, failed to parse.\n'
+        else:
+            log += 'Succeed'
+            return dict(log=log, res=res)
+    log += 'All 5 retries failed.\n'
+    return dict(log=log, res='')
+
+def MMEReasoning_openeval(model, line):
+    prompt_openeval = """
+Please read the following example. Then judge the answer and type it at the end of the prompt.
+Below are two examples. Question is [Question], [Standard Answer] is the standard answer to the question, and [Model_answer] is the answer extracted from a model's output to this question.  Determine whether these two answers are consistent.
+Note:
+    Different expressions of the same number should also be considered consistent, for example, \\frac{{7}}{{2}} and 3.5.
+    If a conversion results in a decimal approximation, the expressions can be considered consistent if the values are equal up to two decimal places, for example, \\sqrt{{3}} and 1.73.
+If they are consistent, Judgement is 1; if they are different, Judgement is 0.\n
+Example 1:
+    [Question]: What is the minimize length of the line?
+    [Standard answer]: \\sqrt{{2}}
+    [Model answer]: 1.414
+    [Judgement]: 1
+Example 2:
+    [Question]: Given an image of a 3x3 maze. How to reach the end cell marked 'E' from the start cell is marked 'S'.
+    [Standard answer]: ['Left', 'Right']
+    [Model answer]: 'Left', 'Right'
+    [Judgement]: 1
+
+Now, judge the anwser for the following question:
+    [Question]: {question}
+    [Standard answer]: {answer}
+    [Model answer]: {response}
+    [Judgement]:
+You should only output the judgement without any other texts.
+"""
+    log = ''
+    retry = 5
+    prompt = prompt_openeval.format(question=line['question'], answer=line['answer'], response=line['res'])
+    for i in range(retry):
+        try:
+            prediction = line['res']
+            if prediction == None or FAIL_MSG in prediction:
+                log += f'Try {i}: output is {prediction}, failed to parse.\n'
+                return dict(log_score=log, score=False)
+            res = model.generate(prompt, temperature=i * 0.5)
+            if FAIL_MSG in res or res.strip() not in ['0', '1']:
+                log += f'Try {i}: output is {prediction}, res is {res}, failed to parse.\n'
+            else:
+                log += 'Succeed'
+                return dict(log_score=log, score=int(res) == 1)
+        except:
+            continue
+    log += 'All 5 retries failed.\n'
+    return dict(log_score=log, score=False)
+
+
+def MMEReasoning_acc(result_file):
+    df = load(result_file)
+
+    capabilities = ['planning and exploring', 'calculation', 'spatial-temporal', 'casual chaining analysis', 'pattern analysis']
+    reasoning_types = ['inductive', 'deductive', 'abductive']
+
+    res = defaultdict(list)
+
+    # Overall Acc
+    res['Overall'].append(np.mean(df['score']) * 100)
+    for capability in capabilities:
+        sub = df[df['capability'].apply(lambda x: capability in x)]
+        res[capability].append(np.mean(sub['score']) * 100)
+
+    for r_type in reasoning_types:
+        sub = df[df['reasoning_type'].apply(lambda x: r_type in x)]
+        res[r_type].append(np.mean(sub['score']) * 100)
+
+    return pd.DataFrame(res)
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/mmif/__pycache__/__init__.cpython-310.pyc b/VLMEvalKit-sudoku/vlmeval/dataset/utils/mmif/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9ed197b2c7cfefdbbcdc7442597339e98fb1aa94
Binary files /dev/null and b/VLMEvalKit-sudoku/vlmeval/dataset/utils/mmif/__pycache__/__init__.cpython-310.pyc differ
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/mmniah.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/mmniah.py
new file mode 100644
index 0000000000000000000000000000000000000000..34604ad8dd89a7ba6fd057961b312d8d82f5c774
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/mmniah.py
@@ -0,0 +1,298 @@
+import re
+import json
+
+
+def has_word(sentence, word):
+    pattern = r'\b' + re.escape(word) + r'\b'
+    match = re.search(pattern, sentence)
+    if match:
+        return True
+    else:
+        return False
+
+
+class VQAEval:
+    def __init__(self):
+        self.contractions = {
+            'aint': "ain't",
+            'arent': "aren't",
+            'cant': "can't",
+            'couldve': "could've",
+            'couldnt': "couldn't",
+            "couldn'tve": "couldn't've",
+            "couldnt've": "couldn't've",
+            'didnt': "didn't",
+            'doesnt': "doesn't",
+            'dont': "don't",
+            'hadnt': "hadn't",
+            "hadnt've": "hadn't've",
+            "hadn'tve": "hadn't've",
+            'hasnt': "hasn't",
+            'havent': "haven't",
+            'hed': "he'd",
+            "hed've": "he'd've",
+            "he'dve": "he'd've",
+            'hes': "he's",
+            'howd': "how'd",
+            'howll': "how'll",
+            'hows': "how's",
+            "Id've": "I'd've",
+            "I'dve": "I'd've",
+            'Im': "I'm",
+            'Ive': "I've",
+            'isnt': "isn't",
+            'itd': "it'd",
+            "itd've": "it'd've",
+            "it'dve": "it'd've",
+            'itll': "it'll",
+            "let's": "let's",
+            'maam': "ma'am",
+            'mightnt': "mightn't",
+            "mightnt've": "mightn't've",
+            "mightn'tve": "mightn't've",
+            'mightve': "might've",
+            'mustnt': "mustn't",
+            'mustve': "must've",
+            'neednt': "needn't",
+            'notve': "not've",
+            'oclock': "o'clock",
+            'oughtnt': "oughtn't",
+            "ow's'at": "'ow's'at",
+            "'ows'at": "'ow's'at",
+            "'ow'sat": "'ow's'at",
+            'shant': "shan't",
+            "shed've": "she'd've",
+            "she'dve": "she'd've",
+            "she's": "she's",
+            'shouldve': "should've",
+            'shouldnt': "shouldn't",
+            "shouldnt've": "shouldn't've",
+            "shouldn'tve": "shouldn't've",
+            "somebody'd": 'somebodyd',
+            "somebodyd've": "somebody'd've",
+            "somebody'dve": "somebody'd've",
+            'somebodyll': "somebody'll",
+            'somebodys': "somebody's",
+            'someoned': "someone'd",
+            "someoned've": "someone'd've",
+            "someone'dve": "someone'd've",
+            'someonell': "someone'll",
+            'someones': "someone's",
+            'somethingd': "something'd",
+            "somethingd've": "something'd've",
+            "something'dve": "something'd've",
+            'somethingll': "something'll",
+            'thats': "that's",
+            'thered': "there'd",
+            "thered've": "there'd've",
+            "there'dve": "there'd've",
+            'therere': "there're",
+            'theres': "there's",
+            'theyd': "they'd",
+            "theyd've": "they'd've",
+            "they'dve": "they'd've",
+            'theyll': "they'll",
+            'theyre': "they're",
+            'theyve': "they've",
+            'twas': "'twas",
+            'wasnt': "wasn't",
+            "wed've": "we'd've",
+            "we'dve": "we'd've",
+            'weve': "we've",
+            'werent': "weren't",
+            'whatll': "what'll",
+            'whatre': "what're",
+            'whats': "what's",
+            'whatve': "what've",
+            'whens': "when's",
+            'whered': "where'd",
+            'wheres': "where's",
+            'whereve': "where've",
+            'whod': "who'd",
+            "whod've": "who'd've",
+            "who'dve": "who'd've",
+            'wholl': "who'll",
+            'whos': "who's",
+            'whove': "who've",
+            'whyll': "why'll",
+            'whyre': "why're",
+            'whys': "why's",
+            'wont': "won't",
+            'wouldve': "would've",
+            'wouldnt': "wouldn't",
+            "wouldnt've": "wouldn't've",
+            "wouldn'tve": "wouldn't've",
+            'yall': "y'all",
+            "yall'll": "y'all'll",
+            "y'allll": "y'all'll",
+            "yall'd've": "y'all'd've",
+            "y'alld've": "y'all'd've",
+            "y'all'dve": "y'all'd've",
+            'youd': "you'd",
+            "youd've": "you'd've",
+            "you'dve": "you'd've",
+            'youll': "you'll",
+            'youre': "you're",
+            'youve': "you've",
+        }
+        self.manualMap = {
+            'zero': 0, 'one': 1, 'two': 2, 'three': 3, 'four': 4,
+            'five': 5, 'six': 6, 'seven': 7, 'eight': 8, 'nine': 9,
+            'ten': 10, 'eleven': 11, 'twelve': 12, 'thirteen': 13,
+            'fourteen': 14, 'fifteen': 15, 'sixteen': 16,
+            'seventeen': 17, 'eighteen': 18, 'nineteen': 19,
+            'twenty': 20, 'thirty': 30, 'forty': 40, 'fifty': 50,
+            'sixty': 60, 'seventy': 70, 'eighty': 80, 'ninety': 90}
+        self.articles = ['a', 'an', 'the']
+
+        self.periodStrip = re.compile('(?!<=\\d)(\\.)(?!\\d)')
+        self.commaStrip = re.compile('(\\d)(\\,)(\\d)')
+        self.punct = [
+            ';',
+            r'/',
+            '[',
+            ']',
+            '"',
+            '{',
+            '}',
+            '(',
+            ')',
+            '=',
+            '+',
+            '\\',
+            '_',
+            '-',
+            '>',
+            '<',
+            '@',
+            '`',
+            ',',
+            '?',
+            '!',
+        ]
+
+    def evaluate(self, answer, gt_answers):
+        answer = answer.replace('\n', ' ')
+        answer = answer.replace('\t', ' ')
+        answer = answer.strip()
+        answer = self.processPunctuation(answer)
+        answer = self.processDigitArticle(answer)
+        if isinstance(gt_answers, list):
+            for i in range(len(gt_answers)):
+                gt_answers[i] = str(gt_answers[i])
+                gt_answers[i] = gt_answers[i].replace('\n', ' ')
+                gt_answers[i] = gt_answers[i].replace('\t', ' ')
+                gt_answers[i] = gt_answers[i].strip()
+                gt_answers[i] = self.processPunctuation(gt_answers[i])
+                gt_answers[i] = self.processDigitArticle(gt_answers[i])
+                if has_word(answer, gt_answers[i]):
+                    return 1
+            return 0
+        else:
+            gt_answers = gt_answers.replace('\n', ' ')
+            gt_answers = gt_answers.replace('\t', ' ')
+            gt_answers = gt_answers.strip()
+            gt_answers = self.processPunctuation(gt_answers)
+            gt_answers = self.processDigitArticle(gt_answers)
+            if has_word(answer, gt_answers):
+                return 1
+            else:
+                return 0
+
+    def evaluate_MRR(self, answer, gt_answers):
+        answer = answer.replace('\n', ' ')
+        answer = answer.replace('\t', ' ')
+        answer = answer.strip()
+        answer = self.processPunctuation(answer)
+        answer = self.processDigitArticle(answer)
+        assert isinstance(gt_answers, list)
+        for i in range(len(gt_answers)):
+            gt_answers[i] = gt_answers[i].replace('\n', ' ')
+            gt_answers[i] = gt_answers[i].replace('\t', ' ')
+            gt_answers[i] = gt_answers[i].strip()
+            gt_answers[i] = self.processPunctuation(gt_answers[i])
+            gt_answers[i] = self.processDigitArticle(gt_answers[i])
+            if has_word(answer, gt_answers[i]):
+                return 1 / (i + 1)
+        return 0.0
+
+    def processPunctuation(self, inText):
+        outText = inText
+        for p in self.punct:
+            if (p + ' ' in inText or ' ' + p in inText) or (
+                re.search(self.commaStrip, inText) is not None
+            ):
+                outText = outText.replace(p, '')
+            else:
+                outText = outText.replace(p, ' ')
+        outText = self.periodStrip.sub('', outText, re.UNICODE)
+        return outText
+
+    def processDigitArticle(self, inText):
+        outText = []
+        tempText = inText.lower().split()
+        for word in tempText:
+            word = self.manualMap.setdefault(word, word)
+            if word not in self.articles:
+                outText.append(word)
+            else:
+                pass
+        for wordId, word in enumerate(outText):
+            if word in self.contractions:
+                outText[wordId] = self.contractions[word]
+
+        outText = [str(text) for text in outText]
+        outText = ' '.join(outText)
+        return outText
+
+
+def is_correct(answer, response):
+    # response_orig = response
+    response = response.strip('.')
+    if isinstance(answer, int):
+        if response.isdigit():
+            return int(int(response) == answer)
+
+        response = response.lower()
+        response = response.replace('the answer is', '')
+        response = response.replace('*', '')  # parse **A**
+        if response.find('.') != -1:
+            response = response.split('.')[0]
+            response = response.replace(',', '')
+            response = response.strip()
+        response = response.strip()
+
+        if response == 'none':
+            return 0
+
+        if 'the camera is moving left' in response:
+            response = 'a'
+        elif 'the camera is moving right' in response:
+            response = 'b'
+
+        if len(response) != 1:
+            # print(f"Fail to parse {response_orig}")
+            return 0
+
+        return (ord(response) - ord('a')) == answer
+
+    if isinstance(answer, list):
+        try:
+            response = response.replace('json', '').replace('```', '').strip()
+            response = json.loads(response)
+            if isinstance(response, dict):
+                response = sum(list(response.values()), start=[])
+        except:
+            # print(f"Fail to parse {response_orig} Exception: {e}")
+            return 0
+
+        if not isinstance(response, (list, tuple)):
+            # print(f"Fail to parse {response_orig} Exception: not a list!")
+            return 0
+
+        match = 0
+        for res, ans in zip(response, answer):
+            match += res == ans
+        return match / len(answer)
+
+    return VQAEval().evaluate(response, answer)
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/ocr_reasoning.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/ocr_reasoning.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc6144765cbd0fe82c73e4cc421d31c521957b9b
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/ocr_reasoning.py
@@ -0,0 +1,169 @@
+from ...smp import *
+from ...utils import can_infer
+import re
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+judge_prompts = '''Please act as an impartial judge and evaluate the quality of the response provided by an AI assistant to the user question displayed below. Your evaluation should consider correctness and helpfulness. You will be given a reference answer and the assistant's answer. Begin your evaluation by comparing the assistant's answer with the reference answer. Identify and correct any mistakes. Be as objective as possible. After providing your explanation, you must rate the response on a scale of 1 to 10 by strictly following this format: \"[[rating]]\", for example: \"Rating: [[5]]\".\n\n[Question]\n{question}\n\n[The Start of Reference Answer]\n{ref_answer_1}\n[The End of Reference Answer]\n\n[The Start of Assistant's Answer]\n{answer}\n[The End of Assistant's Answer]". Again, you must output a score by strictly following this format: \"[[rating]]\", for example: \"Rating: [[5]]\".''' # noqa e501
+
+
+def get_gpt4_ICE():
+    example_1 = """
+Question: 2023年品牌二的三收入比17年品牌一的收入多多少？\n
+Model response: 2023年品牌二的收入为420亿元人民币，2017年品牌一的收入为820亿元人民币。\n420 - 820 = -400亿元人民币\n
+所以，2023年品牌二的收入比2017年品牌一的收入少了400亿元人民币。\n
+Extracted answer: 400亿元人民币
+"""
+
+    example_2 = """
+Question: What is the total price of all dishes with chicken?\n
+Model response: The total price of all dishes with chicken is $103.00.\n
+Extracted answer: $103.00
+"""
+
+    example_3 = """
+Question: 如果2021年的全年营业收入和全年归母净利润的YOY和2022年一样，那么2020年全年归母净利润占全年营业收入的多少？\n
+Model response: 2021年的全年营业收入和全年归母净利润的YOY和2022年一样，那么2020年全年归母净利润占全年营业收入的百分比为：\n0.52亿 / 1.25亿 * 100% ≈ 41.60%\n
+Extracted answer: 41.60%
+"""
+
+    example_4 = """
+Question: What is the fraction of females facing the camera?\n
+Model response: The fraction of females facing the camera is 0.6,
+which means that six out of ten females in the group are facing the camera.\n
+Extracted answer: 0.6
+"""
+
+    example_5 = """
+Question: What fraction of the shape is blue?\n
+Choices: (A) 3/11 (B) 8/11 (C) 6/11 (D) 3/5\n
+Model response: The correct answer is (B) 8/11.\n
+Extracted answer: B
+"""
+
+    return [example_1, example_2, example_3, example_4, example_5]
+
+
+def build_ocrr_gpt4_prompt(line):
+    task_description = """
+Please read the following example.
+Then extract the answer from the model response and type it at the end of the prompt.\n
+"""
+    question = line['question']
+    prediction = str(line['prediction'])
+    prompt = task_description
+    examples = get_gpt4_ICE()
+    for example in examples:
+        prompt += example + '\n'
+    prompt += question + '\n'
+    prompt += 'Model respone: ' + prediction
+    prompt += 'Extracted answer:'
+    return prompt
+
+
+def list_to_dict(lst):
+    return {chr(65 + i): val for i, val in enumerate(lst)}
+
+
+def post_check(line, prefetch=False):
+    res = None
+    ans = line['answer']
+    response = line['prediction'] if prefetch else line['res']
+    try:
+        if line['question_type'] == 'multi_choice':
+            ans = line['answer_option']
+            choices = list_to_dict(eval(line['choices']))
+            res = can_infer(response, choices)
+            if prefetch:
+                return res
+        else:
+            if line['answer_type'] == 'integer':
+                res = int(response)
+                ans = int(line['answer'])
+            elif line['answer_type'] == 'float':
+                res = float(response)
+                ans = float(line['answer'])
+            else:
+                res = str(response).replace(' ', '')
+                ans = str(ans).replace(' ', '')
+    except ValueError:
+        pass
+    if res == ans:
+        return res if prefetch else True
+    else:
+        return False
+
+
+def OcrR_auxeval(model, line):
+    prompt = build_ocrr_gpt4_prompt(line)
+    log = ''
+    retry = 5
+
+    reason_prompt = judge_prompts.format(question=line['question'], ref_answer_1=line['reasoning'], answer=line['prediction']) # noqa e501
+    for i in range(6):
+        reason_score = model.generate(reason_prompt, temperature=i * 0.3)
+        match = re.search(r'\[\[(\d+)\]\]', reason_score)
+        if match is not None:
+            break
+    reason_score = int(match.group(1)) / 10
+
+    if post_check(line, prefetch=True):
+        res = post_check(line, prefetch=True)
+        return dict(log='Prefetch succeed', res=res, reason_score=reason_score)
+
+    for i in range(retry):
+        prediction = line['prediction']
+        res = model.generate(prompt, temperature=i * 0.5)
+        if FAIL_MSG in res:
+            log += f'Try {i}: output is {prediction}, failed to parse.\n'
+        else:
+            log += 'Succeed'
+            return dict(log=log, res=res, reason_score=reason_score)
+    log += 'All 5 retries failed.\n'
+    return dict(log=log, res='', reason_score=0.0)
+
+
+def OcrR_acc(result_file):
+    data = load(result_file)
+    tot = defaultdict(lambda: 0)
+    fetch = defaultdict(lambda: 0)
+    hit = defaultdict(lambda: 0)
+    tot_rp = defaultdict(lambda: 0)
+    lt = len(data)
+    for i in range(lt):
+        item = data.iloc[i]
+        cate = item['task']
+        tot['Overall'] += 1
+        tot[cate] += 1
+        if item['log'] == 'Prefetch succeed':
+            fetch['Overall'] += 1
+            fetch[cate] += 1
+        if post_check(item, prefetch=False):
+            hit['Overall'] += 1
+            hit[cate] += 1
+
+    for i in range(lt):
+        item = data.iloc[i]
+        cate = item['task']
+        tot_rp['Overall_RP'] += item['reason_score']
+        tot_rp[cate + '_RP'] += item['reason_score']
+
+    res = defaultdict(list)
+    for k in tot.keys():
+        res['Task'].append(k)
+        res['tot'].append(tot[k])
+        res['prefetch'].append(fetch[k])
+        res['hit'].append(hit[k])
+        res['prefetch_rate'].append(fetch[k] / tot[k] * 100)
+        res['acc'].append(hit[k] / tot[k] * 100)
+
+    for k in tot_rp.keys():
+        res['Task'].append(k)
+        res['tot'].append(tot[k.replace('_RP', '')])
+        res['prefetch'].append(0)
+        res['hit'].append(0)
+        res['prefetch_rate'].append(0)
+        res['acc'].append(tot_rp[k] / tot[k.replace('_RP', '')] * 100)
+
+    res = pd.DataFrame(res)
+    return res
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/ocrbench.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/ocrbench.py
new file mode 100644
index 0000000000000000000000000000000000000000..dedee4bfc0c257d0ba9a347feee9bef7b4f520ba
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/ocrbench.py
@@ -0,0 +1,65 @@
+from ...smp import *
+
+
+def OCRBench_eval(eval_file):
+    OCRBench_score = {
+        'Regular Text Recognition': 0,
+        'Irregular Text Recognition': 0,
+        'Artistic Text Recognition': 0,
+        'Handwriting Recognition': 0,
+        'Digit String Recognition': 0,
+        'Non-Semantic Text Recognition': 0,
+        'Scene Text-centric VQA': 0,
+        'Doc-oriented VQA': 0,
+        'Key Information Extraction': 0,
+        'Handwritten Mathematical Expression Recognition': 0
+    }
+
+    logger = get_logger('Evaluation')
+
+    data = load(eval_file)
+    lt = len(data)
+    lines = [data.iloc[i] for i in range(lt)]
+    for i in tqdm(range(len(lines))):
+        line = lines[i]
+        predict = str(line['prediction'])
+        answers = eval(line['answer'])
+        category = line['category']
+        if category == 'Handwritten Mathematical Expression Recognition':
+            for j in range(len(answers)):
+                answer = answers[j].strip().replace('\n', ' ').replace(' ', '')
+                predict = predict.strip().replace('\n', ' ').replace(' ', '')
+                if answer in predict:
+                    OCRBench_score[category] += 1
+                    break
+        else:
+            for j in range(len(answers)):
+                answer = answers[j].lower().strip().replace('\n', ' ')
+                predict = predict.lower().strip().replace('\n', ' ')
+                if answer in predict:
+                    OCRBench_score[category] += 1
+                    break
+
+    final_score_dict = {}
+    final_score_dict['Text Recognition'] = (
+        OCRBench_score['Regular Text Recognition'] + OCRBench_score['Irregular Text Recognition']
+        + OCRBench_score['Artistic Text Recognition'] + OCRBench_score['Handwriting Recognition']
+        + OCRBench_score['Digit String Recognition'] + OCRBench_score['Non-Semantic Text Recognition']
+    )
+    final_score_dict['Scene Text-centric VQA'] = OCRBench_score['Scene Text-centric VQA']
+    final_score_dict['Doc-oriented VQA'] = OCRBench_score['Doc-oriented VQA']
+    final_score_dict['Key Information Extraction'] = OCRBench_score['Key Information Extraction']
+    final_score_dict['Handwritten Mathematical Expression Recognition'] = \
+        OCRBench_score['Handwritten Mathematical Expression Recognition']
+    final_score_dict['Final Score'] = (
+        final_score_dict['Text Recognition'] + final_score_dict['Scene Text-centric VQA']
+        + final_score_dict['Doc-oriented VQA'] + final_score_dict['Key Information Extraction']
+        + final_score_dict['Handwritten Mathematical Expression Recognition']
+    )
+    final_score_dict['Final Score Norm'] = float(final_score_dict['Final Score']) / 10
+    score_pth = get_intermediate_file_path(eval_file, '_score', 'json')
+    dump(final_score_dict, score_pth)
+    logger.info(f'OCRBench_eval successfully finished evaluating {eval_file}, results saved in {score_pth}')
+    logger.info('Score: ')
+    for key, value in final_score_dict.items():
+        logger.info('{}:{}'.format(key, value))
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/omni3dbench.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/omni3dbench.py
new file mode 100644
index 0000000000000000000000000000000000000000..f41652fb639efe7fa2fcca4bc2dd8afb36c19c3b
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/omni3dbench.py
@@ -0,0 +1,99 @@
+from collections import defaultdict
+import pandas as pd
+
+OMNI3DBENCH_PROMPT = """
+I will ask you a question based on an image. Answer with either true/false, one word or number, \
+place your answer between <ans></ans> tags. Only include your answer. Question:
+"""
+
+
+def extract_answer(prediction):
+    if '<ans>' in prediction:
+        return prediction.split('<ans>')[1].split('</ans>')[0]
+    else:
+        return prediction
+
+
+def Omni3DBench_acc(data):
+    mra_thresholds = [0.5, 0.45, 0.40, 0.35, 0.3, 0.25, 0.2, 0.15, 0.1, 0.05]
+    correct_at_threshold = {key: 0 for key in mra_thresholds}
+    yn_correct = 0
+    yn_n = 0
+    num_ct_n = 0
+    num_ct_correct = 0
+    multi_correct = 0
+    multi_n = 0
+    num_other_n = 0
+
+    for i in range(len(data)):
+        row = data.iloc[i]
+        ans_type = row['answer_type']
+        gt = row['answer']
+        pred = extract_answer(row['prediction'])
+
+        # Numeric (count)
+        if ans_type == "int":
+            num_ct_n += 1
+            try:
+                pred = int(pred)
+            except:
+                continue
+            gt = int(gt)
+            if gt == pred:
+                num_ct_correct += 1
+        elif ans_type == "str":
+            # Yes/No
+            if gt in ["yes", "no"]:
+                yn_n += 1
+                try:
+                    if gt in pred.lower():
+                        yn_correct += 1
+                    elif gt == "yes" and "true" in pred.lower():
+                        yn_correct += 1
+                    elif gt == "no" and "false" in pred.lower():
+                        yn_correct += 1
+                except:
+                    continue
+            # Multi-choice
+            else:
+                multi_n += 1
+                try:
+                    if gt == pred.lower():
+                        multi_correct += 1
+                except:
+                    continue
+        elif ans_type == "float":
+            # Numeric (other)
+            # Calculated Mean Relative Accuracy (MRA) introduced in VSI-Bench (https://arxiv.org/abs/2412.14171)
+            num_other_n += 1
+            for threshold in mra_thresholds:
+                try:
+                    pred = float(pred)
+                except:
+                    continue
+                gt = float(gt)
+                if abs(gt - pred) / gt < threshold:
+                    correct_at_threshold[threshold] += 1
+
+    # Compute averages
+    yn_acc = yn_correct / yn_n if yn_n != 0 else None
+    multi_acc = multi_correct / multi_n if multi_n != 0 else None
+    num_ct_acc = num_ct_correct / num_ct_n if num_ct_n != 0 else None
+    num_other_mra = 0
+
+    if num_other_n != 0:
+        for threshold in mra_thresholds:
+            correct_at_threshold[threshold] /= num_other_n
+            num_other_mra += correct_at_threshold[threshold]
+
+        num_other_mra = num_other_mra / len(mra_thresholds)
+    else:
+        num_other_mra = None
+
+    res = defaultdict(list)
+    res['Yes/No Accuracy'].append(yn_acc)
+    res['Multiple Choice Accuracy'].append(multi_acc)
+    res['Numeric (count) Accuracy'].append(num_ct_acc)
+    res['Numeric (other) Mean Relative Accuracy'].append(num_other_mra)
+    res = pd.DataFrame(res)
+    return res
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/physic.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/physic.py
new file mode 100644
index 0000000000000000000000000000000000000000..515623f2a83816f0dbf2065c8248c368ced859a8
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/physic.py
@@ -0,0 +1,103 @@
+import logging
+import re
+import timeout_decorator
+from sympy import simplify, expand, trigsimp
+from sympy.parsing.latex import parse_latex
+from ...smp import *
+from ...utils import can_infer
+import json
+from collections import defaultdict
+from tqdm import tqdm
+import pandas as pd
+from .physics_eval_utils import extract_final_answer_allform, is_equiv
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+def build_physic_prompt(line):
+    prompt_text = (
+        "You are a physics expert assistant. Solve the following question step-by-step.\n\n"
+        "At the VERY END of your answer, output ONLY the FINAL ANSWER in this format:\n\n"
+        "\\[\n\\boxed{{your_final_answer_here}}\n\\]\n\n"
+        "You MUST put the final answer in the `\\boxed{}` environment.\n"
+        "This applies even if the answer is a text explanation like \"The singlet state is lower in energy.\"\n"
+        "Do NOT include multiple boxes.\n"
+        "Do NOT include \\boxed anywhere else in your reasoning.\n"
+        "The box must appear on the last line of the response.\n\n"
+        "WARNING: DO NOT forget to include \boxed{} with the final answer. Responses without it will be considered INVALID.\n\n"  # noqa: E501
+        "Example:\n\n"
+        "Question: What is the energy difference between n=2 and n=1 in hydrogen?\n"
+        "Answer:\nThe energy levels are E_n = -13.6 / n² (in eV).\n"
+        "E_2 = -13.6 / 4 = -3.4 eV\n"
+        "E_1 = -13.6 eV\n"
+        "ΔE = 13.6 - 3.4 = 10.2 eV\n"
+        "\\[\n\\boxed{10.2\\ \\text{eV}}\n\\]\n\n"
+        "Question: Which energy state is lower in hydrogen molecule?\n"
+        "Answer:\nBased on spin multiplicity, the singlet state lies lower in energy than the triplet.\n"
+        "\\[\n\\boxed{The singlet state is lower in energy}\n\\]\n\n"
+        f"Question: {line['question']}\nAnswer:"
+    )
+    return [{"type": "text", "value": prompt_text}]
+
+
+def PHYSIC_auxeval(model, line):
+    equiv_data = {}
+    try:
+        response = line['prediction']
+        if not response or not isinstance(response, str):
+            equiv_data['LOG'] = 'Invalid response format, returning False.'
+            return dict(log=equiv_data, res=False)
+
+        pred_boxed = extract_final_answer_allform(response)
+        gt = line['answer'].strip()
+
+        flat_preds = [item.strip() for group in pred_boxed for item in (group if isinstance(group, list) else [group])]
+
+        if gt in flat_preds:
+            equiv_data['LOG'] = 'GT found in prediction, returning True.'
+            return dict(log=equiv_data, res=True)
+
+        for pred in flat_preds:
+            equiv_data = is_equiv(model, pred, gt)
+            if equiv_data['llm_result']:
+                equiv_data['LOG'] = 'Equivalence found, returning True.'
+                return dict(log=equiv_data, res=True)
+
+        equiv_data['LOG'] = 'No equivalence found, returning False.'
+        return dict(log=equiv_data, res=False)
+    except Exception as e:
+        logging.warning(f'post_check error: {e}')
+        equiv_data['LOG'] = f'Exception occurred: {e}'
+        return dict(log=equiv_data, res=False)
+
+
+def PHYSIC_acc(result_file):
+    data = load(result_file)
+    tot = defaultdict(int)
+    hit = defaultdict(int)
+    lt = len(data)
+
+    for i in tqdm(range(lt)):
+        item = data.iloc[i]
+        cate = item.get('category', 'Overall')
+
+        tot['Overall'] += 1
+        tot[cate] += 1
+
+        if item.get('res'):
+            hit['Overall'] += 1
+            hit[cate] += 1
+
+        pred_raw = item.get("res", "")
+        gt = item.get("answer", "").strip()  # noqa: F841
+        pred_boxed = extract_final_answer_allform(str(pred_raw))
+        flat_pred = [ans.strip() for group in pred_boxed for ans in (group if isinstance(group, list) else [group])]  # noqa: F841, E501
+
+    res = defaultdict(list)
+    for k in tot:
+        res['Subject'].append(k)
+        res['tot'].append(tot[k])
+        res['hit'].append(hit[k])
+        res['acc'].append(hit[k] / tot[k] * 100 if tot[k] else 0.0)
+
+    return pd.DataFrame(res).sort_values('Subject', ignore_index=True)
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/phyx.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/phyx.py
new file mode 100644
index 0000000000000000000000000000000000000000..7883631e7c51680a109e1dd787661a3ae98daf69
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/phyx.py
@@ -0,0 +1,378 @@
+from vlmeval.smp import *
+from vlmeval.utils import can_infer
+import re
+import json
+import os
+import copy
+import argparse
+from tqdm import tqdm
+from collections import defaultdict
+import ast
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+# ************** Answer Evaluation ****************
+
+
+def get_ICE():
+    example_1 = """
+Ground truth answer: 502 \n
+Predicted answer: The mass of block (B) is:
+[
+\\boxed{ 50 \\sqrt{101} }
+] \n
+Judegement: 1
+"""
+
+    example_2 = """
+Ground truth answer: 46.3 kN \n
+Predicted answer: The tension ( T_B ) in the cable is approximately:
+[
+\\boxed{46300 }
+] \n
+Judegement: 1
+"""
+
+    example_3 = """
+Ground truth answer: 12 m/s \n
+Predicted answer: The speed of the box after 2.00 seconds is:
+[
+\\boxed{11.3, \\text{m/s}}
+] \n
+Judegement: 0
+"""
+
+    example_4 = """
+Ground truth answer: 36.00 kg \n
+Predicted answer: The mass of the hanging block ( m_2 ) must be approximately:
+[
+\\boxed{36.1, \\text\\{kg\\}}
+] \n
+Judegement: 1
+"""
+
+    example_5 = """
+Ground truth answer: 3.2 m \n
+Predicted answer: The stuntman and villain slide approximately \\frac\\{10\\}{3.1415} meters**.
+Judegement: 1
+"""
+
+    return [example_1, example_2, example_3, example_4, example_5]
+
+
+def get_ICE_MC():
+    example_1 = """
+Ground truth answer: A \n
+Predicted answer: A \n
+Judegement: 1
+"""
+
+    example_2 = """
+Ground truth answer: B \n
+Predicted answer: A \n
+Judegement: 0
+"""
+
+    example_3 = """
+Ground truth answer: C \n
+Predicted answer: ### Step 1: Calculate ( l_1 )
+The lightbulb is ( 2.50, \\text\\{m\\}) above the floor, and the bottom of the mirror is (0.50, \\text\\{m\\}) \
+above the floor. The vertical distance from the lightbulb to the bottom of the mirror is:
+[
+\\Delta y_1 = 2.50, \\text\\{m\\} - 0.50, \\text\\{m\\} = 2.00, \\text\\{m\\}.
+] \n
+Judegement: 0
+"""
+
+    example_4 = """
+Ground truth answer: D \n
+Predicted answer: The correct option is D. \n
+Judegement: 1
+"""
+
+    return [example_1, example_2, example_3, example_4]
+
+
+def build_phyx_gpt4_prompt(line, pred):
+    task_description = """
+Please read the following example. Given predicted answer and ground truth answer,
+compare the these two answers, then ONLY output judegement 1/0 for matched/unmatched at the end of the prompt.
+If the meaning is expressed in the same way, it is also considered consistent, for example, 0.5m and 50cm.
+If the given predicted mentions "approximately", then allow the Approximation Error, \
+such as 0.49 and approximately 0.5, 0.81 and approximately 0.8. \n
+"""
+    gt_answer = line['answer']
+    prompt = task_description
+    examples = get_ICE()
+    for example in examples:
+        prompt += example + '\n'
+    prompt += 'Ground truth answer: {} \n'.format(gt_answer)
+    prompt += 'Predicted answer: {} \n'.format(pred)
+    prompt += 'Judegement:'
+    return prompt
+
+
+def build_phyx_gpt4_prompt_MC(line, pred):
+    task_description = """
+Please read the following example. Given predicted answer and ground truth answer for Multi-Choice question.
+The ground truth answer would be A/B/C/D. The predicted answer would be some words containing A/B/C/D.
+Please compare the these two answers, then ONLY output judegement 1/0 for matched/unmatched at the end of the prompt. \n
+"""
+    gt_answer = line['answer']
+    prompt = task_description
+    examples = get_ICE_MC()
+    for example in examples:
+        prompt += example + '\n'
+    prompt += 'Ground truth answer: {} \n'.format(gt_answer)
+    prompt += 'Predicted answer: {} \n'.format(pred)
+    prompt += 'Judegement:'
+    return prompt
+
+
+def mapping_str(input):
+    d = {r"\dfrac": r"\frac", r"\pi": "3.14"}
+    output = input
+    for k,v in d.items():
+        try:
+            output = output.replace(k, v)
+        except:
+            pass
+    return output
+
+
+def safe_literal_eval(s):
+    s = s.strip()
+    try:
+        return ast.literal_eval(s)
+    except:
+        pass
+    if not s.startswith("{"):
+        s = "{" + s
+    if not s.endswith("}"):
+        s = s + "}"
+    s = re.sub(r'([{,]\s*)([^"\{\}\:\,\s]+)\s*:', r'\1"\2":', s)
+    try:
+        return ast.literal_eval(s)
+    except:
+        return None
+
+
+def extract_boxed_content(s):
+    start = s.find(r'\boxed{')
+    if start == -1:
+        return None
+    content_start = start + len(r'\boxed{')
+    rest = s[content_start:]
+    depth = 0
+    for i, ch in enumerate(rest):
+        if ch == '{':
+            depth += 1
+        elif ch == '}':
+            if depth == 0:
+                return rest[:i]
+            else:
+                depth -= 1
+    return None
+
+
+def PhyX_auxeval(model, line):
+    log = ''
+    retry = 5
+
+    gt_answer = str(line['answer'])
+    prediction = line['prediction']
+
+    # try extract final answer using re rules
+    tmp = PhyX_process_line(line)
+
+    if tmp["extracted"] == "Fail to Call API":
+        log += "Fail to Call API"
+        prediction = "Fail to Call API"
+        return dict(log=log, res=0, extracted=prediction)
+
+    if tmp["extracted"] != "SAME as predict":
+        prediction = tmp["extracted"]
+
+    # judge via LLM
+    if gt_answer.strip().lower() == prediction.strip().lower():
+        return dict(log="Matched at string level", res=1, extracted=prediction)
+
+    prompt = build_phyx_gpt4_prompt(line, prediction)
+    for i in range(retry):
+        res = model.generate(prompt, temperature=i * 0.5)
+        if FAIL_MSG in res:
+            log += f'Try {i}: answer and prediction are {gt_answer} and {prediction}, failed to compare.\n'
+        else:
+            log += 'Compared at semantic level. '
+            # print(res)
+            if "1" in res or 1 == res:
+                log += "Semantic equal via LLM."
+                return dict(log=log, res=1, extracted=prediction)
+            elif "0" in res or 0 == res:
+                log += "LLM judgement {}".format(res)
+                return dict(log=log, res=0, extracted=prediction)
+    log += 'All 5 retries failed.\n'
+    return dict(log=log, res=0, extracted=prediction)
+
+
+def PhyX_auxeval_MC(model, line):
+    log = ''
+    retry = 5
+
+    gt_answer = str(line['answer'])
+    prediction = line['prediction']
+
+    tmp = PhyX_process_line_MC(line)
+
+    if tmp["extracted"] == "Fail to Call API":
+        log += "Fail to Call API"
+        prediction = "Fail to Call API"
+        return dict(log=log, res=0, extracted=prediction)
+
+    if tmp["extracted"] != "SAME as predict":
+        prediction = tmp["extracted"]
+
+    # match at string level
+    if gt_answer.strip().lower() == prediction.strip().lower():
+        return dict(log="Matched at string level", res=1, extracted=prediction)
+    else:
+        # prediction is A/B/C/D, then labeled as unmatch
+        if prediction.strip() in ["A", "B", "C", "D"]:
+            return dict(log="Unmatched at string level", res=0, extracted=prediction)
+
+    prompt = build_phyx_gpt4_prompt_MC(line, prediction)
+    for i in range(retry):
+        res = model.generate(prompt, temperature=i * 0.5)
+        if FAIL_MSG in res:
+            log += f'Try {i}: answer and prediction are {gt_answer} and {prediction}, failed to compare.\n'
+        else:
+            log += 'Compared at semantic level. '
+            if "1" in res or 1 == res:
+                log += "Semantic equal via LLM."
+                return dict(log=log, res=1, extracted=prediction)
+            elif "0" in res or 0 == res:
+                log += "LLM judgement {}".format(res)
+                return dict(log=log, res=0, extracted=prediction)
+    log += 'All 5 retries failed.\n'
+    return dict(log=log, res=0, extracted=prediction)
+
+
+def PhyX_acc(result_file):
+    data = load(result_file)
+    lt = len(data)
+    res = {}
+    hit = 0
+    for i in range(lt):
+        item = data.iloc[i]
+        cate = item['category']
+        if cate in res.keys():
+            res[cate].append(item['res'])
+        else:
+            res[cate] = [item['res']]
+        hit += item['res']
+
+    final_res = {}
+    final_res["Overall Acc"] = hit / lt
+    for k,v in res.items():
+        final_res[k] = sum(v) / len(v)
+    df = pd.DataFrame(final_res, index=[0])
+    return df
+
+
+def PhyX_process_line(line):
+    ret = {}
+
+    answers = str(line['answer'])
+
+    ret["index"] = line["index"]
+    ret['gt'] = answers
+
+    # with reasoning, extract content part
+    prediction_str = line['prediction']
+    with_reasoning = False
+    try:
+        pred_dict = safe_literal_eval(prediction_str)
+        if isinstance(pred_dict, dict) and 'content' in pred_dict and pred_dict['content'] != "":
+            ret['pred'] = pred_dict['content'].strip()
+            with_reasoning = True
+    except:
+        pass
+
+    if not with_reasoning:
+        ret['pred'] = prediction_str.strip()
+
+    if ret['pred'] == FAIL_MSG:
+        ret['match'] = 0
+        ret["extracted"] = "Fail to Call API"
+        return ret
+
+    boxed_answer = extract_boxed_content(ret['pred'])
+    if boxed_answer is not None:
+        boxed_answer = mapping_str(boxed_answer)
+        ret["extracted"] = boxed_answer
+    else:
+        pattern = r'\b(?:final\s+answer|correct\s+answer)\b[^:：]*[:：]\s*(.*?)(?=\n\n\n|\Z)'
+        flags = re.IGNORECASE | re.DOTALL
+        match = re.search(pattern, ret['pred'], flags=flags)
+        if match:
+            extracted_answer = match.group(1)
+            extracted_answer = mapping_str(extracted_answer)
+            ret["extracted"] = extracted_answer
+        else:
+            ret["extracted"] = "SAME as predict"
+
+    if (
+        ret['gt'].strip().lower() == ret["extracted"].strip().lower()
+        or ret['gt'].strip().lower() == ret["pred"].strip().lower()
+        or ret['gt'] in ret['pred']
+    ):
+        ret['match'] = 1
+        return ret
+
+    # unmatch at string level
+    ret['match'] = 0
+    return ret
+
+
+def PhyX_process_line_MC(line):
+    ret = {}
+
+    answers = str(line['answer'])
+
+    ret["index"] = line["index"]
+    ret['gt'] = answers
+    ret['pred'] = line['prediction'].strip()
+
+    pattern = r'\b(?:correct|answer|option|Answer|Option|Correct)\b[\s\S]*?([A-D])'
+    match = re.search(pattern, ret['pred'])
+
+    if ret['pred'] == FAIL_MSG:
+        ret['match'] = 0
+        ret["extracted"] = "Fail to Call API"
+        return ret
+
+    if match:
+        extracted_answer = match.group(1)
+        # compare string
+        ret["extracted"] = extracted_answer
+        if ret['gt'].strip().lower() == extracted_answer.strip().lower():
+            ret['match'] = 1
+            return ret
+    else:
+        # try another match strategy
+        matches = re.findall(r'([ABCD]):', ret['pred'])
+        if matches:
+            extracted_answer = matches[-1]
+            ret["extracted"] = extracted_answer
+            if ret['gt'].strip().lower() == extracted_answer.strip().lower():
+                ret['match'] = 1
+                return ret
+        else:
+            ret["extracted"] = "SAME as predict"
+
+    if ret['gt'] + ":" in ret['pred'] or ret['gt'] + "**" in ret['pred'] or "**" + ret['gt'] in ret['pred']:
+        ret['match'] = 1
+    else:
+        ret['match'] = 0
+
+    return ret
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/tallyqa.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/tallyqa.py
new file mode 100644
index 0000000000000000000000000000000000000000..bc7e702e7d73832f711d5fedd4bf68a5c9db8362
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/tallyqa.py
@@ -0,0 +1,66 @@
+import re
+
+
+def text_to_int(text):
+    """
+    Convert a string or number to an integer between 0 and 20.
+    If the input is a string, it can be a digit or a word representing a number (e.g., "one", "two", etc.).
+    If the input is a number, it must be an integer or a float between 0 and 20.
+    """
+
+    if isinstance(text, (int, float)):
+        if isinstance(text, float) and (text != text):
+            return None
+        return int(text) if 0 <= text <= 20 else None
+
+    text = str(text).lower()
+
+    number_words = {
+        "zero": 0,
+        "one": 1,
+        "two": 2,
+        "three": 3,
+        "four": 4,
+        "five": 5,
+        "six": 6,
+        "seven": 7,
+        "eight": 8,
+        "nine": 9,
+        "ten": 10,
+        "eleven": 11,
+        "twelve": 12,
+        "thirteen": 13,
+        "fourteen": 14,
+        "fifteen": 15,
+        "sixteen": 16,
+        "seventeen": 17,
+        "eighteen": 18,
+        "nineteen": 19,
+        "twenty": 20,
+    }
+
+    word_pattern = r"\b(" + "|".join(number_words.keys()) + r")\b"
+    digit_pattern = r"\b([0-9]|1[0-9]|20)\b"
+
+    combined_pattern = f"({digit_pattern}|{word_pattern})"
+
+    match = re.search(combined_pattern, text)
+
+    if match:
+        found = match.group()
+        if found.isdigit():
+            return int(found)
+        return number_words.get(found, None)
+
+    return None
+
+
+def extract_count_from_prediction(prediction):
+    """
+    Extract an integer count (0-20) from a prediction string or number.
+    Returns None if extraction fails.
+    """
+    try:
+        return text_to_int(prediction)
+    except Exception:
+        return None
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/tdbench.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/tdbench.py
new file mode 100644
index 0000000000000000000000000000000000000000..62986f7507f95afc84d7a087d710733efec6d8ba
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/tdbench.py
@@ -0,0 +1,108 @@
+import os
+import re
+import warnings
+import pandas as pd
+from functools import reduce
+
+rotations_all = ['rot0', 'rot90', 'rot180', 'rot270']
+
+
+def extract_bbox_from_string(bbox_str):
+    bbox_str = bbox_str.replace('\n', '')
+    parsed = re.findall(r'(\d?(?:\.\d+)?),\s?(\d?(?:\.\d+)?),\s?(\d?(?:\.\d+)?),\s?(\d?(?:\.\d+)?)', bbox_str)
+    if len(parsed) == 1:
+        return float(parsed[0][0]), float(parsed[0][1]), float(parsed[0][2]), float(parsed[0][3])
+    else:
+        raise RuntimeError(f'Invalid VLM output: {bbox_str}. '
+                           f'Correct coordinate should be [a, b, c, d], where each number is 0, 0.*, or 1. ')
+
+
+def calculate_bbox_iou(pred_bbox, gt_bbox):
+    pred_x_min, pred_y_min, pred_x_max, pred_y_max = pred_bbox
+    gt_x_min, gt_y_min, gt_x_max, gt_y_max = gt_bbox
+
+    x_min_intersect = max(pred_x_min, gt_x_min)
+    y_min_intersect = max(pred_y_min, gt_y_min)
+    x_max_intersect = min(pred_x_max, gt_x_max)
+    y_max_intersect = min(pred_y_max, gt_y_max)
+
+    if x_max_intersect < x_min_intersect or y_max_intersect < y_min_intersect:
+        return 0.0
+
+    intersection_area = (x_max_intersect - x_min_intersect) * (y_max_intersect - y_min_intersect)
+
+    pred_area = (pred_x_max - pred_x_min) * (pred_y_max - pred_y_min)
+    gt_area = (gt_x_max - gt_x_min) * (gt_y_max - gt_y_min)
+
+    union_area = pred_area + gt_area - intersection_area
+
+    iou = intersection_area / union_area
+
+    return iou
+
+
+def calculate_centroid_containment(pred_bbox, gt_bbox):
+    label_x0, label_y0, label_x1, label_y1 = gt_bbox
+    pred_x0, pred_y0, pred_x1, pred_y1 = pred_bbox
+    pred_center_x = (pred_x0 + pred_x1) / 2
+    pred_center_y = (pred_y0 + pred_y1) / 2
+    if (label_x0 <= pred_center_x <= label_x1) and (label_y0 <= pred_center_y <= label_y1):
+        return 1
+    else:
+        return 0
+
+
+def evaluate_bbox(pred_bbox, gt_bbox, method):
+    if method == 'centroid':
+        return calculate_centroid_containment(pred_bbox, gt_bbox)
+    elif method == 'iou':
+        return calculate_bbox_iou(pred_bbox, gt_bbox)
+
+
+def rotational_eval(eval_file):
+    rotations = set(rotations_all)
+    match = re.search(r'(rot\d+)', eval_file)
+    if not match:
+        warnings.warn(f"[RotationalEval] Invalid file name format: {eval_file}."
+                      f"Expected format includes rotation like 'rot0', 'rot90', etc.")
+        return False
+    current_rotation = match.group(1)
+
+    # Collect all existing rotation's result files
+    data = []
+    rotation_files = {rot: eval_file.replace(current_rotation, rot) for rot in rotations}
+    for rot, path in rotation_files.items():
+        filename = os.path.basename(path)
+        if os.path.exists(path):
+            df_rot = pd.read_excel(path)[['index', 'category', 'hit']]
+            df_rot.rename(columns={'hit': f'hit_{rot}'}, inplace=True)
+            data.append(df_rot)
+        else:
+            rotations.remove(rot)
+            warnings.warn(f"[RotationEval] Skipped rotation {rot} because {filename} does not exist.")
+
+    # Merge dataframes from different rotations
+    df_all = reduce(lambda df1, df2: pd.merge(df1, df2, on=['index', 'category'], how='inner'), data)
+    hit_columns = [col for col in df_all.columns if col.startswith('hit_')]
+    # Find all correct and all wrong
+    df_all['hit_all'] = df_all[hit_columns].eq(1).all(axis=1)
+    df_all['miss_all'] = df_all[hit_columns].eq(0).all(axis=1)
+
+    # Count for each category
+    acc = df_all.groupby('category').agg(
+        total_questions=('index', 'count'),
+        hit_all=('hit_all', lambda x: x.astype(float).sum()),
+        miss_all=('miss_all', lambda x: x.astype(float).sum()),
+        **{rot: (f'hit_{rot}', lambda x: x.astype(float).sum()) for rot in rotations},
+    )
+
+    cols = acc.columns != 'total_questions'
+    acc.loc[:, cols] = acc.loc[:, cols].div(acc['total_questions'], axis=0)
+    acc.loc['Average'] = acc.mean().round(3)
+
+    # Clean up output
+    acc['total_questions'] = acc['total_questions'].astype(int)
+    for rot in rotations_all:
+        if rot not in acc.columns:
+            acc[rot] = 'No Data'
+    return acc[['total_questions', 'hit_all', 'miss_all', *rotations_all]]
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/vdc.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/vdc.py
new file mode 100644
index 0000000000000000000000000000000000000000..920114765741f82674d5ecf4eba31eb222477432
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/vdc.py
@@ -0,0 +1,156 @@
+# flake8: noqa
+from ...smp import *
+import numpy as np
+import pandas as pd
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+SYSTEM_CAL_SCORE_PROMPT = """You are an intelligent chatbot designed for evaluating the correctness of generative outputs for question-answer pairs.
+Your task is to compare the predicted answer with the correct answer and determine if they match meaningfully. Here's how you can accomplish the task:
+------
+##INSTRUCTIONS:
+- Focus on the meaningful match between the predicted answer and the correct answer.
+- Consider synonyms or paraphrases as valid matches.
+- Evaluate the correctness of the prediction compared to the answer.
+"""
+
+USER_CAL_SCORE_PROMPT = """Please evaluate the following video-based question-answer pair:
+
+Question: {question}
+Correct Answer: {answer}
+Predicted Answer: {pred_response}
+
+Provide your evaluation only as a yes/no and score where the score is an integer value between 0 and 5, with 5 indicating the highest meaningful match.
+Please generate the response in the form of a Python dictionary string with keys 'pred' and 'score', where value of 'pred' is  a string of 'yes' or 'no' and value of 'score' is in INTEGER, not STRING.
+DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string.
+For example, your response should look like this: \{'pred': 'yes', 'score': 4.8\}.
+"""
+
+SYSTEM_GENER_PRED_PROMPT = """You are an intelligent chatbot designed for providing accurate answers to questions related to the content based on a detailed description of a video or image.
+Here's how you can accomplish the task:
+------
+##INSTRUCTIONS:
+- Read the detailed description carefully.
+- Answer the question only based on the detailed description.
+- The answer should be a short sentence or phrase.
+"""
+
+USER_GENER_PRED_PROMPT = """Please provide accurate answers to questions related to the content based on a detailed description of a video or image:
+
+detailed description: {pred_cap}
+question: {q}
+
+DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide short but accurate answer."""
+
+
+VDC_DIMENSIONS = {
+    'short': ['short'],
+    'detailed': ['detailed'],
+    'background': ['background'],
+    'main_object': ['main_object'],
+    'camera': ['camera'],
+    'overall': []
+}
+
+L3_DIMS = []
+for k, v in VDC_DIMENSIONS.items():
+    if k != 'overall':
+        L3_DIMS.extend(v)
+        VDC_DIMENSIONS['overall'].extend(v)
+
+
+def get_dimension_rating(data_path):
+    data = load(data_path)
+    coarse_rating = {k: [] for k in VDC_DIMENSIONS}
+    coarse_acc = {k: [] for k in VDC_DIMENSIONS}
+
+    def parse_score_dict(score_dict):
+        """Helper function to parse score dictionary string"""
+        if isinstance(score_dict, dict):
+            return score_dict
+
+        if isinstance(score_dict, str):
+            try:
+                # First try standard json loading
+                return json.loads(score_dict)
+            except json.JSONDecodeError:
+                try:
+                    # If that fails, try eval (safer than literal_eval for this case)
+                    return eval(score_dict)
+                except:
+                    print(f"Failed to parse score_dict: {score_dict}")
+                    return None
+        return None
+
+    for i in range(len(data)):
+        caption_type = data.iloc[i]['caption_type'].lower()  # Convert to lowercase
+        score_dict = parse_score_dict(data.iloc[i]['score'])
+
+        if score_dict and isinstance(score_dict, dict) and 'pred' in score_dict and 'score' in score_dict:
+            score = score_dict['score']
+            is_correct = 1 if score_dict['pred'].lower() == 'yes' else 0
+        else:
+            score = -1
+            is_correct = -1
+
+        # Map caption types to their lowercase versions
+        if caption_type in ['short', 'detailed', 'background', 'main_object', 'camera']:
+            coarse_rating[caption_type].append(score)
+            coarse_rating['overall'].append(score)
+
+            if is_correct != -1:
+                coarse_acc[caption_type].append(is_correct)
+                coarse_acc['overall'].append(is_correct)
+
+    coarse_valid = {k: f'{np.mean([x for x in v if x >= 0]):.2f}' for k, v in coarse_rating.items()}
+    coarse_accuracy = {k: f'{np.mean(v):.2f}' if v else '0.00' for k, v in coarse_acc.items()}
+
+    return dict(
+        coarse_valid=coarse_valid,
+        coarse_accuracy=coarse_accuracy
+    )
+
+
+def prepare_response_prompt(item):
+    """
+    Prepare messages for response generation
+
+    Args:
+        item: DataFrame row containing pred_cap and question
+
+    Returns:
+        list: List of message dictionaries for the model
+    """
+    return USER_GENER_PRED_PROMPT.format(pred_cap=item['prediction'], q=item['question'])
+
+
+def prepare_score_prompt(item):
+    """
+    Prepare messages for score evaluation
+
+    Args:
+        item: DataFrame row containing question, answer, and prediction
+
+    Returns:
+        list: List of message dictionaries for the model
+    """
+    # Convert Series to dictionary if needed
+    if isinstance(item, pd.Series):
+        item = item.to_dict()
+
+    # prompt = USER_CAL_SCORE_PROMPT.format(
+    #     question=item['question'],
+    #     answer=item['answer'],
+    #     pred_response=item['pred_response']
+    # )
+
+    prompt = f"""Please evaluate the following video-based question-answer pair:\n\n
+            Question: {item['question']}\n
+            Correct Answer: {item['answer']}\n
+            Predicted Answer: {item['pred_response']}\n\n
+            Provide your evaluation only as a yes/no and score where the score is an integer value between 0 and 5, with 5 indicating the highest meaningful match.
+            Please generate the response in the form of a Python dictionary string with keys 'pred' and 'score', where value of 'pred' is  a string of 'yes' or 'no' and value of 'score' is in INTEGER, not STRING.
+            DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string.
+                For example, your response should look like this: {{'pred': 'yes', 'score': 4.8}}."""
+
+    return prompt
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/verifier.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/verifier.py
new file mode 100644
index 0000000000000000000000000000000000000000..4a16b502605f9366bc41a6f1309207ea4eb20a7b
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/verifier.py
@@ -0,0 +1,353 @@
+QUESTION_QUALITY_PROMPT_EN_NO_COT = (
+    "Please as a grading expert, judge whether the final answers given by the candidates below are consistent with "
+    "the standard answers, that is, whether the candidates answered correctly. "
+    "Here are some evaluation criteria: "
+    "1. Please refer to the given standard answer. You don't need to re-generate the answer to the question because "
+    "the standard answer has been given. You only need to judge whether the candidate's answer is consistent with the "
+    "standard answer according to the form of the question. THE STANDARD ANSWER IS ALWAYS CORRECT AND THE QUESTION IS "
+    "PERFECTLY VALID. NEVER QUESTION THEM. "
+    "2. ONLY compare the FINAL ANSWER - COMPLETELY IGNORE any potential errors in the REASONING PROCESSES. "
+    "3. Some answers may be expressed in different ways, such as some answers may be a mathematical expression, some "
+    "answers may be a textual description, as long as the meaning expressed is the same. Before making a judgment, "
+    "please understand the question and the standard answer first, and then judge whether the candidate's answer is "
+    "correct.If the standard answer does not specify a unit, but the candidate's answer includes a unit that is "
+    "correct for the value given, consider it correct. "
+    "4. Some answers may consist of multiple items, such as multiple-choice questions, multiple-select questions, "
+    "fill-in-the-blank questions, etc. Regardless of the question type, the final answer will be considered correct "
+    "as long as it matches the standard answer, regardless of whether the reasoning process is correct. For "
+    "multiple-select questions and multi-blank fill-in-the-blank questions, all corresponding options or blanks must "
+    "be answered correctly and match the standard answer exactly to be deemed correct. "
+    "5. If the prediction is given with \\boxed{{}}, please ignore the \\boxed{{}} and only judge whether the "
+    "candidate's answer is consistent with the standard answer. "
+    "6. If the candidate's answer is invalid (e.g., incomplete (cut off mid-response), lots of unnormal repetitive "
+    "content, or irrelevant to the question, saying it can't answer the question because some irresistible factors, "
+    "like ethical issues, no enough information, etc.), select option C (INVALID).Please judge whether the following "
+    "answers are consistent with the standard answer based on the above criteria. Grade the predicted answer of this "
+    "new question as one of: "
+    "A: CORRECT "
+    "B: INCORRECT "
+    "C: INVALID "
+    "Just return the letters \"A\", \"B\", or \"C\", with no text around it. "
+    "Here is your task. Simply reply with either CORRECT, INCORRECT, or INVALID. Don't apologize or correct yourself "
+    "if there was a mistake; we are just trying to grade the answer. "
+    "<Original Question Begin>: "
+    "{question} "
+    "<Original Question End> "
+    "<Standard Answer Begin>: "
+    "{gold_answer} "
+    "<Standard Answer End> "
+    "<Candidate's Answer Begin>: "
+    "{llm_response} "
+    "<Candidate's Answer End> "
+    "Judging the correctness of the candidate's answer:"
+)
+
+QUESTION_QUALITY_PROMPT_EN_COT = (
+    "As a grading expert, your task is to determine whether the candidate's final answer matches the provided "
+    "standard answer. Follow these evaluation guidelines precisely: "
+    "Evaluation Protocol: "
+    "1. Reference Standard: "
+    "- The standard answer is definitive and always correct "
+    "- The question is perfectly valid - never question them "
+    "- Do not regenerate answers; only compare with the given standard "
+    "2. Comparison Method: "
+    "- Carefully analyze the question's requirements and the standard answer's structure "
+    "* Determine whether the question expects exact matching of the entire standard answer or allows partial "
+    "matching of its components. "
+    "* This determination must be made based on the question's phrasing and the nature of the standard answer. "
+    "- Compare ONLY the candidate's final answer (ignore all reasoning/explanation errors) "
+    "- Disregard any differences in formatting or presentation style "
+    "- For mathematical expressions: calculate step by step whether the two formulas are equivalent "
+    "- For multiple-choice questions: compare only the final choice and corresponding option content "
+    "3. Multi-part Answers: "
+    "- For questions requiring multiple responses (e.g., multi-select): "
+    "- All parts must match the standard answer exactly. "
+    "- Compare each sub-answer step by step. Partial matches are considered incorrect. "
+    "4. Validity Check: "
+    "- Reject answers that are: "
+    "* Incomplete (cut off mid-sentence in the final sentence, lacking a complete response) → Label as INCOMPLETE "
+    "* Repetitive (repetition of words or phrases in a loop) → Label as REPETITIVE "
+    "* Explicit refusals (e.g., directly return \"I cannot answer/provide/access ...\") → Label as REFUSAL "
+    "- For invalid answers, specify the type in the judgment (e.g., \\boxed{{C}} - INCOMPLETE). "
+    "Grading Scale: "
+    "\\boxed{{A}} - CORRECT: "
+    "- Answer matches standard exactly (including equivalent expressions) "
+    "- For numerical answers: consider as equivalent if values match when rounded appropriately "
+    "- Semantically equivalent responses "
+    "\\boxed{{B}} - INCORRECT: "
+    "- Any deviation from standard answer "
+    "- Partial matches for multi-part questions "
+    "\\boxed{{C}} - INCOMPLETE/REPETITIVE/REFUSAL: "
+    "- Fails validity criteria above (must specify: INCOMPLETE/REPETITIVE/REFUSAL) "
+    "Execution Steps and Output Formats: "
+    "Analysis step by step: [ "
+    "Thoroughly evaluate the candidate's answer including: "
+    "(1) First check if the answer is INCOMPLETE (cut off mid-sentence), REPETITIVE (looping repetition), or a "
+    "REFUSAL (explicit denial) - if so, immediately classify as \\boxed{{C}} with the corresponding type. "
+    "(2) Analyze the question's core requirements and the standard answer's structure, for example: "
+    "- Strict requirements: Identify mandatory constraints (e.g., simplification, answer order, multi-part "
+    "completeness) "
+    "- Tolerant allowances: Ignore non-critical deviations (e.g., missing option labels in MCQs, equivalent but "
+    "unformatted expressions) "
+    "- Required answer type, precision level, etc. "
+    "(3) Perform a detailed comparison between the candidate's final answer and the standard answer, for example: "
+    "- Content equivalence "
+    "- Permitted variations in numerical precision "
+    "- Allowed expression formats] "
+    "Final Judgment: \\boxed{{A/B/C}} - <CORRECT/INCORRECT/INCOMPLETE/REPETITIVE/REFUSAL> "
+    "Here is your task. "
+    "<Original Question Begin> "
+    "{question} "
+    "<Original Question End> "
+    "<Standard Answer Begin> "
+    "{gold_answer} "
+    "<Standard Answer End> "
+    "<Candidate's Answer Begin> "
+    "{llm_response} "
+    "<Candidate's Answer End> "
+    "Analysis step by step and Final Judgment:"
+)
+
+import os
+from abc import ABC, abstractmethod
+
+
+class BaseVerifierModel(ABC):
+
+    @abstractmethod
+    def load_model(self):
+        pass
+
+    @abstractmethod
+    def evaluate(self, question, prediction, groundtruth):
+        pass
+
+
+class Verifier:
+    """Main Verifier Class"""
+
+    def __init__(self, model_path, use_vllm=False, use_cot=False, **kwargs):
+        if 'VERIFIER_PATH' in os.environ and os.environ['VERIFIER_PATH'] != '':
+            self.logger.info('Environment variable VERIFIER_PATH is set. Will use it as model_path. ')
+            model_path = os.environ['VERIFIER_PATH']
+        else:
+            raise ValueError('VERIFIER_PATH is not set. Please set it in the .env file.')
+        self.model_path = model_path
+        self.model = self._create_model(model_path, use_vllm=use_vllm, use_cot=use_cot, **kwargs)
+
+    def _create_model(self, model_path, **kwargs):
+        return Verifier_Model(model_path=model_path, **kwargs)
+
+    def evaluate(self, question, prediction, groundtruth):
+        return self.model.evaluate(question, prediction, groundtruth)
+
+    @staticmethod
+    def clear_model_cache():
+        Verifier_Model._model_cache.clear()
+        Verifier_Model._tokenizer_cache.clear()
+        print("All model caches cleared.")
+
+    @staticmethod
+    def get_cache_info():
+        verifier_count = len(Verifier_Model._model_cache)
+        tokenizer_count = len(Verifier_Model._tokenizer_cache)
+
+        print("Cache status:")
+        print(f"  Verifier_Model cache: {verifier_count} items")
+        print(f"  Tokenizer cache: {tokenizer_count} items")
+
+        return {
+            "verifier_cache_size": verifier_count,
+            "tokenizer_cache_size": tokenizer_count,
+        }
+
+
+class Verifier_Model(BaseVerifierModel):
+
+    _model_cache = {}
+    _tokenizer_cache = {}
+
+    def __init__(self, model_path, use_vllm=False, use_cot=False, **kwargs):
+        self.model = None
+        self.tokenizer = None
+        self.use_vllm = use_vllm
+        self.use_cot = use_cot
+        self.model_path = model_path
+        self.load_model(model_path=self.model_path)
+        print(
+            f"Using Verifier_Model with use_vllm: {self.use_vllm}, use_cot: {self.use_cot}"
+        )
+
+    def _get_cache_key(self, model_path):
+        if self.use_vllm:
+            return f"vllm_{model_path}_16384_4_eager_chunked_131072"
+        else:
+            return f"transformers_{model_path}_auto_auto"
+
+    def load_model(self, model_path):
+        if self.use_vllm:
+            self.load_model_vllm(model_path)
+        else:
+            self.load_model_transformers(model_path)
+
+    def load_model_vllm(self, model_path):
+        cache_key = self._get_cache_key(model_path)
+
+        if cache_key in Verifier_Model._model_cache:
+            print(f"Using cached vLLM model: {cache_key}")
+            self.model = Verifier_Model._model_cache[cache_key]
+            self.tokenizer = Verifier_Model._tokenizer_cache[cache_key]
+        else:
+            from vllm import LLM
+            from transformers import AutoTokenizer
+
+            print("Loading verifier model with vLLM...")
+            import os
+            import torch
+
+            os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
+            gpu_count = torch.cuda.device_count()
+            if gpu_count >= 8:
+                tp_size = 8
+            elif gpu_count >= 4:
+                tp_size = 4
+            elif gpu_count >= 2:
+                tp_size = 2
+            else:
+                tp_size = 1
+
+            self.model = LLM(
+                model=model_path,
+                max_model_len=16384,
+                max_num_seqs=3,
+                tensor_parallel_size=tp_size,
+                enable_chunked_prefill=True,
+                max_num_batched_tokens=131072,
+                gpu_memory_utilization=0.9,
+            )
+            self.tokenizer = AutoTokenizer.from_pretrained(model_path)
+            # 缓存模型实例
+            Verifier_Model._model_cache[cache_key] = self.model
+            Verifier_Model._tokenizer_cache[cache_key] = self.tokenizer
+            print(f"Cached vLLM model: {cache_key}")
+
+    def load_model_transformers(self, model_path):
+        cache_key = self._get_cache_key(model_path)
+
+        if cache_key in Verifier_Model._model_cache:
+            print(f"Using cached transformers model: {cache_key}")
+            cached_data = Verifier_Model._model_cache[cache_key]
+            self.model = cached_data["model"]
+            self.tokenizer = cached_data["tokenizer"]
+        else:
+            from transformers import AutoModelForCausalLM, AutoTokenizer
+
+            print("Loading verifier model with transformers...")
+
+            self.tokenizer = AutoTokenizer.from_pretrained(model_path)
+            self.model = AutoModelForCausalLM.from_pretrained(
+                model_path, torch_dtype="auto", device_map="auto"
+            )
+
+            Verifier_Model._model_cache[cache_key] = {
+                "model": self.model,
+                "tokenizer": self.tokenizer,
+            }
+            print(f"Cached transformers model: {cache_key}")
+
+    def evaluate_vllm(self, question, prediction, groundtruth):
+        if self.use_cot:
+            prompt = QUESTION_QUALITY_PROMPT_EN_COT.format(
+                question=question, gold_answer=groundtruth, llm_response=prediction
+            )
+        else:
+            prompt = QUESTION_QUALITY_PROMPT_EN_NO_COT.format(
+                question=question, gold_answer=groundtruth, llm_response=prediction
+            )
+        from vllm import SamplingParams
+
+        sampling_params = SamplingParams(
+            temperature=0.0,
+            detokenize=True,
+            max_tokens=4096,
+        )
+        messages = [{"role": "user", "content": prompt}]
+        text = self.tokenizer.apply_chat_template(
+            messages,
+            tokenize=False,
+            add_generation_prompt=True,
+            enable_thinking=True,  # Switches between thinking and non-thinking modes. Default is True.
+        )
+        outputs = self.model.generate([text], sampling_params=sampling_params)
+        for output in outputs:
+            generated_text = output.outputs[0].text
+        response = self._process_judgment(generated_text)
+        if "CORRECT" in response or "A" in response:
+            return True
+        else:
+            return False
+
+    def _process_judgment(self, judgment_str: str) -> str:
+        import re
+
+        # First try to find the exact \boxed{letter} pattern
+        boxed_matches = re.findall(r"boxed{([A-C])}", judgment_str)
+        if boxed_matches:
+            return boxed_matches[-1]  # Return the last boxed judgment
+
+        # Directly return the judgment if it is A, B, or C
+        if judgment_str == "A":
+            return "A"
+        elif judgment_str == "B":
+            return "B"
+        elif judgment_str == "C":
+            return "C"
+        else:
+            judgment_str = judgment_str.split("Final Judgment:")[-1]
+            matches = re.findall(r"\(([A-C])\)*", judgment_str)
+            if matches:
+                return matches[-1]
+            matches = re.findall(r"([A-C])", judgment_str)
+            if matches:
+                return matches[-1]
+            return ""
+
+    def evaluate_transformers(self, question, prediction, groundtruth):
+        # prepare the model input
+        if self.use_cot:
+            prompt = QUESTION_QUALITY_PROMPT_EN_COT.format(
+                question=question, gold_answer=groundtruth, llm_response=prediction
+            )
+        else:
+            prompt = QUESTION_QUALITY_PROMPT_EN_NO_COT.format(
+                question=question, gold_answer=groundtruth, llm_response=prediction
+            )
+        messages = [{"role": "user", "content": prompt}]
+        text = self.tokenizer.apply_chat_template(
+            messages,
+            tokenize=False,
+            add_generation_prompt=True,
+            enable_thinking=True,  # Switches between thinking and non-thinking modes. Default is True.
+        )
+        model_inputs = self.tokenizer([text], return_tensors="pt").to(self.model.device)
+
+        # conduct text completion
+        generated_ids = self.model.generate(**model_inputs, max_new_tokens=32768)
+        output_ids = generated_ids[0][len(model_inputs.input_ids[0]):].tolist()
+
+        # the result will begin with thinking content in <think></think> tags, followed by the actual response
+        response = self.tokenizer.decode(output_ids, skip_special_tokens=True)
+        response = self._process_judgment(response)
+
+        # Parse the response to determine if it's correct
+        response = response.strip().upper()
+        if "CORRECT" in response or "A" in response:
+            return True
+        else:
+            return False
+
+    def evaluate(self, question, prediction, groundtruth):
+        if self.use_vllm:
+            return self.evaluate_vllm(question, prediction, groundtruth)
+        else:
+            return self.evaluate_transformers(question, prediction, groundtruth)
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/vgrpbench/puzzles/aquarium.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/vgrpbench/puzzles/aquarium.py
new file mode 100644
index 0000000000000000000000000000000000000000..1b6d25fb622788936ac6fc852cca6a95f102c177
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/vgrpbench/puzzles/aquarium.py
@@ -0,0 +1,115 @@
+import argparse
+import os
+import random
+from typing import Any, Dict, List, Tuple
+
+from .common_constriants import Constraint
+from .common_puzzle_factory import PuzzleFactory
+
+class ConstraintAquariumFill(Constraint):
+    """Check aquarium conditions:
+    1. If there's a highest water row in the aquarium, all cells from that row downward in the same aquarium must not be empty.
+    2. For every row in the aquarium, if a cell is defined as empty or filled, all defined cells in that row must match.
+    3. For every column in the aquarium, if a top cell is filled with water, all consecutive lower cells must not be empty.
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.name = "constraint_aquarium_fill"
+
+    def check(self, game_state: Dict[str, Any]) -> bool:
+        board = game_state["board"]
+        aquariums = game_state.get("clues", {}).get("aquariums", [])
+
+        for aquarium in aquariums:
+            # Find highest water cell in this aquarium
+            highest_water_row = float('inf')
+            for r, c in aquarium:
+                if board[r][c] == "s":
+                    highest_water_row = min(highest_water_row, r)
+
+            if highest_water_row == float('inf'):
+                continue  # No water in this aquarium
+
+            # Check all cells at or below highest water level
+            for r, c in aquarium:
+                if r >= highest_water_row:  # if cell is at same height or lower than highest water
+                    if board[r][c] == "e":  # if cell is empty
+                        return False
+
+        return True
+
+class ConstraintAquariumCount(Constraint):
+    """Check if row and column counts match the clues"""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.name = "constraint_aquarium_count"
+
+    def check(self, game_state: Dict[str, Any]) -> bool:
+        board = game_state["board"]
+        clues = game_state.get("clues", None)
+        if not clues:
+            return True
+
+        size = len(board)
+        row_counts = clues["row_counts"]
+        col_counts = clues["col_counts"]
+
+        # Check rows
+        for i in range(size):
+            row_selected = sum(1 for j in range(size) if board[i][j] == "s")
+            row_undefined = sum(1 for j in range(size) if board[i][j] == 0)
+            # If row is fully decided (no zeros), it must match exactly
+            if 0 not in board[i]:
+                if row_selected != row_counts[i]:
+                    return False
+            else:
+                # If not fully decided, no more than the count should be selected
+                if row_selected > row_counts[i]:
+                    return False
+                # Also must be possible to still reach the target
+                if row_selected + row_undefined < row_counts[i]:
+                    return False
+
+        # Check columns
+        for j in range(size):
+            col_cells = [board[i][j] for i in range(size)]
+            col_selected = sum(1 for i in range(size) if board[i][j] == "s")
+            col_undefined = sum(1 for i in range(size) if board[i][j] == 0)
+            if all(cell != 0 for cell in col_cells):
+                if col_selected != col_counts[j]:
+                    return False
+            else:
+                if col_selected > col_counts[j]:
+                    return False
+                if col_selected + col_undefined < col_counts[j]:
+                    return False
+
+        return True
+
+
+class AquariumPuzzleFactory(PuzzleFactory):
+    def __init__(self, size: int) -> None:
+        super().__init__()
+        if size < 4:
+            raise ValueError("Size must be at least 4")
+
+        self.game_name = "aquarium"
+        self.size = size
+        self.constraints = [ConstraintAquariumFill(), ConstraintAquariumCount()]
+        self.all_possible_values = ["e", "s"]  # empty or selected (water)
+
+    def get_possible_values(
+        self, game_state: Dict[str, Any], row: int, col: int
+    ) -> List[str]:
+        possible_values = []
+        board = game_state["board"]
+        original_value = board[row][col]
+
+        for value in self.all_possible_values:
+            board[row][col] = value
+            if self.check(game_state):
+                possible_values.append(value)
+        board[row][col] = original_value
+        return possible_values
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/vgrpbench/puzzles/common_get_game_factory.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/vgrpbench/puzzles/common_get_game_factory.py
new file mode 100644
index 0000000000000000000000000000000000000000..9f48b532f636eff6732e6ff1a832a537b3f96053
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/vgrpbench/puzzles/common_get_game_factory.py
@@ -0,0 +1,43 @@
+def get_game_factory(game_type):
+    if game_type == "sudoku":
+        from .sudoku import SudokuPuzzleFactory as GameFactory
+    elif game_type == "binairo":
+        from .binairo import BinairoPuzzleFactory as GameFactory
+    elif game_type == "coloredsudoku":
+        from .coloredsudoku import ColoredSudokuPuzzleFactory as GameFactory
+    elif game_type == "kakuro":
+        from .kakuro import KakuroPuzzleFactory as GameFactory
+    elif game_type == "killersudoku":
+        from .killersudoku import KillerSudokuPuzzleFactory as GameFactory
+    elif game_type == "renzoku":
+        from .renzoku import RenzokuPuzzleFactory as GameFactory
+    elif game_type == "skyscraper":
+        from .skyscraper import SkyscraperPuzzleFactory as GameFactory
+    elif game_type == "starbattle":
+        from .starbattle import StarBattlePuzzleFactory as GameFactory
+    elif game_type == "treesandtents":
+        from .treesandtents import TreesAndTentsPuzzleFactory as GameFactory
+    elif game_type == "thermometers":
+        from .thermometers import ThermometersPuzzleFactory as GameFactory
+    elif game_type == "futoshiki":
+        from .futoshiki import FutoshikiPuzzleFactory as GameFactory
+    elif game_type == "hitori":
+        from .hitori import HitoriPuzzleFactory as GameFactory
+    elif game_type == "aquarium":
+        from .aquarium import AquariumPuzzleFactory as GameFactory
+    elif game_type == "kakurasu":
+        from .kakurasu import KakurasuPuzzleFactory as GameFactory
+    elif game_type == "oddevensudoku":
+        from .oddevensudoku import OddEvenSudokuPuzzleFactory as GameFactory
+    elif game_type == "battleships":
+        from .battleships import BattleshipsPuzzleFactory as GameFactory
+    elif game_type == "fieldexplore":
+        from .fieldexplore import FieldExplorePuzzleFactory as GameFactory
+    elif game_type == "jigsawsudoku":
+        from .jigsawsudoku import JigsawSudokuPuzzleFactory as GameFactory
+    elif game_type == "lightup":
+        from .lightup import LightUpPuzzleFactory as GameFactory
+    elif game_type == "nonogram":
+        from .nonogram import NonogramPuzzleFactory as GameFactory
+
+    return GameFactory
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/vgrpbench/puzzles/common_puzzle_factory.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/vgrpbench/puzzles/common_puzzle_factory.py
new file mode 100644
index 0000000000000000000000000000000000000000..b68cb24a951916134402b900368da028b2b2244e
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/vgrpbench/puzzles/common_puzzle_factory.py
@@ -0,0 +1,136 @@
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any, Union
+import copy
+import random
+import json
+import os
+
+import argparse
+
+def hint_type(value):
+    if value == "random":
+        return "random"
+    try:
+        return int(value)
+    except ValueError:
+        raise argparse.ArgumentTypeError(f"'{value}' must be 'random' or an integer")
+
+
+class PuzzleFactory():
+    def __init__(self) -> None:
+        self.constraints = []
+        self.game_name = "unknown"
+        self.size = 0
+        # Define dataset split ratios (must sum to 10)
+        self.train_ratio = 8
+        self.val_ratio = 1
+        self.ablation_ratio = 1
+
+    def sample_hints(self, board: List[List[int]], num_sample_hints: int) -> List[List[int]]:
+        # Create a new board filled with zeros
+        new_board = [[0 for _ in range(len(board[0]))] for _ in range(len(board))]
+        # Sample num_sample_hints cells to keep from the original board
+        sampled_cells = random.sample(range(len(board) * len(board[0])), num_sample_hints)
+        for cell in sampled_cells:
+            row = cell // len(board[0])
+            col = cell % len(board[0])
+            new_board[row][col] = board[row][col]  # Copy only the sampled cells from original board
+        return new_board
+    def save_puzzles(self, puzzles: List[Dict[str, Any]], save_path: str = "datasets/", filename: str = None) -> None:
+        """
+        Save the generated puzzles to JSON files, split into train, val, and ablation sets.
+        Splits are based on unique solutions with ratios defined in __init__.
+        Val set has different solutions from train, while ablation shares solutions with train.
+        """
+        if filename is None:
+            base_path = f"{save_path}/{self.game_name}_{self.size}x{self.size}_puzzles"
+        else:
+            base_path = f"{save_path}/{filename.rsplit('.', 1)[0]}"
+
+        # Group puzzles by their solutions
+        solution_groups = {}
+        for puzzle in puzzles:
+            solution_key = str(puzzle['solution'])  # Convert to string for dict key
+            if solution_key not in solution_groups:
+                solution_groups[solution_key] = []
+            solution_groups[solution_key].append(puzzle)
+
+        # Sort groups (common groups first to validation set) by size for better distribution
+        sorted_groups = sorted(solution_groups.items(), key=lambda x: len(x[1]), reverse=True)
+        # Calculate target sizes based on ratios
+        total_puzzles = len(puzzles)
+        target_val_size = total_puzzles * self.val_ratio // 10
+        target_ablation_size = total_puzzles * self.ablation_ratio // 10
+        # Initialize sets
+        train_puzzles = []
+        val_puzzles = []
+        ablation_puzzles = []
+        # First, fill validation set with complete groups
+        val_solutions = set()
+        current_val_size = 0
+        val_group_idx = 0
+        while val_group_idx < len(sorted_groups) and current_val_size < target_val_size:
+            group = sorted_groups[val_group_idx][1]
+            if current_val_size + len(group) <= target_val_size * 1.2:  # Allow 20% overflow
+                val_puzzles.extend(group)
+                val_solutions.add(sorted_groups[val_group_idx][0])
+                current_val_size += len(group)
+            val_group_idx += 1
+
+        # Fill train and ablation sets with remaining groups
+        train_solutions = set()
+        current_ablation_size = 0
+
+        for solution, group in sorted_groups:
+            if solution in val_solutions:
+                continue
+
+            train_solutions.add(solution)
+            # Randomly split each remaining group between train and ablation
+            if current_ablation_size < target_ablation_size:
+                # Calculate how many puzzles we can still add to ablation
+                space_left = target_ablation_size - current_ablation_size
+                # Take up to 20% of the current group for ablation
+                ablation_count = min(max(1, len(group) // 5), space_left)
+                # Randomly select puzzles for ablation
+                ablation_indices = random.sample(range(len(group)), ablation_count)
+                for i in range(len(group)):
+                    if i in ablation_indices:
+                        ablation_puzzles.append(group[i])
+                        current_ablation_size += 1
+                    else:
+                        train_puzzles.append(group[i])
+            else:
+                train_puzzles.extend(group)
+
+        # Shuffle each set before saving
+        random.shuffle(train_puzzles)
+        random.shuffle(val_puzzles)
+        random.shuffle(ablation_puzzles)
+
+        # Create all parent directories
+        os.makedirs(os.path.dirname(f"{base_path}_train.json"), exist_ok=True)
+
+        # Save splits to separate files
+        for split_name, split_puzzles in [
+            ("train", train_puzzles),
+            ("val", val_puzzles),
+            ("ablation", ablation_puzzles)
+        ]:
+            split_path = f"{base_path}_{split_name}.json"
+            with open(split_path, "w") as f:
+                json.dump(split_puzzles, f, indent=2)
+        print(f"\nSplit and saved {len(puzzles)} puzzles:")
+        print(f"Train: {len(train_puzzles)} puzzles ({len(train_solutions)} unique solutions)")
+        print(f"Val: {len(val_puzzles)} puzzles ({len(val_solutions)} unique solutions)")
+        print(f"Ablation: {len(ablation_puzzles)} puzzles (solutions shared with train)")
+        print(f"Files saved to {base_path}_[train/val/ablation].json")
+
+    def check(self, game_state: Dict[str, Any]) -> bool:
+        for constraint in self.constraints:
+            if not constraint.check(game_state):
+                return False
+        return True
+
+    def get_possible_values(self, game_state: Dict[str, Any], row: int, col: int) -> List[int]:
+        pass
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/vgrpbench/puzzles/kakuro.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/vgrpbench/puzzles/kakuro.py
new file mode 100644
index 0000000000000000000000000000000000000000..7281d79c6802241bfc4e05593de7b50bae31c132
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/vgrpbench/puzzles/kakuro.py
@@ -0,0 +1,91 @@
+from typing import List, Dict, Any, Tuple
+import random
+import copy
+import os
+import json
+
+from .common_puzzle_factory import PuzzleFactory
+from .common_constriants import Constraint, ConstraintRowNoRepeat, ConstraintColNoRepeat, ConstraintSubGridNoRepeat
+
+class ConstraintKakuroSum(Constraint):
+    def __init__(self) -> None:
+        super().__init__()
+        self.name = "constraint_kakuro_sum"
+    def check(self, game_state: Dict[str, Any]) -> bool:
+        board = game_state["board"]
+        # if any of board is str, then convert to int
+        if any(isinstance(cell, str) for row in board for cell in row):
+            board = [[int(cell) for cell in row] for row in board]
+
+        sums = game_state.get("sums", {"row": [], "col": []})
+        # Check row sums
+        for row in range(len(board)):
+            if row < len(sums["row"]):
+                target_sum = sums["row"][row]
+                current_sum = sum(x for x in board[row] if x != 0)
+                if current_sum > target_sum:
+                    return False
+                if all(x != 0 for x in board[row]) and current_sum != target_sum:
+                    return False
+
+        # Check column sums
+        for col in range(len(board[0])):
+            if col < len(sums["col"]):
+                target_sum = sums["col"][col]
+                current_sum = sum(board[row][col] for row in range(len(board)) if board[row][col] != 0)
+                if current_sum > target_sum:
+                    return False
+                if all(board[row][col] != 0 for row in range(len(board))) and current_sum != target_sum:
+                    return False
+
+        return True
+
+class ConstraintKakuroAdjacent(Constraint):
+    def __init__(self) -> None:
+        super().__init__()
+        self.name = "constraint_kakuro_adjacent"
+    def check(self, game_state: Dict[str, Any]) -> bool:
+        board = game_state["board"]
+        # if any of board is str, then convert to int
+        if any(isinstance(cell, str) for row in board for cell in row):
+            board = [[int(cell) for cell in row] for row in board]
+
+        size = len(board)
+
+        for row in range(size):
+            for col in range(size):
+                if board[row][col] == 0:
+                    continue
+                # Check adjacent cells (up, down, left, right)
+                if row > 0 and board[row-1][col] == board[row][col]:
+                    return False
+                if row < size-1 and board[row+1][col] == board[row][col]:
+                    return False
+                if col > 0 and board[row][col-1] == board[row][col]:
+                    return False
+                if col < size-1 and board[row][col+1] == board[row][col]:
+                    return False
+        return True
+
+class KakuroPuzzleFactory(PuzzleFactory):
+    def __init__(self, size: int) -> None:
+        super().__init__()
+        if size < 3 or size > 12:
+            raise ValueError("Grid size must be between 3 and 12")
+        self.game_name = "kakuro"
+        self.size = size
+        self.constraints = [
+            ConstraintKakuroSum(),
+            ConstraintKakuroAdjacent()
+        ]
+        self.all_possible_values = [i for i in range(1, size + 1)]
+    def get_possible_values(self, game_state: Dict[str, Any], row: int, col: int) -> List[int]:
+        possible_values = []
+        board = game_state["board"]
+        original_value = board[row][col]
+        for value in self.all_possible_values:
+            board[row][col] = value
+            if self.check(game_state):
+                possible_values.append(value)
+        board[row][col] = original_value
+        return possible_values
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/vgrpbench/puzzles/killersudoku.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/vgrpbench/puzzles/killersudoku.py
new file mode 100644
index 0000000000000000000000000000000000000000..8df4f8c2d30a50fe69a2a60f4a9deda0b3c38f82
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/vgrpbench/puzzles/killersudoku.py
@@ -0,0 +1,61 @@
+from typing import List, Dict, Any, Tuple
+import random
+import copy
+import os
+import argparse
+
+from .common_puzzle_factory import PuzzleFactory
+from .common_constriants import Constraint, ConstraintRowNoRepeat, ConstraintColNoRepeat, ConstraintSubGridNoRepeat
+
+class ConstraintCageSum(Constraint):
+    def __init__(self) -> None:
+        super().__init__()
+        self.name = "constraint_cage_sum"
+
+    def check(self, game_state: Dict[str, Any]) -> bool:
+        board = game_state["board"]
+        cages = game_state.get("cages", [])  # Default to empty list if no cages
+
+        for cage in cages:
+            cells = cage["cells"]
+            target_sum = cage["sum"]
+            current_sum = 0
+            for row, col in cells:
+                if board[row][col] == 0:  # Skip empty cells
+                    continue
+                current_sum += board[row][col]
+            if current_sum > target_sum:  # Can't exceed target sum
+                return False
+            # Only check equality if all cells in cage are filled
+            if all(board[row][col] != 0 for row, col in cells) and current_sum != target_sum:
+                return False
+        return True
+
+class KillerSudokuPuzzleFactory(PuzzleFactory):
+    def __init__(self, size: int) -> None:
+        super().__init__()
+        self.game_name = "killersudoku"
+        self.size = size
+        self.constraints = [
+            ConstraintRowNoRepeat(),
+            ConstraintColNoRepeat(),
+            ConstraintSubGridNoRepeat(),
+            ConstraintCageSum()
+        ]
+        self.all_possible_values = [i for i in range(1, size + 1)]
+
+    def get_possible_values(self, game_state: Dict[str, Any], row: int, col: int) -> List[int]:
+        possible_values = []
+        board = game_state["board"]
+        original_value = board[row][col]
+
+        # Ensure cages exist in game_state
+        if "cages" not in game_state:
+            game_state["cages"] = []
+
+        for value in self.all_possible_values:
+            board[row][col] = value
+            if self.check(game_state):
+                possible_values.append(value)
+        board[row][col] = original_value
+        return possible_values
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/visulogic.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/visulogic.py
new file mode 100644
index 0000000000000000000000000000000000000000..2d174fe6cab3e5543599d3c229d9562844c457fc
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/visulogic.py
@@ -0,0 +1,123 @@
+import re
+from ...smp import *
+from ...utils import can_infer
+import timeout_decorator
+
+Option_list = ['A','B','C','D']
+
+
+def extract_last_boxed_content(text):
+    stack = []
+    last_boxed_content = None
+    text = str(text)
+    if len(text) < 3:
+        return text
+
+    pattern = re.finditer(r'\\boxed\{|[^\\]\}', text)
+
+    try:
+        for match in pattern:
+            if match.group().endswith(r'\boxed{'):
+                stack.append(match.end())
+            elif match.group().endswith('}') and stack:
+                start = stack.pop()
+                if not stack:
+                    last_boxed_content = text[start:match.start() + 1]
+
+        if last_boxed_content:
+            latex_commands = [r'\text{', r'\rm{', r'\mathbf{', '$']
+            for cmd in latex_commands:
+                last_boxed_content = last_boxed_content.replace(cmd, '')
+            last_boxed_content = last_boxed_content.replace('}', '')
+
+        if (
+            "LETTER".lower() in last_boxed_content.lower()
+            or "or" in last_boxed_content
+            or len(last_boxed_content) > 2
+        ):
+            last_boxed_content = text
+
+    except Exception:
+        last_boxed_content = text
+
+    return 'N' if last_boxed_content is None else last_boxed_content
+
+
+def extract_lang_content(ans):
+    ans = str(ans)
+    ans = ans.replace("<|endoftext|>","")
+    for c in Option_list:
+        if (
+            ans.endswith(f" {c}.")
+            or ans.endswith(f" ({c}).")
+            or ans.startswith(f"{c}\n")
+            or ans.startswith(f"({c})\n")
+            or ans.startswith(f"({c}) {c}\n")
+        ):
+            return c
+
+    lower_ans = ans.lower()
+    for flag in [
+        "answer:",
+        'the final answer is:',
+        'the answer is option:',
+        'the answer is:',
+        'the correct answer is option:',
+        'the correct answer is:',
+        'the answer should be:',
+        'the final answer is',
+        'the answer is option',
+        'the answer is',
+        'the correct answer is option',
+        'the correct answer is',
+        'the answer should be'
+    ]:
+        if flag in lower_ans:
+            lower_ans = lower_ans.split(flag)[-1].strip()
+            lower_ans = lower_ans.split('\n')[0].split('.')[0]
+            upper_ans = lower_ans.upper()
+            if upper_ans in Option_list:
+                return upper_ans
+
+    return ans
+
+
+def extract_answer(ans):
+    if extract_last_boxed_content(ans).strip() in Option_list:
+        return extract_last_boxed_content(ans).strip(), "box"
+    elif extract_lang_content(ans) in Option_list:
+        return extract_lang_content(ans), "lang"
+    else:
+        return "Z", "error"
+
+
+def VisuLogic_acc(result_file):
+    categories = [
+        'Overall',
+        'Quantitative Reasoning',
+        'Spatial Reasoning',
+        'Positional Reasoning',
+        'Attribute Reasoning',
+        'Stylistic Reasoning',
+        'Other'
+    ]
+    data = load(result_file)
+    lt = len(data)
+    hit = defaultdict(lambda: 0)
+    tot = defaultdict(lambda: 0)
+    from tqdm import tqdm
+    for i in tqdm(range(lt)):
+        item = data.iloc[i]
+        cate = item['category']
+        tot['Overall'] += 1
+        tot[cate] += 1
+        if extract_answer(item['prediction'])[0] == item['answer']:
+            hit['Overall'] += 1
+            hit[cate] += 1
+    res = defaultdict(list)
+    for k in categories:
+        res['category'].append(k)
+        res['tot'].append(tot[k])
+        res['hit'].append(hit[k])
+        res['acc'].append(hit[k] / tot[k] * 100)
+    return res
diff --git a/VLMEvalKit-sudoku/vlmeval/dataset/utils/vqa_eval.py b/VLMEvalKit-sudoku/vlmeval/dataset/utils/vqa_eval.py
new file mode 100644
index 0000000000000000000000000000000000000000..077ba546b23cc104eb60d0a44b73c11cef7a1425
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/dataset/utils/vqa_eval.py
@@ -0,0 +1,363 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+# Partly adopted from https://github.com/GT-Vision-Lab/VQA
+# Copyright (c) 2014, Aishwarya Agrawal
+
+from ...smp import *
+from typing import Optional
+
+
+def _process_digit_article(inText):
+    outText = []
+    tempText = inText.lower().split()
+    articles = ['a', 'an', 'the']
+    manualMap = {
+        'none': '0',
+        'zero': '0',
+        'one': '1',
+        'two': '2',
+        'three': '3',
+        'four': '4',
+        'five': '5',
+        'six': '6',
+        'seven': '7',
+        'eight': '8',
+        'nine': '9',
+        'ten': '10',
+    }
+    contractions = {
+        'aint': "ain't",
+        'arent': "aren't",
+        'cant': "can't",
+        'couldve': "could've",
+        'couldnt': "couldn't",
+        "couldn'tve": "couldn't've",
+        "couldnt've": "couldn't've",
+        'didnt': "didn't",
+        'doesnt': "doesn't",
+        'dont': "don't",
+        'hadnt': "hadn't",
+        "hadnt've": "hadn't've",
+        "hadn'tve": "hadn't've",
+        'hasnt': "hasn't",
+        'havent': "haven't",
+        'hed': "he'd",
+        "hed've": "he'd've",
+        "he'dve": "he'd've",
+        'hes': "he's",
+        'howd': "how'd",
+        'howll': "how'll",
+        'hows': "how's",
+        "Id've": "I'd've",
+        "I'dve": "I'd've",
+        'Im': "I'm",
+        'Ive': "I've",
+        'isnt': "isn't",
+        'itd': "it'd",
+        "itd've": "it'd've",
+        "it'dve": "it'd've",
+        'itll': "it'll",
+        "let's": "let's",
+        'maam': "ma'am",
+        'mightnt': "mightn't",
+        "mightnt've": "mightn't've",
+        "mightn'tve": "mightn't've",
+        'mightve': "might've",
+        'mustnt': "mustn't",
+        'mustve': "must've",
+        'neednt': "needn't",
+        'notve': "not've",
+        'oclock': "o'clock",
+        'oughtnt': "oughtn't",
+        "ow's'at": "'ow's'at",
+        "'ows'at": "'ow's'at",
+        "'ow'sat": "'ow's'at",
+        'shant': "shan't",
+        "shed've": "she'd've",
+        "she'dve": "she'd've",
+        "she's": "she's",
+        'shouldve': "should've",
+        'shouldnt': "shouldn't",
+        "shouldnt've": "shouldn't've",
+        "shouldn'tve": "shouldn't've",
+        "somebody'd": 'somebodyd',
+        "somebodyd've": "somebody'd've",
+        "somebody'dve": "somebody'd've",
+        'somebodyll': "somebody'll",
+        'somebodys': "somebody's",
+        'someoned': "someone'd",
+        "someoned've": "someone'd've",
+        "someone'dve": "someone'd've",
+        'someonell': "someone'll",
+        'someones': "someone's",
+        'somethingd': "something'd",
+        "somethingd've": "something'd've",
+        "something'dve": "something'd've",
+        'somethingll': "something'll",
+        'thats': "that's",
+        'thered': "there'd",
+        "thered've": "there'd've",
+        "there'dve": "there'd've",
+        'therere': "there're",
+        'theres': "there's",
+        'theyd': "they'd",
+        "theyd've": "they'd've",
+        "they'dve": "they'd've",
+        'theyll': "they'll",
+        'theyre': "they're",
+        'theyve': "they've",
+        'twas': "'twas",
+        'wasnt': "wasn't",
+        "wed've": "we'd've",
+        "we'dve": "we'd've",
+        'weve': "we've",
+        'werent': "weren't",
+        'whatll': "what'll",
+        'whatre': "what're",
+        'whats': "what's",
+        'whatve': "what've",
+        'whens': "when's",
+        'whered': "where'd",
+        'wheres': "where's",
+        'whereve': "where've",
+        'whod': "who'd",
+        "whod've": "who'd've",
+        "who'dve": "who'd've",
+        'wholl': "who'll",
+        'whos': "who's",
+        'whove': "who've",
+        'whyll': "why'll",
+        'whyre': "why're",
+        'whys': "why's",
+        'wont': "won't",
+        'wouldve': "would've",
+        'wouldnt': "wouldn't",
+        "wouldnt've": "wouldn't've",
+        "wouldn'tve": "wouldn't've",
+        'yall': "y'all",
+        "yall'll": "y'all'll",
+        "y'allll": "y'all'll",
+        "yall'd've": "y'all'd've",
+        "y'alld've": "y'all'd've",
+        "y'all'dve": "y'all'd've",
+        'youd': "you'd",
+        "youd've": "you'd've",
+        "you'dve": "you'd've",
+        'youll': "you'll",
+        'youre': "you're",
+        'youve': "you've",
+    }
+    for word in tempText:
+        word = manualMap.setdefault(word, word)
+        if word not in articles:
+            outText.append(word)
+    for wordId, word in enumerate(outText):
+        if word in contractions:
+            outText[wordId] = contractions[word]
+    outText = ' '.join(outText)
+    return outText
+
+
+def hit_calculate(result, dataset_name, anls_threshold=0.5):
+    if listinstr(['TextVQA'], dataset_name):
+        return [np.mean(x['match']) for x in result]
+    elif listinstr(['DocVQA', 'InfoVQA'], dataset_name):
+        return [0.0 if 1 - np.min(x['match']) < anls_threshold else 1 - np.min(x['match']) for x in result]
+    elif listinstr(['ChartQA', 'OCRVQA'], dataset_name):
+        return [np.max(x['match']) for x in result]
+    else:  # default using vqa_score to calculate score
+        return [np.mean(x['match']) for x in result]
+
+
+# https://github.com/google-research/pix2struct/blob/main/pix2struct/metrics.py#L81
+def relaxed_correctness(target: str,
+                        prediction: str,
+                        max_relative_change: float = 0.05) -> bool:
+    """Calculates relaxed correctness.
+
+    The correctness tolerates certain error ratio defined by max_relative_change.
+    See https://arxiv.org/pdf/2203.10244.pdf, end of section 5.1:
+    “Following Methani et al. (2020), we use a relaxed accuracy measure for the
+    numeric answers to allow a minor inaccuracy that may result from the automatic
+    data extraction process. We consider an answer to be correct if it is within
+    5% of the gold answer. For non-numeric answers, we still need an exact match
+    to consider an answer to be correct.”
+
+    Args:
+      target: Target string.
+      prediction: Predicted string.
+      max_relative_change: Maximum relative change.
+
+    Returns:
+      Whether the prediction was correct given the specified tolerance.
+    """
+
+    def _to_float(text: str) -> Optional[float]:
+        try:
+            if text.endswith('%'):
+                # Convert percentages to floats.
+                return float(text.rstrip('%')) / 100.0
+            else:
+                return float(text)
+        except ValueError:
+            return None
+    prediction = str(prediction)
+    target = str(target)
+    prediction_float = _to_float(prediction)
+    target_float = _to_float(target)
+    if prediction_float is not None and target_float:
+        relative_change = abs(prediction_float - target_float) / abs(target_float)
+        return relative_change <= max_relative_change
+    else:
+        return prediction.lower() == target.lower()
+
+
+def levenshtein_distance(s1, s2):
+    if len(s1) > len(s2):
+        s1, s2 = s2, s1
+
+    distances = range(len(s1) + 1)
+    for i2, c2 in enumerate(s2):
+        distances_ = [i2 + 1]
+        for i1, c1 in enumerate(s1):
+            if c1 == c2:
+                distances_.append(distances[i1])
+            else:
+                distances_.append(1 + min((distances[i1], distances[i1 + 1], distances_[-1])))
+        distances = distances_
+    return distances[-1]
+
+
+def anls_compute(groundtruth, prediction):
+    gt_answer = ' '.join(groundtruth.strip().lower().split())
+    det_answer = ' '.join(prediction.strip().lower().split())
+    dist = levenshtein_distance(gt_answer, det_answer)
+    length = max(len(groundtruth.upper()), len(prediction.upper()))
+    values = 0.0 if length == 0 else float(dist) / float(length)
+    return values
+
+
+def process_answer(answer):
+    answer = answer.replace('\n', ' ')
+    answer = answer.replace('\t', ' ')
+    answer = answer.strip()
+    answer = process_punctuation(answer)
+    answer = _process_digit_article(answer)
+    return answer
+
+
+def process_line(line, method='vqa_score'):
+    ret = {}
+    if istype(line['answer'], list):
+        answers = eval(line['answer'])
+    else:
+        answers = [line['answer']]
+    if method == 'vqa_score':
+        ret['gt'] = [process_answer(x) for x in answers]
+        ret['pred'] = process_answer(line['prediction'])
+        ret['match'] = []
+        for current_idx, gtAnsDatum in enumerate(ret['gt']):
+            otherGTAns = [
+                item for ret_gt_idx, item in enumerate(ret['gt'])
+                if ret_gt_idx != current_idx
+            ]
+            matchingAns = [
+                item for item in otherGTAns if item == ret['pred']
+            ]
+            acc = min(1, float(len(matchingAns)) / 3)
+            ret['match'].append(acc)
+    elif method == 'anls':
+        ret['gt'] = answers
+        ret['pred'] = line['prediction']
+        ret['match'] = [anls_compute(x, ret['pred']) for x in ret['gt']]
+    elif method == 'relaxed_accuracy':
+        ret['gt'] = answers
+        ret['pred'] = line['prediction'].strip()
+        ret['match'] = [relaxed_correctness(x, ret['pred']) for x in ret['gt']]
+    elif method == 'accuracy':
+        ret['gt'] = answers
+        ret['pred'] = line['prediction'].strip()
+        ret['match'] = [(1.0 if (x.strip().lower() == ret['pred'].strip().lower()) else 0.0) for x in ret['gt']]
+    else:  # default using vqa_score to calculate score
+        ret['gt'] = [process_answer(x) for x in answers]
+        ret['pred'] = process_answer(line['prediction'])
+        ret['match'] = [x == ret['pred'] for x in ret['gt']]
+
+    return ret
+
+
+def process_line_WildDoc(line, method='vqa_score'):
+    ret = {'index':line["index"]}
+    if istype(line['answer'], list):
+        answers = eval(line['answer'])
+    else:
+        answers = [line['answer']]
+    if method == 'vqa_score':
+        ret['gt'] = [process_answer(x) for x in answers]
+        ret['pred'] = process_answer(line['prediction'])
+        ret['match'] = []
+        for current_idx, gtAnsDatum in enumerate(ret['gt']):
+            otherGTAns = [
+                item for ret_gt_idx, item in enumerate(ret['gt'])
+                if ret_gt_idx != current_idx
+            ]
+            matchingAns = [
+                item for item in otherGTAns if item == ret['pred']
+            ]
+            acc = min(1, float(len(matchingAns)) / 3)
+            ret['match'].append(acc)
+    elif method == 'anls':
+        ret['gt'] = answers
+        ret['pred'] = line['prediction']
+        # import pdb
+        # pdb.set_trace()
+        ret['match'] = [anls_compute(x, ret['pred']) for x in ret['gt']]
+    elif method == 'relaxed_accuracy':
+        ret['gt'] = answers
+        ret['pred'] = line['prediction'].strip()
+        ret['match'] = [relaxed_correctness(x, ret['pred']) for x in ret['gt']]
+    elif method == 'accuracy':
+        ret['gt'] = answers
+        ret['pred'] = line['prediction'].strip()
+        ret['match'] = [(1.0 if (x.strip().lower() == ret['pred'].strip().lower()) else 0.0) for x in ret['gt']]
+    else:  # default using vqa_score to calculate score
+        ret['gt'] = [process_answer(x) for x in answers]
+        ret['pred'] = process_answer(line['prediction'])
+        ret['match'] = [x == ret['pred'] for x in ret['gt']]
+
+    return ret
+
+
+def calculate_consistency_WildDoc(result, anls_threshold=0.5):
+    ret = 0
+    consistency = {}
+
+    for line in result:
+        unique_index = "-".join([line["index"].split("-")[0], line["index"].split("-")[1], line["index"].split("-")[3]])
+        dataset_name = line["index"].split("-")[0]
+        if dataset_name == "DocVQA":
+            score = 0.0 if 1 - np.min(line['match']) < anls_threshold else 1 - np.min(line['match'])
+        elif dataset_name == "ChartQA" or dataset_name == "TableVQA":
+            score = np.max(line['match'])
+        if ((dataset_name == "ChartQA" or dataset_name == "TableVQA" or dataset_name == "TableVQA") and score == 1) or (dataset_name == "DocVQA" and score > 0.5):  # noqa: E501
+            if unique_index in consistency:
+                consistency[unique_index] += 1
+            else:
+                consistency[unique_index] = 1
+
+    for key, value in consistency.items():
+        ret += 1 if value == 4 else 0
+
+    return ret / (len(result) / 4) * 100
+
+
+def calculate_overall_accuracy_WildDoc(result, anls_threshold=0.5):
+    score = 0
+    for line in result:
+        benchmark_name = line["index"].split("-")[0]
+        if benchmark_name == "DocVQA":
+            score += 0.0 if 1 - np.min(line['match']) < anls_threshold else 1 - np.min(line['match'])
+        elif benchmark_name == "ChartQA" or benchmark_name == "TableVQA":
+            score += np.max(line['match'])
+        else:
+            score += np.mean(line['match'])
+    return score / len(result) * 100
diff --git a/VLMEvalKit-sudoku/vlmeval/vlm/__pycache__/h2ovl_mississippi.cpython-310.pyc b/VLMEvalKit-sudoku/vlmeval/vlm/__pycache__/h2ovl_mississippi.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..79672bcfedf69f401270e6036873ed60f75a20bc
Binary files /dev/null and b/VLMEvalKit-sudoku/vlmeval/vlm/__pycache__/h2ovl_mississippi.cpython-310.pyc differ
diff --git a/VLMEvalKit-sudoku/vlmeval/vlm/__pycache__/molmo.cpython-310.pyc b/VLMEvalKit-sudoku/vlmeval/vlm/__pycache__/molmo.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0e724a713ae41d076238f28ae30de62dcacc6a4f
Binary files /dev/null and b/VLMEvalKit-sudoku/vlmeval/vlm/__pycache__/molmo.cpython-310.pyc differ
diff --git a/VLMEvalKit-sudoku/vlmeval/vlm/__pycache__/pixtral.cpython-310.pyc b/VLMEvalKit-sudoku/vlmeval/vlm/__pycache__/pixtral.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f5d9b220f103802c7f08fd8e7384dda12154702a
Binary files /dev/null and b/VLMEvalKit-sudoku/vlmeval/vlm/__pycache__/pixtral.cpython-310.pyc differ
diff --git a/VLMEvalKit-sudoku/vlmeval/vlm/__pycache__/qwen_vl.cpython-310.pyc b/VLMEvalKit-sudoku/vlmeval/vlm/__pycache__/qwen_vl.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ce696d1b5764eb2a6f77d126ed839bb41c23f8ac
Binary files /dev/null and b/VLMEvalKit-sudoku/vlmeval/vlm/__pycache__/qwen_vl.cpython-310.pyc differ
diff --git a/VLMEvalKit-sudoku/vlmeval/vlm/__pycache__/sail_vl.cpython-310.pyc b/VLMEvalKit-sudoku/vlmeval/vlm/__pycache__/sail_vl.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ccadd2133df3581e248f92129c49eaa40447fda2
Binary files /dev/null and b/VLMEvalKit-sudoku/vlmeval/vlm/__pycache__/sail_vl.cpython-310.pyc differ
diff --git a/VLMEvalKit-sudoku/vlmeval/vlm/__pycache__/slime.cpython-310.pyc b/VLMEvalKit-sudoku/vlmeval/vlm/__pycache__/slime.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1049f3f56c2dbc3edd56e4157aca67fab816a75f
Binary files /dev/null and b/VLMEvalKit-sudoku/vlmeval/vlm/__pycache__/slime.cpython-310.pyc differ
diff --git a/VLMEvalKit-sudoku/vlmeval/vlm/granite_vision/__init__.py b/VLMEvalKit-sudoku/vlmeval/vlm/granite_vision/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4e9b2adb1e2cb4294b40471cf3781e7672bc2860
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/vlm/granite_vision/__init__.py
@@ -0,0 +1,4 @@
+from .granite_vision import GraniteVision3
+
+
+__all__ = ['GraniteVision3']
diff --git a/VLMEvalKit-sudoku/vlmeval/vlm/granite_vision/granite_vision.py b/VLMEvalKit-sudoku/vlmeval/vlm/granite_vision/granite_vision.py
new file mode 100644
index 0000000000000000000000000000000000000000..1f46f86cb4ba535668fac2824b82791181e9a272
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/vlm/granite_vision/granite_vision.py
@@ -0,0 +1,184 @@
+import torch
+from PIL import Image
+from abc import abstractproperty
+import sys
+import os.path as osp
+from ..base import BaseModel
+from ...smp import *
+from ...dataset import DATASET_TYPE, DATASET_MODALITY
+import copy
+import requests
+from transformers import AutoModelForVision2Seq, AutoProcessor
+
+flash_attn_flag = False
+try:
+    import flash_attn
+
+    flash_attn_flag = True
+except ImportError:
+    pass
+
+
+class GraniteVision3(BaseModel):
+    INSTALL_REQ = False
+    INTERLEAVE = True
+
+    def __init__(
+        self, model_path="ibm-granite/granite-vision-3.3-2b", use_vllm=False, **kwargs
+    ):
+        # assert not use_vllm "vLLM is not yet supported for evaluations in VLMEvalKit"
+        self.model_path = model_path
+        self.processor = AutoProcessor.from_pretrained(self.model_path)
+        attn_impl = "flash_attention_2" if flash_attn_flag else "eager"
+        model = AutoModelForVision2Seq.from_pretrained(
+            self.model_path,
+            torch_dtype=torch.bfloat16,
+            low_cpu_mem_usage=True,
+            attn_implementation=attn_impl
+        )
+
+        model = model.eval()
+        self.model = model.cuda()
+        kwargs_default = dict(do_sample=False, max_new_tokens=2048)
+        kwargs_default.update(kwargs)
+        self.kwargs = kwargs_default
+        warnings.warn(
+            f"Following kwargs received: {self.kwargs}, will use as generation config. "
+        )
+
+    def output_process(self, answer, dataset):
+        if "<s>" in answer:
+            answer = answer.replace("<s>", "").strip()
+        if "<|assistant|>" in answer:
+            answer = answer.split("<|assistant|>")[1].strip("\n .")
+        elif "<|start_of_role|>assistant<|end_of_role|>" in answer:
+            answer = answer.split("<|start_of_role|>assistant<|end_of_role|>")[1].strip(
+                "\n ."
+            )
+
+        if "<|end_of_text|>" in answer:
+            answer = answer.split("<|end_of_text|>")[0].strip("\n ")
+        if dataset in [
+            "ChartQA_TEST",
+            "DocVQA_VAL",
+            "DocVQA_TEST",
+            "InfoVQA_VAL",
+            "InfoVQA_TEST",
+            "OCRVQA_TEST",
+            "OCRVQA_TESTCORE",
+            "TextVQA_VAL"
+        ]:
+            answer = answer.strip(".")
+
+        return answer
+
+    def use_custom_prompt(self, dataset):
+        assert dataset is not None
+        if DATASET_TYPE(dataset) == "MCQ":
+            return True
+        if dataset in ["OCRBench", "COCO_VAL"]:
+            return True
+        return False
+
+    def get_pre_post_prompt(self, dataset, chineese=False):
+        pre_post_prompt = {
+            "OCRBench": (
+                "",
+                "\nReply with only one word or a short phrase or a full address.",
+            ),
+            "COCO_VAL": ("", "\nReply with one short sentence."),
+        }
+        pre_post_prompt_cn = {}
+
+        return (
+            pre_post_prompt.get(dataset, ("", ""))
+            if not chineese
+            else pre_post_prompt_cn.get(dataset, ("", ""))
+        )
+
+    def build_promt_mcq(self, line):
+        question = line["question"]
+        hint = line["hint"] if ("hint" in line and not pd.isna(line["hint"])) else None
+        if hint is not None:
+            question = hint + "\n" + question
+
+        options = {
+            cand: line[cand]
+            for cand in string.ascii_uppercase
+            if cand in line and not pd.isna(line[cand])
+        }
+        for key, item in options.items():
+            question += f"\n{key}. {item}"
+        prompt = question
+
+        if len(options):
+            prompt += (
+                "\n请直接回答选项字母。"
+                if cn_string(prompt)
+                else "\nAnswer with the option's letter from the given choices directly."
+            )
+        else:
+            prompt += (
+                "\n请直接回答问题。"
+                if cn_string(prompt)
+                else "\nAnswer the question directly."
+            )
+        return prompt
+
+    def build_prompt(self, line, dataset=None):
+        assert self.use_custom_prompt(dataset)
+        assert dataset is None or isinstance(dataset, str)
+
+        tgt_path = self.dump_image(line, dataset)
+        if DATASET_TYPE(dataset) == "MCQ":
+            prompt = self.build_promt_mcq(line)
+        else:
+            prompt = line["question"]
+        pre_promt, post_prompt = self.get_pre_post_prompt(
+            dataset, chineese=cn_string(prompt)
+        )
+        prompt = pre_promt + prompt + post_prompt
+        message = [dict(type="image", value=s) for s in tgt_path]
+        message.append(dict(type="text", value=prompt))
+
+        return message
+
+    def resize_to_max_dim(self, image: Image.Image, max_dim: int = 768) -> Image.Image:
+        """Resize image so the longer side is exactly `max_dim` pixels."""
+        w, h = image.size
+        scale = max_dim / max(w, h)
+        new_size = (int(w * scale), int(h * scale))
+        # print(f"Resized image from {(w,h)} to {new_size}")
+        return image.resize(new_size, Image.LANCZOS)
+
+    def generate_inner(self, message, dataset=None):
+        content, images = [], []
+        img_count = 0
+        for msg in message:
+            if not msg["type"] == "text":
+                img_count += 1
+        for msg in message:
+            if msg["type"] == "text":
+                content.append({"type": msg["type"], "text": msg["value"]})
+            else:
+                content.append({"type": "image"})
+                img = Image.open(msg["value"]).convert("RGB")
+                if img_count > 2:
+                    img = self.resize_to_max_dim(img)
+                images.append(img)
+        conversation = [
+            {
+                "role": "user",
+                "content": content,
+            }
+        ]
+        prompt = self.processor.apply_chat_template(
+            conversation, add_generation_prompt=True
+        )
+        inputs = self.processor(prompt, images, return_tensors="pt").to(
+            "cuda", torch.float16
+        )
+        output = self.model.generate(**inputs, **self.kwargs)
+        answer = self.processor.decode(output[0], skip_special_token=True)
+        answer = self.output_process(answer, dataset)
+        return answer
diff --git a/VLMEvalKit-sudoku/vlmeval/vlm/hawk_vl/model.py b/VLMEvalKit-sudoku/vlmeval/vlm/hawk_vl/model.py
new file mode 100644
index 0000000000000000000000000000000000000000..4838e0795ee73f1131f29afff4f49641ade84a37
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/vlm/hawk_vl/model.py
@@ -0,0 +1,150 @@
+import os
+import warnings
+from .prompt import HawkVLPromptMixin
+from ..base import BaseModel
+import logging
+import torch
+
+
+def ensure_image_url(image: str) -> str:
+    prefixes = ['http://', 'https://', 'file://', 'data:image;']
+    if any(image.startswith(prefix) for prefix in prefixes):
+        return image
+    if os.path.exists(image):
+        return 'file://' + image
+    raise ValueError(f'Invalid image: {image}')
+
+
+def ensure_video_url(video: str) -> str:
+    prefixes = ['http://', 'https://', 'file://', 'data:video;']
+    if any(video.startswith(prefix) for prefix in prefixes):
+        return video
+    if os.path.exists(video):
+        return 'file://' + video
+    raise ValueError(f'Invalid video: {video}')
+
+
+class HawkVL(HawkVLPromptMixin, BaseModel):
+
+    INSTALL_REQ = False
+    INTERLEAVE = False
+
+    def __init__(
+        self,
+        model_path: str,
+        min_pixels: int = None,
+        max_pixels: int = None,
+        max_new_tokens=1024,
+        top_p=0.8,
+        top_k=20,
+        temperature=0.7,
+        repetition_penalty=1.0,
+        use_custom_prompt: bool = False,
+        system_prompt: str = None,
+        verbose: bool = False,
+    ):
+        try:
+            from .hawk.model import HawkQwenForCausalLM
+        except Exception as e:
+            logging.critical(
+                "Please move the code ('hawk' directory) to $VLMEVALKIT/vlm/hawk_vl."
+            )
+            raise e
+        super().__init__(use_custom_prompt=use_custom_prompt)
+        self.min_pixels = min_pixels
+        self.max_pixels = max_pixels
+        self.generate_kwargs = dict(
+            max_new_tokens=max_new_tokens,
+            top_p=top_p,
+            top_k=top_k,
+            temperature=temperature,
+            repetition_penalty=repetition_penalty,
+        )
+        self.system_prompt = system_prompt
+        self.verbose = verbose
+        self.fps = 1.0
+        self.nframe = 64
+        self.FRAME_FACTOR = 1
+
+        self.model_path = model_path
+        from transformers import AutoProcessor
+        self.processor = AutoProcessor.from_pretrained(model_path)
+
+        self.model = HawkQwenForCausalLM.from_pretrained(
+            model_path, torch_dtype=torch.bfloat16, attn_implementation='flash_attention_2', device_map=None)
+
+        self.model.cuda().eval()
+
+    def _prepare_content(self, inputs: list[dict[str, str]], dataset: str = None) -> list[dict[str, str]]:
+        """
+        inputs list[dict[str, str]], each dict has keys: ['type', 'value']
+        """
+        content = []
+        for s in inputs:
+            if s['type'] == 'image':
+                item = {'type': 'image', 'image': ensure_image_url(s['value'])}
+                if dataset == 'OCRBench':
+                    item['min_pixels'] = 10 * 10 * 28 * 28
+                    warnings.warn(f"OCRBench dataset uses custom min_pixels={item['min_pixels']}")
+                    if self.max_pixels is not None:
+                        item['max_pixels'] = self.max_pixels
+                else:
+                    if self.min_pixels is not None:
+                        item['min_pixels'] = self.min_pixels
+                    if self.max_pixels is not None:
+                        item['max_pixels'] = self.max_pixels
+            elif s['type'] == 'video':
+                item = {'type': 'video', 'video': ensure_video_url(s['value'])}
+                if self.fps is not None:
+                    item['fps'] = self.fps
+                elif self.nframe is not None:
+                    import cv2
+                    video = cv2.VideoCapture(s['value'])
+                    frame_count = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
+                    video.release()
+                    if frame_count < self.nframe:
+                        new_frame_count = frame_count // self.FRAME_FACTOR * self.FRAME_FACTOR
+                        print(f"use {new_frame_count} for {s['value']}")
+                        item['nframes'] = new_frame_count
+                    else:
+                        item['nframes'] = self.nframe
+            elif s['type'] == 'text':
+                item = {'type': 'text', 'text': s['value']}
+            else:
+                raise ValueError(f"Invalid message type: {s['type']}, {s}")
+            content.append(item)
+        return content
+
+    def generate_inner(self, message, dataset=None):
+        try:
+            from qwen_vl_utils import process_vision_info
+        except Exception as err:
+            logging.critical("qwen_vl_utils not found, please install it via 'pip install qwen-vl-utils'")
+            raise err
+
+        messages = []
+        if self.system_prompt is not None:
+            messages.append({'role': 'system', 'content': self.system_prompt})
+        messages.append({'role': 'user', 'content': self._prepare_content(message, dataset=dataset)})
+        if self.verbose:
+            print(f'\033[31m{messages}\033[0m')
+
+        text = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+        images, videos = process_vision_info(messages)
+        inputs = self.processor(text=[text], images=images, videos=videos, padding=True, return_tensors='pt')
+
+        inputs = inputs.to('cuda')
+
+        generated_ids = self.model.generate(
+            **inputs,
+            **self.generate_kwargs,
+        )
+
+        out = self.processor.batch_decode(
+            generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False
+        )
+        response = out[0].strip()
+
+        if self.verbose:
+            print(f'\033[32m{response}\033[0m')
+        return response
diff --git a/VLMEvalKit-sudoku/vlmeval/vlm/hawk_vl/prompt.py b/VLMEvalKit-sudoku/vlmeval/vlm/hawk_vl/prompt.py
new file mode 100644
index 0000000000000000000000000000000000000000..582f6f756a3dcb8d70090b4f186648521b30b008
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/vlm/hawk_vl/prompt.py
@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+
+# Adapted from vlmeval/vlm/qwen2_vl/prompt.py
+class HawkVLPromptMixin:
+    """
+    Mixin class for HawkVL to build custom prompt for different datasets.
+
+    Requires the following methods to be implemented in the subclass:
+        - dump_image(line, dataset: str) -> str | list[str]
+
+    Implements the following methods:
+        - use_custom_prompt(dataset: str) -> bool
+        - build_prompt(line, dataset: str) -> list[dict[str, str]]
+    """
+
+    def __init__(self, *args, use_custom_prompt: bool = True, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._use_custom_prompt = use_custom_prompt
+
+    def set_dump_image(self, dump_image_func):
+        self.dump_image_func = dump_image_func
+
+    def dump_image(self, line, dataset):
+        return self.dump_image_func(line)
+
+    def use_custom_prompt(self, dataset: str) -> bool:
+        from vlmeval.dataset import DATASET_TYPE
+        dataset_type = DATASET_TYPE(dataset, default=None)
+
+        if not self._use_custom_prompt:
+            return False
+        if dataset in {'MMMU_DEV_VAL', 'MMMU_TEST'}:
+            return True
+        if dataset_type == 'MCQ':
+            if dataset == 'LEGO':
+                return False
+            return True
+        if dataset_type == 'Y/N' and dataset in {'HallusionBench', 'POPE'}:  # MME has it's own prompt
+            return True
+        if dataset_type == 'VQA' and dataset not in {'MMVet'}:  # MMVet VQA has it's own prompt
+            return True
+        return False
+
+    def build_prompt(self, line, dataset: str) -> list[dict[str, str]]:
+        from vlmeval.dataset import DATASET_TYPE
+
+        if dataset in {'MMMU_DEV_VAL', 'MMMU_TEST'}:
+            return self._build_mmmu_prompt(line, dataset)
+        dataset_type = DATASET_TYPE(dataset, default=None)
+        if dataset_type == 'MCQ':
+            return self._build_mcq_prompt(line, dataset)
+        if dataset_type == 'Y/N':
+            return self._build_yorn_prompt(line, dataset)
+        if dataset_type == 'VQA':
+            return self._build_vqa_prompt(line, dataset)
+        raise ValueError(f'Unsupported dataset: {dataset}')
+
+    def _build_mmmu_prompt(self, line, dataset: str) -> list[dict[str, str]]:
+        """change the prompt for MMMU dataset: keep all images at beginning."""
+
+        import string
+
+        import pandas as pd
+
+        tgt_path = self.dump_image(line, dataset)
+        question = line['question']
+        options = {cand: line[cand] for cand in string.ascii_uppercase if cand in line and not pd.isna(line[cand])}
+        options_prompt = 'Options:\n'
+        for key, item in options.items():
+            options_prompt += f'{key}. {item}\n'
+        hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+        prompt = ''
+        if hint is not None:
+            prompt += f'Hint: {hint}\n'
+        prompt += f'Question: {question}\n'
+        if len(options):
+            prompt += options_prompt
+            prompt += "Answer with the option's letter from the given choices directly. \n"
+        prompt = prompt.rstrip()
+        msgs = []
+        if isinstance(tgt_path, list):
+            msgs.extend([dict(type='image', value=p) for p in tgt_path])
+        else:
+            msgs = [dict(type='image', value=tgt_path)]
+        msgs.append(dict(type='text', value=prompt))
+        return msgs
+
+    def _build_mcq_prompt(self, line, dataset: str) -> list[dict[str, str]]:
+        """change the prompt for MCQ dataset: use chinese prompt if the question contains chinese characters."""
+        MCQ_CN_PROMPT = '请直接回答选项字母。'
+        MCQ_EN_PROMPT = "Answer with the option's letter from the given choices directly."
+
+        import string
+
+        import pandas as pd
+
+        def cn_string(s):
+            import re
+
+            if re.search('[\u4e00-\u9fff]', s):
+                return True
+            return False
+
+        tgt_path = self.dump_image(line, dataset)
+        question = line['question']
+        options = {cand: line[cand] for cand in string.ascii_uppercase if cand in line and not pd.isna(line[cand])}
+        options_prompt = 'Options:\n'
+        for key, item in options.items():
+            options_prompt += f'{key}. {item}\n'
+        hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+        prompt = ''
+        if hint is not None:
+            prompt += f'Hint: {hint}\n'
+        prompt += f'Question: {question}\n'
+        if len(options):
+            prompt += options_prompt
+            prompt += MCQ_CN_PROMPT if cn_string(prompt) else MCQ_EN_PROMPT
+        prompt = prompt.rstrip()
+        msgs = []
+        if isinstance(tgt_path, list):
+            msgs.extend([dict(type='image', value=p) for p in tgt_path])
+        else:
+            msgs = [dict(type='image', value=tgt_path)]
+        msgs.append(dict(type='text', value=prompt))
+        return msgs
+
+    def _build_yorn_prompt(self, line, dataset: str) -> list[dict[str, str]]:
+        """change the prompt for YORN dataset:"""
+        YORN_PROMPT = ' Please answer yes or no.'
+
+        tgt_path = self.dump_image(line, dataset)
+        question = line['question']
+        msgs = []
+        if isinstance(tgt_path, list):
+            msgs.extend([dict(type='image', value=p) for p in tgt_path])
+        else:
+            msgs = [dict(type='image', value=tgt_path)]
+        msgs.append(dict(type='text', value=question))
+        assert msgs[-1]['type'] == 'text'
+        msgs[-1]['value'] += YORN_PROMPT
+        return msgs
+
+    def _build_vqa_prompt(self, line, dataset: str) -> list[dict[str, str]]:
+        """change the prompt for VQA dataset:"""
+        VQA_PROMPT = "\nAnswer the question using a single word or phrase."
+
+        tgt_path = self.dump_image(line, dataset)
+        question = line['question']
+        msgs = []
+        if isinstance(tgt_path, list):
+            msgs.extend([dict(type='image', value=p) for p in tgt_path])
+        else:
+            msgs = [dict(type='image', value=tgt_path)]
+        msgs.append(dict(type='text', value=question))
+        assert msgs[-1]['type'] == 'text'
+        msgs[-1]['value'] += VQA_PROMPT
+        return msgs
diff --git a/VLMEvalKit-sudoku/vlmeval/vlm/llava/__init__.py b/VLMEvalKit-sudoku/vlmeval/vlm/llava/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..9ad9a644a262fe21e34f656d067798edcd18b522
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/vlm/llava/__init__.py
@@ -0,0 +1,4 @@
+from .llava import LLaVA, LLaVA_Next, LLaVA_Next2, LLaVA_OneVision, LLaVA_OneVision_HF
+from .llava_xtuner import LLaVA_XTuner
+
+__all__ = ['LLaVA', 'LLaVA_Next', 'LLaVA_XTuner', 'LLaVA_Next2', 'LLaVA_OneVision', 'LLaVA_OneVision_HF']
diff --git a/VLMEvalKit-sudoku/vlmeval/vlm/llava/llava.py b/VLMEvalKit-sudoku/vlmeval/vlm/llava/llava.py
new file mode 100644
index 0000000000000000000000000000000000000000..889c01167a6039125e7dfc35e66f8bed976dd2a6
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/vlm/llava/llava.py
@@ -0,0 +1,845 @@
+import torch
+from PIL import Image
+from abc import abstractproperty
+import sys
+import os.path as osp
+from ..base import BaseModel
+from ...smp import *
+from ...dataset import DATASET_TYPE, DATASET_MODALITY
+import copy
+import requests
+
+
+class LLaVA(BaseModel):
+
+    INSTALL_REQ = True
+    INTERLEAVE = True
+
+    def __init__(self, model_path="liuhaotian/llava_v1.5_7b", **kwargs):
+        try:
+            from llava.model.builder import load_pretrained_model
+            from llava.mm_utils import get_model_name_from_path
+        except Exception as err:
+            logging.critical(
+                "Please install llava from https://github.com/haotian-liu/LLaVA"
+            )
+            raise err
+
+        assert osp.exists(model_path) or splitlen(model_path) == 2
+        self.system_prompt = (
+            "A chat between a curious human and an artificial intelligence assistant. "
+            "The assistant gives helpful, detailed, and polite answers to the human's questions. "
+        )
+        self.stop_str = "</s>"
+
+        if model_path == "Lin-Chen/ShareGPT4V-7B":
+            model_name = "llava-v1.5-7b"
+        elif model_path == "Lin-Chen/ShareGPT4V-13B":
+            model_name = "llava-v1.5-13b"
+        else:
+            model_name = get_model_name_from_path(model_path)
+
+        try:
+            self.tokenizer, self.model, self.image_processor, self.context_len = (
+                load_pretrained_model(
+                    model_path=model_path,
+                    model_base=None,
+                    model_name=model_name,
+                    device_map="cpu",
+                )
+            )
+        except Exception as err:
+            if "ShareGPT4V" in model_path:
+                import llava
+
+                logging.critical(
+                    "Please manually remove the encoder type check in "
+                    f"{llava.__path__[0]}/model/multimodal_encoder/builder.py "
+                    "Line 8 to use the ShareGPT4V model. "
+                )
+            else:
+                logging.critical("Unknown error when loading LLaVA model.")
+            raise err
+
+        self.model = self.model.cuda()
+        self.conv_mode = "llava_v1"
+
+        kwargs_default = dict(
+            do_sample=False,
+            temperature=0,
+            max_new_tokens=2048,
+            top_p=None,
+            num_beams=1,
+            use_cache=True,
+        )  # noqa E501
+        kwargs_default.update(kwargs)
+        self.kwargs = kwargs_default
+        warnings.warn(
+            f"Following kwargs received: {self.kwargs}, will use as generation config. "
+        )
+
+    def use_custom_prompt(self, dataset):
+        assert dataset is not None
+        if DATASET_TYPE(dataset) == "MCQ":
+            return True
+        return False
+
+    def build_prompt(self, line, dataset=None):
+        assert self.use_custom_prompt(dataset)
+        assert dataset is None or isinstance(dataset, str)
+        tgt_path = self.dump_image(line, dataset)
+
+        question = line["question"]
+        hint = line["hint"] if ("hint" in line and not pd.isna(line["hint"])) else None
+        if hint is not None:
+            question = hint + "\n" + question
+
+        options = {
+            cand: line[cand]
+            for cand in string.ascii_uppercase
+            if cand in line and not pd.isna(line[cand])
+        }
+        for key, item in options.items():
+            question += f"\n{key}. {item}"
+        prompt = question
+
+        if len(options):
+            prompt += (
+                "\n请直接回答选项字母。"
+                if cn_string(prompt)
+                else "\nAnswer with the option's letter from the given choices directly."
+            )
+        else:
+            prompt += (
+                "\n请直接回答问题。"
+                if cn_string(prompt)
+                else "\nAnswer the question directly."
+            )
+
+        message = [dict(type="image", value=s) for s in tgt_path]
+        message.append(dict(type="text", value=prompt))
+        return message
+
+    def concat_tilist(self, message):
+        text, images = "", []
+        for item in message:
+            if item["type"] == "text":
+                text += item["value"]
+            elif item["type"] == "image":
+                text += " <image> "
+                images.append(item["value"])
+        return text, images
+
+    def chat_inner(self, message, dataset=None):
+        from llava.mm_utils import (
+            process_images,
+            tokenizer_image_token,
+            KeywordsStoppingCriteria,
+        )
+        from llava.constants import IMAGE_TOKEN_INDEX
+
+        prompt = self.system_prompt
+        images = []
+        for utter in message:
+            prompt += "USER: " if utter["role"] == "user" else "ASSISTANT: "
+            content, images_sub = self.concat_tilist(utter["content"])
+            prompt += content
+            images.extend(images_sub)
+            prompt += " " if utter["role"] == "user" else self.stop_str
+        assert message[-1]["role"] == "user", message
+        prompt += "ASSISTANT: "
+
+        images = [Image.open(s).convert("RGB") for s in images]
+        args = abstractproperty()
+        args.image_aspect_ratio = "pad"
+        image_tensor = process_images(images, self.image_processor, args).to(
+            "cuda", dtype=torch.float16
+        )
+
+        input_ids = (
+            tokenizer_image_token(
+                prompt, self.tokenizer, IMAGE_TOKEN_INDEX, return_tensors="pt"
+            )
+            .unsqueeze(0)
+            .cuda()
+        )
+        keywords = [self.stop_str]
+        stopping_criteria = KeywordsStoppingCriteria(
+            keywords, self.tokenizer, input_ids
+        )
+        with torch.inference_mode():
+            output_ids = self.model.generate(
+                input_ids,
+                images=image_tensor,
+                stopping_criteria=[stopping_criteria],
+                **self.kwargs,
+            )
+        output = self.tokenizer.batch_decode(output_ids, skip_special_tokens=True)[
+            0
+        ].strip()
+        return output
+
+    def generate_inner(self, message, dataset=None):
+        from llava.mm_utils import (
+            process_images,
+            tokenizer_image_token,
+            KeywordsStoppingCriteria,
+        )
+        from llava.constants import IMAGE_TOKEN_INDEX
+
+        # Support interleave text and image
+        content, images = self.concat_tilist(message)
+
+        images = [Image.open(s).convert("RGB") for s in images]
+        args = abstractproperty()
+        args.image_aspect_ratio = "pad"
+        if images:
+            image_tensor = process_images(images, self.image_processor, args).to(
+                "cuda", dtype=torch.float16
+            )
+        else:
+            image_tensor = None
+
+        prompt = self.system_prompt + "USER: " + content + " ASSISTANT: "
+
+        input_ids = (
+            tokenizer_image_token(
+                prompt, self.tokenizer, IMAGE_TOKEN_INDEX, return_tensors="pt"
+            )
+            .unsqueeze(0)
+            .cuda()
+        )
+        keywords = [self.stop_str]
+        stopping_criteria = KeywordsStoppingCriteria(
+            keywords, self.tokenizer, input_ids
+        )
+        with torch.inference_mode():
+            output_ids = self.model.generate(
+                input_ids,
+                images=image_tensor,
+                stopping_criteria=[stopping_criteria],
+                **self.kwargs,
+            )
+
+        output = self.tokenizer.batch_decode(output_ids, skip_special_tokens=True)[
+            0
+        ].strip()
+        return output
+
+
+class LLaVA_Next(BaseModel):
+
+    INSTALL_REQ = False
+    INTERLEAVE = True
+
+    def __init__(self, model_path="llava-hf/llava-v1.6-vicuna-7b-hf", **kwargs):
+        import transformers
+        from transformers import (
+            LlavaNextProcessor,
+            LlavaNextForConditionalGeneration,
+            AutoProcessor,
+            LlavaForConditionalGeneration,
+        )
+
+        self.model_path = model_path
+        if "34b" in model_path.lower():
+            self.processor = LlavaNextProcessor.from_pretrained(
+                self.model_path, use_fast=False
+            )
+        elif "interleave" in model_path.lower():
+            self.processor = AutoProcessor.from_pretrained(self.model_path)
+        else:
+            self.processor = LlavaNextProcessor.from_pretrained(self.model_path)
+        flash_attn_flag = False
+        try:
+            import flash_attn
+
+            flash_attn_flag = True
+        except ImportError:
+            pass
+
+        if flash_attn_flag:
+            if "interleave" in model_path.lower():
+                model = LlavaForConditionalGeneration.from_pretrained(
+                    self.model_path,
+                    torch_dtype=torch.float16,
+                    low_cpu_mem_usage=True,
+                    use_flash_attention_2=True,
+                )
+            else:
+                model = LlavaNextForConditionalGeneration.from_pretrained(
+                    self.model_path,
+                    torch_dtype=torch.float16,
+                    low_cpu_mem_usage=True,
+                    use_flash_attention_2=True,
+                )
+        else:
+            if "interleave" in model_path.lower():
+                model = LlavaForConditionalGeneration.from_pretrained(
+                    self.model_path, torch_dtype=torch.float16, low_cpu_mem_usage=True
+                )
+            else:
+                model = LlavaNextForConditionalGeneration.from_pretrained(
+                    self.model_path, torch_dtype=torch.float16, low_cpu_mem_usage=True
+                )
+
+        model = model.eval()
+        self.model = model.cuda()
+        kwargs_default = dict(
+            do_sample=False, temperature=0, max_new_tokens=2048, top_p=None, num_beams=1
+        )
+        kwargs_default.update(kwargs)
+        self.kwargs = kwargs_default
+        warnings.warn(
+            f"Following kwargs received: {self.kwargs}, will use as generation config. "
+        )
+
+    def apply_prompt_template(self, prompt):
+        model_path = self.model_path.lower()
+        if "mistral" in model_path:
+            template = "[INST] PLACEHOLDER [/INST]"
+        elif "vicuna" in model_path:
+            template = (
+                "A chat between a curious human and an artificial intelligence assistant. "
+                "The assistant gives helpful, detailed, and polite answers to the human's questions. "
+                "USER: PLACEHOLDER ASSISTANT:"
+            )
+        elif "34b" in model_path:
+            template = (
+                "<|im_start|>system\nAnswer the questions.<|im_end|><|im_start|>user\nPLACEHOLDER<|im_end|>"
+                "<|im_start|>assistant\n"
+            )
+        else:
+            raise NotImplementedError(
+                f"Prompt template for {model_path} not implemented."
+            )
+
+        prompt = template.replace("PLACEHOLDER", f"<image>\n{prompt}")
+        return prompt
+
+    def output_process(self, answer):
+        if "<s>" in answer:
+            answer = answer.replace("<s>", "").strip()
+        if "[/INST]" in answer:
+            answer = answer.split("[/INST]")[1].strip()
+        elif "ASSISTANT:" in answer:
+            answer = answer.split("ASSISTANT:")[1].strip()
+        elif "assistant\n" in answer:
+            answer = answer.split("assistant\n")[1].strip()
+        elif "<|end_header_id|>\n\n" in answer:
+            answer = answer.split("<|end_header_id|>\n\n")[2].strip()
+
+        if "</s>" in answer:
+            answer = answer.split("</s>")[0].strip()
+        elif "<|im_end|>" in answer:
+            answer = answer.split("<|im_end|>")[0].strip()
+        elif "<|eot_id|>" in answer:
+            answer = answer.split("<|eot_id|>")[0].strip()
+        return answer
+
+    def use_custom_prompt(self, dataset):
+        assert dataset is not None
+        if DATASET_TYPE(dataset) == "MCQ":
+            return True
+        return False
+
+    def build_prompt(self, line, dataset=None):
+        assert self.use_custom_prompt(dataset)
+        assert dataset is None or isinstance(dataset, str)
+        tgt_path = self.dump_image(line, dataset)
+
+        question = line["question"]
+        hint = line["hint"] if ("hint" in line and not pd.isna(line["hint"])) else None
+        if hint is not None:
+            question = hint + "\n" + question
+
+        options = {
+            cand: line[cand]
+            for cand in string.ascii_uppercase
+            if cand in line and not pd.isna(line[cand])
+        }
+        for key, item in options.items():
+            question += f"\n{key}. {item}"
+        prompt = question
+
+        if len(options):
+            prompt += (
+                "\n请直接回答选项字母。"
+                if cn_string(prompt)
+                else "\nAnswer with the option's letter from the given choices directly."
+            )
+        else:
+            prompt += (
+                "\n请直接回答问题。"
+                if cn_string(prompt)
+                else "\nAnswer the question directly."
+            )
+        message = [dict(type="image", value=s) for s in tgt_path]
+        message.append(dict(type="text", value=prompt))
+        return message
+
+    def generate_inner(self, message, dataset=None):
+        content, images = [], []
+        for msg in message:
+            if msg["type"] == "text":
+                content.append({"type": msg["type"], "text": msg["value"]})
+            else:
+                content.append({"type": "image"})
+                images.append(Image.open(msg["value"]).convert("RGB"))
+        conversation = [
+            {
+                "role": "user",
+                "content": content,
+            }
+        ]
+        prompt = self.processor.apply_chat_template(
+            conversation, add_generation_prompt=True
+        )
+        inputs = self.processor(prompt, images, return_tensors="pt").to(
+            "cuda", torch.float16
+        )
+        output = self.model.generate(**inputs, **self.kwargs)
+        answer = self.processor.decode(output[0], skip_special_token=True)
+        answer = self.output_process(answer)
+        answer = answer.replace('<unk>', '')
+        return answer
+
+
+class LLaVA_Next2(BaseModel):
+    INSTALL_REQ = True
+    INTERLEAVE = True
+
+    DEFAULT_IMAGE_TOKEN = "<image>"
+    IMAGE_TOKEN_INDEX = -200
+
+    def __init__(self, model_path="lmms-lab/llama3-llava-next-8b", **kwargs):
+        assert model_path is not None
+        try:
+            from llava.model.builder import load_pretrained_model
+            from llava.conversation import conv_templates, SeparatorStyle
+            from llava.mm_utils import (
+                get_model_name_from_path,
+                tokenizer_image_token,
+                KeywordsStoppingCriteria,
+            )
+        except Exception as err:
+            logging.critical(
+                "Please `pip install git+https://github.com/LLaVA-VL/LLaVA-NeXT.git`"
+            )
+            raise err
+
+        model_name = get_model_name_from_path(model_path)
+        tokenizer, model, image_processor, _ = load_pretrained_model(
+            model_path, None, model_name, device_map=None
+        )
+        model.cuda().eval()
+        model.tie_weights()
+
+        if "llama3" in model_path.lower():
+            conv_mode = "llava_llama_3"
+        elif "qwen" in model_path.lower():
+            conv_mode = "qwen_1_5"
+        self.conv_template = conv_mode
+        self.conv_templates = conv_templates
+        self.tokenizer = tokenizer
+        self.model = model
+        self.image_processor = image_processor
+        self.tokenizer_image_token = tokenizer_image_token
+        self.KeywordStoppingCriteria = KeywordsStoppingCriteria
+        self.SeparatorStyle = SeparatorStyle
+
+    def generate_inner(self, message, dataset=None):
+        content, images = "", []
+        for msg in message:
+            if msg["type"] == "text":
+                content += msg["value"]
+            else:
+                images.append(Image.open(msg["value"]).convert("RGB"))
+                content += self.DEFAULT_IMAGE_TOKEN + "\n"
+
+        preprocess = self.image_processor.preprocess
+        image_tokenizer = self.tokenizer_image_token
+        image_tensor = [
+            preprocess(f, return_tensors="pt")["pixel_values"][0].half().cuda()
+            for f in images
+        ]
+        image_tensor = torch.stack(image_tensor)
+
+        conv = copy.deepcopy(self.conv_templates[self.conv_template])
+        conv.append_message(conv.roles[0], content)
+        conv.append_message(conv.roles[1], None)
+        prompt_question = conv.get_prompt()
+
+        input_ids = image_tokenizer(
+            prompt_question, self.tokenizer, self.IMAGE_TOKEN_INDEX, return_tensors="pt"
+        )
+        input_ids = input_ids.unsqueeze(0).cuda()
+
+        stop_str = conv.sep if conv.sep_style != self.SeparatorStyle.TWO else conv.sep2
+        keywords = [stop_str]
+        stopping_criteria = self.KeywordStoppingCriteria(
+            keywords, self.tokenizer, input_ids
+        )
+
+        cont = self.model.generate(
+            input_ids,
+            images=image_tensor,
+            do_sample=False,
+            temperature=0,
+            max_new_tokens=2048,
+            stopping_criteria=[stopping_criteria],
+        )
+        text_outputs = self.tokenizer.batch_decode(cont, skip_special_tokens=True)[0]
+        return text_outputs
+
+
+class LLaVA_OneVision(BaseModel):
+    INSTALL_REQ = True
+    INTERLEAVE = True
+    VIDEO_LLM = True
+    DEFAULT_IMAGE_TOKEN = "<image>"
+    IMAGE_TOKEN_INDEX = -200
+
+    def __init__(self, model_path="lmms-lab/llava-onevision-qwen2-7b-si", **kwargs):
+        assert model_path is not None
+        try:
+            from llava.model.builder import load_pretrained_model
+            from llava.conversation import conv_templates, SeparatorStyle
+            from llava.mm_utils import (
+                get_model_name_from_path,
+                process_images,
+                tokenizer_image_token,
+                KeywordsStoppingCriteria,
+            )  # noqa: E501
+        except Exception as err:
+            logging.critical(
+                "Please `pip install git+https://github.com/LLaVA-VL/LLaVA-NeXT.git`"
+            )
+            raise err
+
+        video_kwargs_default = dict(
+            overwrite=True, mm_spatial_pool_mode="average", force_sample=True
+        )
+        video_kwargs_default.update(kwargs)
+        self.video_kwargs = video_kwargs_default
+
+        overwrite_config = None
+        if "video" in model_path.lower():
+            if self.video_kwargs["overwrite"]:
+                overwrite_config = {}
+                overwrite_config["mm_spatial_pool_mode"] = self.video_kwargs[
+                    "mm_spatial_pool_mode"
+                ]
+
+        model_name = get_model_name_from_path(model_path)
+        import warnings
+        # filter warning align with official code
+        warnings.filterwarnings("ignore")
+        tokenizer, model, image_processor, _ = load_pretrained_model(
+            model_path,
+            None,
+            model_name,
+            device_map="auto",
+            overwrite_config=overwrite_config,
+        )
+        model.eval()
+        model.tie_weights()
+
+        if "llava" in model_path.lower():
+            conv_mode = "qwen_1_5"
+        if 'llava-video' in model_path.lower():
+            self.nframe = 64
+        else:
+            self.nframe = 16
+            if "72b" in model_path.lower():
+                self.nframe = 32
+
+        if "video" in model_path.lower():
+            self.force_sample = self.video_kwargs["force_sample"]
+        else:
+            self.force_sample = False
+
+        self.conv_template = conv_mode
+        self.conv_templates = conv_templates
+        self.tokenizer = tokenizer
+        self.model = model
+        self.image_processor = image_processor
+        self.tokenizer_image_token = tokenizer_image_token
+        self.process_images = (
+            process_images  # Store process_images as a class attribute
+        )
+        self.KeywordStoppingCriteria = KeywordsStoppingCriteria
+        self.SeparatorStyle = SeparatorStyle
+
+    def generate_inner_image(self, message, dataset=None):
+        content, images = "", []
+        image_sizes = []  # Store image sizes
+
+        for msg in message:
+            if msg["type"] == "text":
+                content += msg["value"]
+            else:
+                img = Image.open(msg["value"]).convert("RGB")
+                images.append(img)
+                image_sizes.append(img.size)  # Store the size of each image
+                content += self.DEFAULT_IMAGE_TOKEN + "\n"
+
+        # Process images using the class attribute self.process_images
+        image_tensor = self.process_images(
+            images, self.image_processor, self.model.config
+        )
+        image_tensor = [
+            _image.to(dtype=torch.float16, device="cuda") for _image in image_tensor
+        ]
+
+        conv = copy.deepcopy(self.conv_templates[self.conv_template])
+        conv.append_message(conv.roles[0], content)
+        conv.append_message(conv.roles[1], None)
+        prompt_question = conv.get_prompt()
+
+        input_ids = self.tokenizer_image_token(
+            prompt_question, self.tokenizer, self.IMAGE_TOKEN_INDEX, return_tensors="pt"
+        )
+        input_ids = input_ids.unsqueeze(0).cuda()
+
+        stop_str = conv.sep if conv.sep_style != self.SeparatorStyle.TWO else conv.sep2
+        keywords = [stop_str]
+        stopping_criteria = self.KeywordStoppingCriteria(
+            keywords, self.tokenizer, input_ids
+        )
+
+        # Pass image sizes along with other parameters
+        cont = self.model.generate(
+            input_ids,
+            images=image_tensor,
+            image_sizes=image_sizes,  # Pass the image sizes here
+            do_sample=False,
+            temperature=0,
+            max_new_tokens=2048,
+            stopping_criteria=[stopping_criteria],
+        )
+        text_outputs = self.tokenizer.batch_decode(cont, skip_special_tokens=True)[0]
+        return text_outputs
+
+    def generate_inner_video(self, message, dataset=None):
+        content, text_content, visual_content, videos = "", "", "", []
+
+        for msg in message:
+            if msg["type"] == "text":
+                text_content += msg["value"]
+            else:
+                videos.append(msg["value"])
+                visual_content += self.DEFAULT_IMAGE_TOKEN + "\n"
+
+        if len(videos) > 1:
+            raise ValueError(
+                "LLaVA-OneVision does not support multiple videos as input."
+            )
+
+        video_frames, frame_time, video_time = self.load_video(
+            videos[0], self.nframe, 1, self.force_sample
+        )
+
+        time_instruciton = (
+            f"The video lasts for {video_time:.2f} seconds,"
+            f"and {len(video_frames[0])} frames are uniformly sampled from it."
+            f"These frames are located at {frame_time}."
+            f"Please answer the following questions related to this video.\n"
+        )
+
+        if self.force_sample:
+            content = visual_content + time_instruciton + text_content
+        else:
+            content = visual_content + text_content
+
+        image_tensors = []
+        frames = (
+            self.image_processor.preprocess(video_frames, return_tensors="pt")[
+                "pixel_values"
+            ]
+            .half()
+            .cuda()
+        )
+        image_tensors.append(frames)
+
+        conv = copy.deepcopy(self.conv_templates[self.conv_template])
+        conv.append_message(conv.roles[0], content)
+        conv.append_message(conv.roles[1], None)
+        prompt_question = conv.get_prompt()
+
+        input_ids = self.tokenizer_image_token(
+            prompt_question, self.tokenizer, self.IMAGE_TOKEN_INDEX, return_tensors="pt"
+        )
+        input_ids = input_ids.unsqueeze(0).cuda()
+        image_sizes = [frame.size for frame in video_frames]
+        modalities = ["video"] * len(video_frames)
+
+        stop_str = conv.sep if conv.sep_style != self.SeparatorStyle.TWO else conv.sep2
+        keywords = [stop_str]
+        stopping_criteria = self.KeywordStoppingCriteria(
+            keywords, self.tokenizer, input_ids
+        )
+
+        # Pass image sizes along with other parameters
+        cont = self.model.generate(
+            input_ids,
+            images=image_tensors,
+            image_sizes=image_sizes,  # Pass the image sizes here
+            do_sample=False,
+            temperature=0,
+            max_new_tokens=2048,
+            modalities=modalities,
+            stopping_criteria=[stopping_criteria],
+        )
+        text_outputs = self.tokenizer.batch_decode(cont, skip_special_tokens=True)[0]
+        return text_outputs
+
+    def load_video(self, video_path, max_frames_num, fps=1, force_sample=False):
+        from decord import VideoReader, cpu
+        import numpy as np
+
+        if max_frames_num == 0:
+            return np.zeros((1, 336, 336, 3))
+        vr = VideoReader(video_path, ctx=cpu(0), num_threads=1)
+        total_frame_num = len(vr)
+        video_time = total_frame_num / vr.get_avg_fps()
+        fps = round(vr.get_avg_fps() / fps)
+        frame_idx = [i for i in range(0, len(vr), fps)]
+        frame_time = [i / fps for i in frame_idx]
+        if len(frame_idx) > max_frames_num or force_sample:
+            sample_fps = max_frames_num
+            uniform_sampled_frames = np.linspace(
+                0, total_frame_num - 1, sample_fps, dtype=int
+            )
+            frame_idx = uniform_sampled_frames.tolist()
+            frame_time = [i / vr.get_avg_fps() for i in frame_idx]
+        frame_time = ",".join([f"{i:.2f}s" for i in frame_time])
+        spare_frames = vr.get_batch(frame_idx).asnumpy()
+        # import pdb;pdb.set_trace()
+        return spare_frames, frame_time, video_time
+
+    def generate_inner(self, message, dataset=None):
+        if DATASET_MODALITY(dataset) == 'VIDEO' and 'megabench' not in dataset.lower():
+            return self.generate_inner_video(message, dataset)
+        else:
+            return self.generate_inner_image(message, dataset)
+
+
+class LLaVA_OneVision_HF(BaseModel):
+    INSTALL_REQ = True
+    INTERLEAVE = True
+    VIDEO_LLM = True
+    DEFAULT_IMAGE_TOKEN = "<image>"
+    IMAGE_TOKEN_INDEX = -200
+
+    def __init__(self, model_path="llava-hf/llava-onevision-qwen2-0.5b-ov-hf", **kwargs):
+        from transformers import AutoProcessor, LlavaOnevisionForConditionalGeneration
+        assert model_path is not None, "Model path must be provided."
+        self.model = LlavaOnevisionForConditionalGeneration.from_pretrained(
+            model_path, torch_dtype=torch.float16, low_cpu_mem_usage=True
+        ).to('cuda')
+        self.processor = AutoProcessor.from_pretrained(model_path)
+
+        self.video_kwargs = kwargs.get("video_kwargs", {})
+        self.force_sample = self.video_kwargs.get("force_sample", False)
+        self.nframe = kwargs.get("nframe", 8)
+        self.fps = 1
+        self.model_path = model_path
+
+    def generate_inner_image(self, message, dataset=None):
+        content, images = "", []
+        image_sizes = []
+
+        for msg in message:
+            if msg["type"] == "text":
+                content += msg["value"]
+            elif msg["type"] == "image":
+                img = Image.open(msg["value"]).convert("RGB")
+                images.append(img)
+                image_sizes.append(img.size)
+                content += self.DEFAULT_IMAGE_TOKEN + "\n"
+
+        conversation = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": content},
+                ],
+            }
+        ]
+        prompt = self.processor.apply_chat_template(conversation, add_generation_prompt=True)
+        inputs = self.processor(images=images, text=prompt, return_tensors="pt").to('cuda', torch.float16)
+
+        output = self.model.generate(**inputs, max_new_tokens=2048)
+        return self.processor.decode(output[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)
+
+    def generate_inner_video(self, message, dataset=None):
+        content, text_content, visual_content, videos = "", "", "", []
+
+        for msg in message:
+            if msg["type"] == "text":
+                text_content += msg["value"]
+            elif msg["type"] == "video":
+                videos.append(msg["value"])
+                visual_content += self.DEFAULT_IMAGE_TOKEN + "\n"
+
+        if len(videos) > 1:
+            raise ValueError("LLaVA-OneVision does not support multiple videos as input.")
+
+        video_frames, frame_time, video_time = self.load_video(
+            videos[0], self.nframe, fps=1, force_sample=self.force_sample
+        )
+
+        time_instruction = (
+            f"The video lasts for {video_time:.2f} seconds, "
+            f"and {len(video_frames)} frames are uniformly sampled from it. "
+            f"These frames are located at {frame_time}. "
+            f"Please answer the following questions related to this video.\n"
+        )
+
+        content = visual_content + time_instruction + text_content
+        conversation = [
+            {
+                "role": "user",
+                "content": [{"type": "text", "text": content}, {"type": "video"}],
+            }
+        ]
+        prompt = self.processor.apply_chat_template(conversation, add_generation_prompt=True)
+
+        inputs = self.processor(videos=video_frames, text=prompt, return_tensors="pt").to('cuda', torch.float16)
+        output = self.model.generate(**inputs, max_new_tokens=2048)
+        return self.processor.decode(output[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)
+
+    def load_video(self, video_path, max_frames_num, fps=1, force_sample=False):
+        from decord import VideoReader, cpu
+        import numpy as np
+
+        vr = VideoReader(video_path, ctx=cpu(0), num_threads=1)
+        total_frame_num = len(vr)
+        avg_fps = vr.get_avg_fps()
+
+        if avg_fps == 0:
+            raise ValueError(f"Video '{video_path}' has an average FPS of 0, which is invalid.")
+        if fps <= 0:
+            raise ValueError("FPS argument must be greater than 0.")
+
+        effective_fps = round(avg_fps / fps)
+        frame_idx = list(range(0, total_frame_num, effective_fps))
+        frame_time = [i / avg_fps for i in frame_idx]
+
+        if len(frame_idx) > max_frames_num or force_sample:
+            uniform_sampled_frames = np.linspace(0, total_frame_num - 1, max_frames_num, dtype=int)
+            frame_idx = uniform_sampled_frames.tolist()
+            frame_time = [i / avg_fps for i in frame_idx]
+
+        frame_time_str = ", ".join([f"{t:.2f}s" for t in frame_time])
+        video_frames = vr.get_batch(frame_idx).asnumpy()
+        video_time = total_frame_num / avg_fps
+
+        return video_frames, frame_time_str, video_time
+
+    def generate_inner(self, message, dataset=None):
+        if DATASET_MODALITY(dataset) == "VIDEO" and 'megabench' not in dataset.lower():
+            return self.generate_inner_video(message, dataset)
+        else:
+            return self.generate_inner_image(message, dataset)
diff --git a/VLMEvalKit-sudoku/vlmeval/vlm/llava/llava_xtuner.py b/VLMEvalKit-sudoku/vlmeval/vlm/llava/llava_xtuner.py
new file mode 100644
index 0000000000000000000000000000000000000000..b3897e7b048624d55cc136e6f71c3126e87d904d
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/vlm/llava/llava_xtuner.py
@@ -0,0 +1,241 @@
+import os
+import os.path as osp
+import string
+import sys
+import warnings
+
+import pandas as pd
+import torch
+from huggingface_hub import snapshot_download
+from PIL import Image
+
+from ..base import BaseModel
+from ...smp import *
+from ...dataset import DATASET_TYPE
+
+
+class LLaVA_XTuner(BaseModel):
+
+    INSTALL_REQ = True
+    INTERLEAVE = False
+
+    def __init__(self,
+                 llava_path,
+                 llm_path=None,
+                 visual_encoder_path='openai/clip-vit-large-patch14-336',
+                 visual_select_layer=-2,
+                 prompt_template=None,
+                 stop_words=[],
+                 torch_dtype=torch.float16):
+        try:
+            from peft import PeftModel
+            from xtuner.utils import PROMPT_TEMPLATE, StopWordStoppingCriteria
+        except Exception as err:
+            logging.critical(
+                'Please install xtuner with `pip install -U xtuner` before '
+                'using LLaVA_XTuner')
+            raise err
+
+        from transformers import AutoModel, AutoModelForCausalLM, AutoTokenizer, StoppingCriteriaList  # noqa
+
+        if not osp.isdir(llava_path):
+            cache_path = get_cache_path(llava_path)
+            if cache_path is not None:
+                llava_path = cache_path
+            else:
+                llava_path = snapshot_download(repo_id=llava_path)
+        assert osp.exists(llava_path) and osp.isdir(llava_path)
+
+        # build visual_encoder
+        if 'llm' in os.listdir(llava_path):
+            assert llm_path is None, (
+                "Please don't specify the `llm_path` since passed "
+                '`llava_path` contains a LLM!')
+            llm_path = osp.join(llava_path, 'llm')
+        else:
+            assert llm_path is not None, 'Please specify the `llm_path`!'
+
+        llm = AutoModelForCausalLM.from_pretrained(llm_path,
+                                                   trust_remote_code=True,
+                                                   torch_dtype=torch_dtype,
+                                                   device_map='cpu')
+        tokenizer = AutoTokenizer.from_pretrained(llm_path,
+                                                  trust_remote_code=True,
+                                                  encode_special_tokens=True)
+        print(f'Load LLM from {llm_path}')
+
+        # build visual_encoder
+        if 'visual_encoder' in os.listdir(llava_path):
+            assert visual_encoder_path is None, (
+                "Please don't specify the `visual_encoder_path` since passed "
+                '`llava_path` contains a visual encoder!')
+            visual_encoder_path = osp.join(llava_path, 'visual_encoder')
+        else:
+            assert visual_encoder_path is not None, (
+                'Please specify the `visual_encoder_path`!')
+
+        from transformers import CLIPImageProcessor, CLIPVisionModel
+        visual_encoder = CLIPVisionModel.from_pretrained(
+            visual_encoder_path, torch_dtype=torch_dtype, device_map='cpu')
+        image_processor = CLIPImageProcessor.from_pretrained(
+            visual_encoder_path)
+        print(f'Load visual_encoder from {visual_encoder_path}')
+
+        # load adapter
+        if 'llm_adapter' in os.listdir(llava_path):
+            adapter_path = osp.join(llava_path, 'llm_adapter')
+            llm = PeftModel.from_pretrained(llm,
+                                            adapter_path,
+                                            trust_remote_code=True,
+                                            device_map='cpu')
+            print(f'Load LLM adapter from {llava_path}')
+        if 'visual_encoder_adapter' in os.listdir(llava_path):
+            adapter_path = osp.join(llava_path, 'visual_encoder_adapter')
+            visual_encoder = PeftModel.from_pretrained(visual_encoder,
+                                                       adapter_path,
+                                                       trust_remote_code=True,
+                                                       device_map='cpu')
+            print(f'Load visual_encoder adapter from {llava_path}')
+
+        # build projector
+        projector_path = osp.join(llava_path, 'projector')
+        projector = AutoModel.from_pretrained(projector_path,
+                                              trust_remote_code=True,
+                                              torch_dtype=torch_dtype,
+                                              device_map='cpu')
+        print(f'Load projector from {llava_path}')
+
+        llm.eval()
+        visual_encoder.eval()
+        projector.eval()
+
+        self.llm = llm.cuda()
+        self.tokenizer = tokenizer
+        self.visual_encoder = visual_encoder.cuda()
+        self.image_processor = image_processor
+        self.projector = projector.cuda()
+        self.visual_select_layer = visual_select_layer
+        if prompt_template is not None:
+            # modified prompt template
+            if prompt_template == 'llama3_chat':
+                self.prompt_template = dict(
+                    SYSTEM=('<|start_header_id|>system<|end_header_id|>\n\n'
+                            '{system}<|eot_id|>'),
+                    INSTRUCTION=(
+                        '<|start_header_id|>user<|end_header_id|>\n\n{input}<|eot_id|>'
+                        '<|start_header_id|>assistant<|end_header_id|>\n\n'),
+                    SUFFIX='<|eot_id|>',
+                    SUFFIX_AS_EOS=True,
+                    STOP_WORDS=['<|eot_id|>'])
+            else:
+                self.prompt_template = PROMPT_TEMPLATE[prompt_template]
+            stop_words += self.prompt_template.get('STOP_WORDS', [])
+        else:
+            self.prompt_template = None
+
+        self.stop_criteria = StoppingCriteriaList()
+        for word in stop_words:
+            self.stop_criteria.append(
+                StopWordStoppingCriteria(self.tokenizer, word))
+
+    def build_gen_config(self, dataset):
+        from transformers import GenerationConfig
+        gen_kwargs = dict(max_new_tokens=512,
+                          do_sample=True,
+                          temperature=1,
+                          num_beams=5,
+                          eos_token_id=self.tokenizer.eos_token_id,
+                          pad_token_id=self.tokenizer.pad_token_id
+                          if self.tokenizer.pad_token_id is not None else
+                          self.tokenizer.eos_token_id)
+        # For single word generation
+        if (dataset is not None
+                and DATASET_TYPE(dataset) in ['MCQ', 'Y/N']):
+            gen_kwargs.update(
+                dict(max_new_tokens=5, do_sample=False, num_beams=1))
+        return GenerationConfig(**gen_kwargs)
+
+    def use_custom_prompt(self, dataset):
+        assert dataset is not None
+        if DATASET_TYPE(dataset) == 'MCQ':
+            return True
+        return False
+
+    def build_prompt(self, line, dataset=None):
+        assert self.use_custom_prompt(dataset)
+        assert dataset is None or isinstance(dataset, str)
+        tgt_path = self.dump_image(line, dataset)
+
+        question = line['question']
+        hint = line['hint'] if ('hint' in line
+                                and not pd.isna(line['hint'])) else None
+        if hint is not None:
+            question = hint + '\n' + question
+
+        options = {
+            cand: line[cand]
+            for cand in string.ascii_uppercase
+            if cand in line and not pd.isna(line[cand])
+        }
+        for key, item in options.items():
+            question += f'\n{key}. {item}'
+
+        if not cn_string(question):
+            prompt = question + '\n' + ("Answer with the option's letter "
+                                        'from the given choices directly.')
+        else:
+            prompt = question + '\n' + '请直接回答选项字母。'
+
+        message = [dict(type='text', value=prompt)]
+        message.extend([dict(type='image', value=s) for s in tgt_path])
+        return message
+
+    def generate_inner(self, message, dataset=None):
+        from xtuner.dataset.utils import expand2square
+        from xtuner.model.utils import prepare_inputs_labels_for_multimodal
+        from xtuner.utils import DEFAULT_IMAGE_TOKEN, IMAGE_TOKEN_INDEX
+        prompt, image_path = self.message_to_promptimg(message, dataset=dataset)
+        prompt = prompt.replace('<image>', '')
+        image = Image.open(image_path).convert('RGB')
+        image = expand2square(
+            image,
+            tuple(int(x * 255) for x in self.image_processor.image_mean))
+        image = self.image_processor.preprocess(
+            image, return_tensors='pt')['pixel_values'][0]
+        image = image.cuda().unsqueeze(0)
+        visual_outputs = self.visual_encoder(image, output_hidden_states=True)
+        pixel_values = self.projector(
+            visual_outputs.hidden_states[self.visual_select_layer][:, 1:])
+
+        inputs = DEFAULT_IMAGE_TOKEN + '\n' + prompt
+
+        if self.prompt_template:
+            inputs = self.prompt_template['INSTRUCTION'].format(input=inputs)
+
+        chunk_encode = []
+        for idx, chunk in enumerate(inputs.split(DEFAULT_IMAGE_TOKEN)):
+            if idx == 0:
+                cur_encode = self.tokenizer(chunk)
+            else:
+                cur_encode = self.tokenizer(chunk, add_special_tokens=False)
+            chunk_encode.append(cur_encode)
+        assert len(chunk_encode) == 2
+        ids = []
+        for idx, cur_chunk_encode in enumerate(chunk_encode):
+            ids.extend(cur_chunk_encode['input_ids'])
+            if idx != len(chunk_encode) - 1:
+                ids.append(IMAGE_TOKEN_INDEX)
+        ids = torch.tensor(ids).cuda().unsqueeze(0)
+        mm_inputs = prepare_inputs_labels_for_multimodal(
+            llm=self.llm, input_ids=ids, pixel_values=pixel_values)
+
+        gen_config = self.build_gen_config(dataset)
+        generate_output = self.llm.generate(
+            **mm_inputs,
+            generation_config=gen_config,
+            streamer=None,
+            bos_token_id=self.tokenizer.bos_token_id,
+            stopping_criteria=self.stop_criteria)
+        predict = self.tokenizer.decode(generate_output[0],
+                                        skip_special_tokens=True).strip()
+        return predict
diff --git a/VLMEvalKit-sudoku/vlmeval/vlm/misc/minigptv2_eval.yaml b/VLMEvalKit-sudoku/vlmeval/vlm/misc/minigptv2_eval.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..32815e1b9de21fbfcfc4ea459e95306fd9e42d95
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/vlm/misc/minigptv2_eval.yaml
@@ -0,0 +1,36 @@
+model:
+  arch: minigpt_v2
+  model_type: pretrain
+  max_txt_len: 160
+  end_sym: "</s>"
+  low_resource: True
+  prompt_template: '[INST] {} [/INST]'
+  ckpt: "please set this value to the path of pretrained checkpoint"
+  lora_r: 64
+  lora_alpha: 16
+
+  # vit encoder
+  image_size: 448
+  drop_path_rate: 0
+  use_grad_checkpoint: False
+  vit_precision: "fp16"
+  freeze_vit: True
+
+  # generation configs
+  prompt: ""
+
+  # LLM
+  llama_model: "please set this value to the path of llama2-chat-7b"
+
+datasets:
+  cc_sbu_align:
+    vis_processor:
+      train:
+        name: "blip2_image_eval"
+        image_size: 448
+    text_processor:
+      train:
+        name: "blip_caption"
+
+run:
+  task: image_text_pretrain
diff --git a/VLMEvalKit-sudoku/vlmeval/vlm/ola/__init__.py b/VLMEvalKit-sudoku/vlmeval/vlm/ola/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4d18f2e981ee64b83dc7dc51e278724c4c5e8222
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/vlm/ola/__init__.py
@@ -0,0 +1 @@
+from .ola_model import Ola
diff --git a/VLMEvalKit-sudoku/vlmeval/vlm/ola/ola_model.py b/VLMEvalKit-sudoku/vlmeval/vlm/ola/ola_model.py
new file mode 100644
index 0000000000000000000000000000000000000000..7a1e6be44fa765bdaea8bf55892dd33829eada64
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/vlm/ola/ola_model.py
@@ -0,0 +1,172 @@
+import torch
+from PIL import Image
+from abc import abstractproperty
+import sys
+import os.path as osp
+from ..base import BaseModel
+from ...smp import *
+from ...dataset import DATASET_TYPE
+import os
+
+from transformers import CLIPImageProcessor
+
+os.environ['LOWRES_RESIZE']="384x32"
+os.environ['HIGHRES_BASE']="0x32"
+os.environ['MAXRES']="1536"
+os.environ['MINRES']="0"
+os.environ['SIMPLE_ARCH']="1"
+os.environ['PAD2STRIDE']="1"
+os.environ['REGIONAL_POOL']='2x'
+os.environ['FORCE_NO_DOWNSAMPLE']="1"
+os.environ['LOAD_VISION_EARLY']="1"
+os.environ['SKIP_LOAD_VIT']="1"
+
+class Ola(BaseModel):
+
+    INSTALL_REQ = True
+    INTERLEAVE = True
+
+    def __init__(self,
+                 model_path='liuhaotian/llava_v1.5_7b',
+                 **kwargs):
+
+        from .ola.model.builder import load_pretrained_model
+        from .ola.mm_utils import get_model_name_from_path
+
+        assert osp.exists(model_path) or splitlen(model_path) == 2
+
+        model_name = get_model_name_from_path(model_path)
+
+        self.tokenizer, self.model, self.image_processor, self.context_len = load_pretrained_model(
+            model_path=model_path,
+            model_base=None,
+            use_flash_attn=True,
+        )
+
+        if self.image_processor is None:
+            self.image_processor = CLIPImageProcessor.from_pretrained("openai/clip-vit-large-patch14")
+            print('Using default image processor. ')
+
+        self._config = self.model.config
+
+
+        self.model = self.model.cuda()
+        self.conv_mode = 'v1_qwen2'
+
+        self.device = torch.device('cuda')
+
+        kwargs_default = dict(do_sample=False, temperature=0, max_new_tokens=512, top_p=None, num_beams=1, use_cache=True) # noqa E501
+        kwargs_default.update(kwargs)
+        self.kwargs = kwargs_default
+        warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ')
+
+    def use_custom_prompt(self, dataset):
+        assert dataset is not None
+        if DATASET_TYPE(dataset) == 'multi-choice':
+            return True
+        return False
+
+    def build_prompt(self, line, dataset=None):
+        assert self.use_custom_prompt(dataset)
+        assert dataset is None or isinstance(dataset, str)
+        tgt_path = self.dump_image(line, dataset)
+
+        question = line['question']
+        hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+        if hint is not None:
+            question = hint + '\n' + question
+
+        options = {
+            cand: line[cand]
+            for cand in string.ascii_uppercase
+            if cand in line and not pd.isna(line[cand])
+        }
+        for key, item in options.items():
+            question += f'\n{key}. {item}'
+        prompt = question
+
+        if len(options):
+            prompt += '\nAnswer with the option letter from the given choices directly.'
+        else:
+            prompt += '\nAnswer the question using a single word or phrase.'
+
+        message = [dict(type='image', value=s) for s in tgt_path]
+        message.append(dict(type='text', value=prompt))
+        return message
+
+    def generate_inner(self, message, dataset=None):
+        from .ola.mm_utils import process_anyres_highres_image_genli, KeywordsStoppingCriteria
+        from .ola.constants import (
+            IMAGE_TOKEN_INDEX, DEFAULT_IMAGE_TOKEN, DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN)
+        from .ola.conversation import conv_templates, SeparatorStyle
+        from .ola.datasets.preprocess import tokenizer_image_token
+
+        # Support interleave text and image
+        conv = conv_templates[self.conv_mode].copy()
+        conv.append_message(conv.roles[0], 'PLACEHOLDER')
+        conv.append_message(conv.roles[1], None)
+        prompt = conv.get_prompt()
+
+        content, images = '', []
+        for msg in message:
+            if msg['type'] == 'text':
+                content += msg['value']
+            elif msg['type'] == 'image':
+                if 'MMVet' in msg['value'] or 'MMMU' in msg['value']:
+                    os.environ['USE_HIGHRES_ONLY'] = '1'
+                if self.model.config.mm_use_im_start_end:
+                    content += DEFAULT_IM_START_TOKEN + DEFAULT_IMAGE_TOKEN + DEFAULT_IM_END_TOKEN + '\n'
+                else:
+                    content += DEFAULT_IMAGE_TOKEN + '\n'
+                images.append(msg['value'])
+
+        images = [Image.open(s).convert('RGB') for s in images]
+        image_sizes = [img.size for img in images]
+        # args = abstractproperty()
+        # args.image_aspect_ratio = 'pad'
+        self.image_processor.do_resize = False
+        self.image_processor.do_center_crop = False
+        image_tensor, image_highres_tensor = [], []
+        for visual in images:
+            image_tensor_, image_highres_tensor_ = process_anyres_highres_image_genli(visual, self.image_processor)
+            image_tensor.append(image_tensor_)
+            image_highres_tensor.append(image_highres_tensor_)
+        if type(image_tensor) is list:
+            image_tensor = [_image.bfloat16().to("cuda") for _image in image_tensor]
+        else:
+            image_tensor = image_tensor.bfloat16().to("cuda")
+        if type(image_highres_tensor) is list:
+            image_highres_tensor = [_image.bfloat16().to("cuda") for _image in image_highres_tensor]
+        else:
+            image_highres_tensor = image_highres_tensor.bfloat16().to("cuda")
+        prompt = prompt.replace('PLACEHOLDER', content)
+
+        input_ids = tokenizer_image_token(
+            prompt, self.tokenizer, IMAGE_TOKEN_INDEX, return_tensors='pt').unsqueeze(0).cuda()
+        stop_str = '<|im_end|>'
+        keywords = [stop_str]
+        stopping_criteria = KeywordsStoppingCriteria(keywords, self.tokenizer, input_ids)
+
+        pad_token_ids = self.tokenizer.pad_token_id if self.tokenizer.pad_token_id is not None else self.tokenizer.eos_token_id
+        attention_masks = input_ids.ne(pad_token_ids).to(self.device)
+
+        speechs = [torch.zeros(1, 3000, 128).bfloat16().to('cuda')]
+        speech_lengths = [torch.LongTensor([3000]).to('cuda')]
+        speech_wavs = [torch.zeros([1, 480000]).to('cuda')]
+        speech_chunks = [torch.LongTensor([1]).to('cuda')]
+
+        with torch.inference_mode():
+            output_ids = self.model.generate(
+                input_ids, images=image_tensor, images_highres=image_highres_tensor, image_sizes=image_sizes,
+                modalities=['image'] * len(image_tensor),
+                speech=speechs,
+                speech_lengths=speech_lengths,
+                speech_chunks=speech_chunks,
+                speech_wav=speech_wavs,
+                attention_mask=attention_masks,
+                pad_token_id=pad_token_ids,
+                stopping_criteria=[stopping_criteria], **self.kwargs)
+
+        output = self.tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0].strip()
+        print(content, output)
+        return output
diff --git a/VLMEvalKit-sudoku/vlmeval/vlm/ovis/__init__.py b/VLMEvalKit-sudoku/vlmeval/vlm/ovis/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2bda2ba7520a0d83768713c624343742baf75bbc
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/vlm/ovis/__init__.py
@@ -0,0 +1,3 @@
+from .ovis import Ovis, Ovis1_6, Ovis1_6_Plus, Ovis2, OvisU1
+
+__all__ = ['Ovis', 'Ovis1_6', 'Ovis1_6_Plus', 'Ovis2', 'OvisU1']
diff --git a/VLMEvalKit-sudoku/vlmeval/vlm/qwen2_vl/__init__.py b/VLMEvalKit-sudoku/vlmeval/vlm/qwen2_vl/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..9a82e45c3165a78f7c5ad27dc07fd591a1d00d38
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/vlm/qwen2_vl/__init__.py
@@ -0,0 +1,2 @@
+from .model import Qwen2VLChat, Qwen2VLChatAguvis
+from .prompt import Qwen2VLPromptMixin
diff --git a/VLMEvalKit-sudoku/vlmeval/vlm/qwen2_vl/model.py b/VLMEvalKit-sudoku/vlmeval/vlm/qwen2_vl/model.py
new file mode 100644
index 0000000000000000000000000000000000000000..d902b628bd5d209ece00d46abe38015a86e8f69f
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/vlm/qwen2_vl/model.py
@@ -0,0 +1,738 @@
+from __future__ import annotations
+
+import os
+import sys
+import warnings
+import math
+import logging
+
+import torch
+from transformers import StoppingCriteria
+
+from ..base import BaseModel
+from .prompt import Qwen2VLPromptMixin
+from ...smp import get_gpu_memory, listinstr
+from ...dataset import DATASET_MODALITY
+
+VLLM_MAX_IMAGE_INPUT_NUM = 24
+
+
+def ensure_image_url(image: str) -> str:
+    prefixes = ['http://', 'https://', 'file://', 'data:image;']
+    if any(image.startswith(prefix) for prefix in prefixes):
+        return image
+    if os.path.exists(image):
+        return 'file://' + image
+    raise ValueError(f'Invalid image: {image}')
+
+
+def ensure_video_url(video: str) -> str:
+    prefixes = ['http://', 'https://', 'file://', 'data:video;']
+    if any(video.startswith(prefix) for prefix in prefixes):
+        return video
+    if os.path.exists(video):
+        return 'file://' + video
+    raise ValueError(f'Invalid video: {video}')
+
+
+def create_image_content(image_path, min_pixels, max_pixels):
+    base64_image, mime_type = encode_image(image_path)
+    return {
+        "type": "image",
+        "image": f"data:{mime_type};base64,{base64_image}",
+        'min_pixels': min_pixels,
+        'max_pixels': max_pixels
+    }
+
+
+def encode_image(image_path, max_side=None):
+    from mimetypes import guess_type
+    mime_type, _ = guess_type(image_path)
+    if mime_type is None:
+        mime_type = "image/jpeg"
+    image_format = mime_type.split("/")[-1].upper() if mime_type else "JPEG"
+
+    from PIL import Image
+    image = Image.open(image_path)
+    # Handle the alpha channel
+    if image.mode == "RGBA":
+        image = _rgba_to_rgb(image)
+    if max_side:
+        image = _resize_image(image, max_side)
+    encoded_image = _encode_image(image, image_format)
+
+    return encoded_image, mime_type
+
+
+def _encode_image(image, image_format):
+    from io import BytesIO
+    with BytesIO() as output:
+        image.convert("RGB").save(output, format=image_format)
+        import base64
+        base64_encoded_data = base64.b64encode(output.getvalue()).decode("utf-8")
+    return base64_encoded_data
+
+
+def _rgba_to_rgb(image):
+    from PIL import Image
+    background = Image.new("RGBA", image.size, (255, 255, 255, 255))
+    return Image.alpha_composite(background, image).convert("RGB")
+
+
+def _resize_image(image, max_side):
+    resize_scale = max_side / max(image.size)
+    new_size = (
+        int(image.size[0] * resize_scale),
+        int(image.size[1] * resize_scale),
+    )
+    return image.resize(new_size)
+
+
+def process_video(video_path, num_frames, min_pixels, max_pixels):
+    import cv2
+    # Open the video file
+    cap = cv2.VideoCapture(video_path)
+    frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    fps = cap.get(cv2.CAP_PROP_FPS)  # Frames per second
+
+    # the sampling rate using max number of frames
+    sampling_gap_maxframe = (
+        1 if not num_frames else math.ceil(frame_count / num_frames)
+    )
+    sampling_gap = max(math.ceil(fps / 5), sampling_gap_maxframe)
+
+    frame_number = 0
+    images = []
+
+    while True:
+        import tempfile
+        success, frame = cap.read()
+        if not success:
+            break
+        # Sample frames based on the dynamic sampling rate
+        if frame_number % sampling_gap == 0:
+            # Create a temporary file for the frame
+            with tempfile.NamedTemporaryFile(
+                suffix=".jpg", delete=False
+            ) as temp_frame:
+                cv2.imwrite(temp_frame.name, frame)
+                images.append(create_image_content(temp_frame.name, min_pixels, max_pixels))
+                os.remove(temp_frame.name)
+        frame_number += 1
+    if frame_number == 0:
+        raise ValueError(f"Failed to read video from {video_path}, check data...")
+    logging.info(
+        f"Sampled {len(images)}/{frame_number} frames from video {video_path}"
+    )
+    cap.release()
+    return images
+
+
+class KeywordsStoppingCriteria(StoppingCriteria):
+    def __init__(self, keywords, tokenizer, input_ids):
+        self.keywords = keywords
+        self.keyword_ids = []
+        self.max_keyword_len = 0
+        for keyword in keywords:
+            cur_keyword_ids = tokenizer(keyword).input_ids
+            if (
+                len(cur_keyword_ids) > 1
+                and cur_keyword_ids[0] == tokenizer.bos_token_id
+            ):
+                cur_keyword_ids = cur_keyword_ids[1:]
+            if len(cur_keyword_ids) > self.max_keyword_len:
+                self.max_keyword_len = len(cur_keyword_ids)
+            self.keyword_ids.append(torch.tensor(cur_keyword_ids))
+        self.tokenizer = tokenizer
+        self.start_len = input_ids.shape[1]
+
+    def __call__(
+        self, output_ids: torch.LongTensor, scores: torch.FloatTensor, **kwargs
+    ) -> bool:
+        assert output_ids.shape[0] == 1, "Only support batch size 1 (yet)"  # TODO
+        offset = min(output_ids.shape[1] - self.start_len, self.max_keyword_len)
+        self.keyword_ids = [
+            keyword_id.to(output_ids.device) for keyword_id in self.keyword_ids
+        ]
+        for keyword_id in self.keyword_ids:
+            if (output_ids[0, -keyword_id.shape[0]:] == keyword_id).all():
+                return True
+        outputs = self.tokenizer.batch_decode(
+            output_ids[:, -offset:], skip_special_tokens=True
+        )[0]
+        for keyword in self.keywords:
+            if keyword in outputs:
+                return True
+        return False
+
+
+CHAT_TEMPLATE = "{% set image_count = namespace(value=0) %}{% set video_count = namespace(value=0) %}{% for message in messages %}<|im_start|>{{ message['role'] }}\n{% if message['content'] is string %}{{ message['content'] }}<|im_end|>\n{% else %}{% for content in message['content'] %}{% if content['type'] == 'image' or 'image' in content or 'image_url' in content %}{% set image_count.value = image_count.value + 1 %}{% if add_vision_id %}Picture {{ image_count.value }}: {% endif %}<|vision_start|><|image_pad|><|vision_end|>{% elif content['type'] == 'video' or 'video' in content %}{% set video_count.value = video_count.value + 1 %}{% if add_vision_id %}Video {{ video_count.value }}: {% endif %}<|vision_start|><|video_pad|><|vision_end|>{% elif 'text' in content %}{{ content['text'] }}{% endif %}{% endfor %}<|im_end|>\n{% endif %}{% endfor %}{% if add_generation_prompt %}<|im_start|>assistant\n{% endif %}"  # noqa: E501
+
+UNTIL = ["<|diff_marker|>"]
+
+
+class Qwen2VLChat(Qwen2VLPromptMixin, BaseModel):
+    INSTALL_REQ = False
+    INTERLEAVE = True
+    VIDEO_LLM = True
+
+    def __init__(
+        self,
+        model_path: str,
+        min_pixels: int | None = None,
+        max_pixels: int | None = None,
+        total_pixels: int | None = None,
+        max_new_tokens=2048,
+        top_p=0.001,
+        top_k=1,
+        temperature=0.01,
+        repetition_penalty=1.0,
+        use_custom_prompt: bool = True,
+        system_prompt: str | None = None,
+        post_process: bool = False,  # if True, will try to only extract stuff in the last \boxed{}.
+        verbose: bool = False,
+        use_audio_in_video: bool = False,
+        **kwargs,
+    ):
+        super().__init__(use_custom_prompt=use_custom_prompt)
+        self.min_pixels = min_pixels
+        self.max_pixels = max_pixels
+        self.total_pixels = total_pixels
+        self.max_new_tokens = max_new_tokens
+        if self.total_pixels and self.total_pixels > 24576 * 28 * 28:
+            print('The total number of video tokens might become too large, resulting in an overly long input sequence. We recommend lowering **total_pixels** to below **24576 × 28 × 28**.')  # noqa: E501
+        self.generate_kwargs = dict(
+            max_new_tokens=self.max_new_tokens,
+            top_p=top_p,
+            top_k=top_k,
+            temperature=temperature,
+            repetition_penalty=repetition_penalty,
+        )
+        self.system_prompt = system_prompt
+        self.verbose = verbose
+        self.post_process = post_process
+        self.fps = kwargs.pop('fps', 2)
+        self.nframe = kwargs.pop('nframe', 128)
+        if self.fps is None and self.nframe is None:
+            print("Warning: fps and nframe are both None, \
+                  using default nframe/fps setting in qwen-vl-utils/qwen-omni-utils, \
+                  the fps/nframe setting in video dataset is omitted")
+        self.use_audio_in_video = use_audio_in_video
+        self.FRAME_FACTOR = 2
+        assert model_path is not None
+        self.model_path = model_path
+        MODEL_CLS = None
+
+        if listinstr(['omni'], model_path.lower()):
+            try:
+                from transformers import Qwen2_5OmniForConditionalGeneration, Qwen2_5OmniProcessor
+            except Exception as err:
+                logging.critical("pip install git+https://github.com/huggingface/transformers@3a1ead0aabed473eafe527915eea8c197d424356")  # noqa: E501
+                raise err
+            MODEL_CLS = Qwen2_5OmniForConditionalGeneration
+            self.processor = Qwen2_5OmniProcessor.from_pretrained(model_path)
+        elif listinstr(['2.5', '2_5', 'qwen25', 'mimo'], model_path.lower()):
+            from transformers import Qwen2_5_VLForConditionalGeneration, AutoProcessor
+            MODEL_CLS = Qwen2_5_VLForConditionalGeneration
+            self.processor = AutoProcessor.from_pretrained(model_path)
+        else:
+            from transformers import Qwen2VLForConditionalGeneration, Qwen2VLProcessor
+            MODEL_CLS = Qwen2VLForConditionalGeneration
+            self.processor = Qwen2VLProcessor.from_pretrained(model_path)
+
+        gpu_mems = get_gpu_memory()
+        max_gpu_mem = max(gpu_mems) if gpu_mems != [] else -1
+        assert max_gpu_mem > 0
+        self.use_vllm = kwargs.get('use_vllm', False)
+        self.use_lmdeploy = kwargs.get('use_lmdeploy', False)
+        self.limit_mm_per_prompt = VLLM_MAX_IMAGE_INPUT_NUM
+        assert self.use_vllm + self.use_lmdeploy <= 1, "You can only set one flag between `use_vllm` and `use_lmdeploy` to True"  # noqa: E501
+
+        if self.use_vllm:
+            from vllm import LLM
+            gpu_count = torch.cuda.device_count()
+            if gpu_count >= 8:
+                tp_size = 8
+            elif gpu_count >= 4:
+                tp_size = 4
+            elif gpu_count >= 2:
+                tp_size = 2
+            else:
+                tp_size = 1
+            logging.info(
+                f'Using vLLM for {self.model_path} inference with {tp_size} GPUs (available: {gpu_count})'
+            )
+            import os
+            if os.environ.get('VLLM_WORKER_MULTIPROC_METHOD') != 'spawn':
+                logging.warning(
+                    'VLLM_WORKER_MULTIPROC_METHOD is not set to spawn.'
+                    'Use \'export VLLM_WORKER_MULTIPROC_METHOD=spawn\' to avoid potential multi-process issues'
+                )
+            self.llm = LLM(
+                model=self.model_path,
+                max_num_seqs=5,
+                max_model_len=32768,
+                limit_mm_per_prompt={"image": self.limit_mm_per_prompt},
+                tensor_parallel_size=tp_size,
+                gpu_memory_utilization=kwargs.get("gpu_utils", 0.9),
+            )
+
+        elif self.use_lmdeploy:
+            from lmdeploy import TurbomindEngineConfig, pipeline, ChatTemplateConfig
+            num_gpus = torch.cuda.device_count()
+            self.model = pipeline(
+                model_path,
+                backend_config=TurbomindEngineConfig(session_len=32768, cache_max_entry_count=0.1, tp=num_gpus),
+                chat_template_config=ChatTemplateConfig(model_name='qwen2d5-vl'))
+            torch.cuda.set_device(0)
+            self.device = 'cuda'
+        else:
+            self.model = MODEL_CLS.from_pretrained(
+                model_path, torch_dtype='auto', device_map="auto", attn_implementation='flash_attention_2'
+            )
+            self.model.eval()
+
+        torch.cuda.empty_cache()
+
+    def _prepare_content(self, inputs: list[dict[str, str]], dataset: str | None = None) -> list[dict[str, str]]:
+        """
+        inputs list[dict[str, str]], each dict has keys: ['type', 'value']
+        """
+        content = []
+        for s in inputs:
+            if s['type'] == 'image':
+                item = {'type': 'image', 'image': ensure_image_url(s['value'])}
+                if dataset == 'OCRBench':
+                    item['min_pixels'] = 10 * 10 * 28 * 28
+                    warnings.warn(f"OCRBench dataset uses custom min_pixels={item['min_pixels']}")
+                    if self.max_pixels is not None:
+                        item['max_pixels'] = self.max_pixels
+                else:
+                    if self.min_pixels is not None:
+                        item['min_pixels'] = self.min_pixels
+                    if self.max_pixels is not None:
+                        item['max_pixels'] = self.max_pixels
+                if self.total_pixels is not None:
+                    item['total_pixels'] = self.total_pixels
+            elif s['type'] == 'video':
+                item = {
+                    'type': 'video',
+                    'video': ensure_video_url(s['value'])
+                }
+                if self.min_pixels is not None:
+                    item['min_pixels'] = self.min_pixels
+                if self.max_pixels is not None:
+                    item['max_pixels'] = self.max_pixels
+                if self.total_pixels is not None:
+                    item['total_pixels'] = self.total_pixels
+                if self.fps is not None:
+                    item['fps'] = self.fps
+                elif self.nframe is not None:
+                    import cv2
+                    video = cv2.VideoCapture(s['value'])
+                    frame_count = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
+                    video.release()
+                    if frame_count < self.nframe:
+                        new_frame_count = frame_count // self.FRAME_FACTOR * self.FRAME_FACTOR
+                        print(f"use {new_frame_count} for {s['value']}")
+                        item['nframes'] = new_frame_count
+                    else:
+                        item['nframes'] = self.nframe
+            elif s['type'] == 'text':
+                item = {'type': 'text', 'text': s['value']}
+            elif s['type'] == 'audio':
+                item = {'type':'audio','audio':s['value']}
+            else:
+                raise ValueError(f"Invalid message type: {s['type']}, {s}")
+            content.append(item)
+        return content
+
+    def _prepare_content_vllm(self, inputs: list[dict[str, str]], dataset: str | None = None) -> list[dict[str, str]]:
+        """
+        inputs list[dict[str, str]], each dict has keys: ['type', 'value']
+        """
+        content = []
+        video_inputs = [s for s in inputs if s['type'] == 'video']
+        video_count = len(video_inputs)
+        cur_image_count = 0
+        for s in inputs:
+            if s['type'] == 'image':
+                item = {'type': 'image', 'image': ensure_image_url(s['value'])}
+                if dataset == 'OCRBench':
+                    item['min_pixels'] = 10 * 10 * 28 * 28
+                    warnings.warn(f"OCRBench dataset uses custom min_pixels={item['min_pixels']}")
+                    if self.max_pixels is not None:
+                        item['max_pixels'] = self.max_pixels
+                else:
+                    if self.min_pixels is not None:
+                        item['min_pixels'] = self.min_pixels
+                    if self.max_pixels is not None:
+                        item['max_pixels'] = self.max_pixels
+                if self.total_pixels is not None:
+                    item['total_pixels'] = self.total_pixels
+                if cur_image_count < self.limit_mm_per_prompt:
+                    content.append(item)
+                    cur_image_count += 1
+                else:
+                    logging.warning(
+                        f"Number of images exceeds the limit of {self.limit_mm_per_prompt}. "
+                        f"Only the first {self.limit_mm_per_prompt} images will be used."
+                    )
+            elif s['type'] == 'video':
+                if video_count > 1:
+                    logging.warning(
+                        "Multiple videos detected. Using video frames for each video"
+                    )
+                    if dataset == 'OCRBench':
+                        min_pixels = 10 * 10 * 28 * 28
+                        warnings.warn(f"OCRBench dataset uses custom min_pixels={min_pixels}")
+                        if self.max_pixels is not None:
+                            max_pixels = self.max_pixels
+                    else:
+                        if self.min_pixels is not None:
+                            min_pixels = self.min_pixels
+                        if self.max_pixels is not None:
+                            max_pixels = self.max_pixels
+                    import cv2
+                    video = cv2.VideoCapture(s['value'])
+                    frame_count = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
+                    video.release()
+
+                    frames_per_video = max(1, self.limit_mm_per_prompt // video_count)
+                    content.append({"type": "text", "text": "<video frames start>"})
+                    content.extend(process_video(s['value'], frames_per_video, min_pixels, max_pixels))
+                    content.append({"type": "text", "text": "<video frames end>"})
+
+                else:
+                    item = {
+                        'type': 'video',
+                        'video': ensure_video_url(s['value'])
+                    }
+                    if self.min_pixels is not None:
+                        item['min_pixels'] = self.min_pixels
+                    if self.max_pixels is not None:
+                        item['max_pixels'] = self.max_pixels
+                    if self.total_pixels is not None:
+                        item['total_pixels'] = self.total_pixels
+                    if self.fps is not None:
+                        item['fps'] = self.fps
+                    elif self.nframe is not None:
+                        import cv2
+                        video = cv2.VideoCapture(s['value'])
+                        frame_count = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
+                        video.release()
+                        if frame_count < self.nframe:
+                            new_frame_count = frame_count // self.FRAME_FACTOR * self.FRAME_FACTOR
+                            print(f"use {new_frame_count} for {s['value']}")
+                            item['nframes'] = new_frame_count
+                        else:
+                            item['nframes'] = self.nframe
+                    content.append(item)
+            elif s['type'] == 'text':
+                item = {'type': 'text', 'text': s['value']}
+                content.append(item)
+            else:
+                raise ValueError(f"Invalid message type: {s['type']}, {s}")
+        return content
+
+    def generate_inner_transformers(self, message, dataset=None):
+        if listinstr(['omni'], self.model_path.lower()):
+            try:
+                from qwen_omni_utils import process_mm_info
+            except Exception as err:
+                logging.critical("qwen_omni_utils not found, please install it via 'pip install qwen-omni-utils[decord]'")  # noqa: E501
+                raise err
+        else:
+            try:
+                from qwen_vl_utils import process_vision_info
+            except Exception as err:
+                logging.critical("qwen_vl_utils not found, please install it via 'pip install qwen-vl-utils'")  # noqa: E501
+                raise err
+
+        messages = []
+        if self.system_prompt is not None:
+            messages.append({'role': 'system', 'content': self.system_prompt})
+        messages.append({'role': 'user', 'content': self._prepare_content(message, dataset=dataset)})
+        if self.verbose:
+            print(f'\033[31m{messages}\033[0m')
+
+        text = self.processor.apply_chat_template([messages], tokenize=False, add_generation_prompt=True)
+        if listinstr(['omni'], self.model_path.lower()):
+            audios, images, videos = process_mm_info([messages], use_audio_in_video=self.use_audio_in_video)
+            inputs = self.processor(text=text, images=images,audio=audios, videos=videos, padding=True, return_tensors='pt',use_audio_in_video=self.use_audio_in_video)  # noqa: E501
+        else:
+            images, videos = process_vision_info([messages])
+            inputs = self.processor(text=text, images=images, videos=videos, padding=True, return_tensors='pt')  # noqa: E501
+        inputs = inputs.to('cuda')
+
+        if listinstr(['omni'], self.model_path.lower()):
+            self.generate_kwargs['use_audio_in_video'] = self.use_audio_in_video
+            self.generate_kwargs['return_audio'] = False
+        generated_ids = self.model.generate(
+            **inputs,
+            **self.generate_kwargs,
+        )
+        generated_ids = [
+            output_ids[len(input_ids):] for input_ids, output_ids in zip(inputs.input_ids, generated_ids)
+        ]
+        out = self.processor.tokenizer.batch_decode(
+            generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False
+        )
+        response = out[0]
+        if self.post_process:
+            resp = response.split('\\boxed{')[-1]
+            lt = len(resp)
+            counter, end = 1, None
+            for i in range(lt):
+                if resp[i] == '{':
+                    counter += 1
+                elif resp[i] == '}':
+                    counter -= 1
+                if counter == 0:
+                    end = i
+                    break
+                elif i == lt - 1:
+                    end = lt
+                    break
+            if end is not None:
+                response = resp[:end]
+
+        if self.verbose:
+            print(f'\033[32m{response}\033[0m')
+        return response
+
+    def generate_inner_lmdeploy(self, message, dataset=None):
+        from lmdeploy import GenerationConfig
+        gen_config = GenerationConfig(
+            max_new_tokens=self.max_new_tokens,
+            top_p=self.generate_kwargs['top_p'],
+            top_k=self.generate_kwargs['top_k'],
+            temperature=self.generate_kwargs['temperature'],
+            repetition_penalty=self.generate_kwargs['repetition_penalty'],
+        )
+        gen_config.random_seed = None
+        messages_list = self.message_to_lmdeploy(message, system_prompt=self.system_prompt)
+        assert len(messages_list) == 1
+        response = self.model(messages_list, gen_config=gen_config)[0]
+        response = response.text
+        return response
+
+    def generate_inner_vllm(self, message, dataset=None):
+        from vllm import SamplingParams
+
+        if listinstr(['omni'], self.model_path.lower()):
+            try:
+                from qwen_omni_utils import process_mm_info
+            except Exception as err:
+                logging.critical("qwen_omni_utils not found, please install it via 'pip install qwen-omni-utils[decord]'")  # noqa: E501
+                raise err
+        else:
+            try:
+                from qwen_vl_utils import process_vision_info
+            except Exception as err:
+                logging.critical("qwen_vl_utils not found, please install it via 'pip install qwen-vl-utils'")  # noqa: E501
+                raise err
+
+        messages = []
+        if self.system_prompt is not None:
+            messages.append({'role': 'system', 'content': self.system_prompt})
+        messages.append({'role': 'user', 'content': self._prepare_content_vllm(message, dataset=dataset)})
+        if self.verbose:
+            print(f'\033[31m{messages}\033[0m')
+
+        text = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+        if listinstr(['omni'], self.model_path.lower()):
+            audios, images, videos = process_mm_info(messages, use_audio_in_video=self.use_audio_in_video)
+        else:
+            images, videos = process_vision_info(messages)
+        print('finishing process vision info in vllm.')
+
+        if DATASET_MODALITY(dataset) == 'VIDEO' and 'megabench' not in dataset.lower():
+            assert len(videos) == 1
+            videos_nd = [videos[0].detach().cpu().numpy().transpose(0, 2, 3, 1)]
+
+            video_inputs = {
+                "prompt": text[0],
+                "multi_modal_data": {"video": videos_nd[0]},
+                "mm_processor_kwargs":{}
+            }
+            if self.use_audio_in_video:
+                import vllm
+                assert not vllm.envs.VLLM_USE_V1, ("V1 does not support use_audio_in_video. Please launch this example with `VLLM_USE_V1=0`.")  # noqa: E501
+                video_inputs["multi_modal_data"]["audio"] = audios[0]
+                video_inputs['mm_processor_kwargs']['use_audio_in_video'] = True
+            if videos_nd[0].shape[0] > VLLM_MAX_IMAGE_INPUT_NUM:
+                print('video input sequence may be too long for vllm, Maybe cannot generate response for VLLM')
+        sampling_params = SamplingParams(
+            temperature=0.0, max_tokens=self.max_new_tokens, stop_token_ids=None
+        )
+        if images:
+            outputs = self.llm.generate(
+                {
+                    "prompt": text,
+                    "multi_modal_data": {"image": images},
+                },
+                sampling_params=sampling_params,
+            )
+        elif videos_nd:
+            outputs = self.llm.generate(
+                video_inputs,
+                sampling_params=sampling_params,
+            )
+        else:
+            outputs = self.llm.generate(
+                {
+                    "prompt": text,
+                },
+                sampling_params=sampling_params,
+            )
+
+        for o in outputs:
+            generated_text = o.outputs[0].text
+
+        if self.post_process:
+            resp = generated_text.split('\\boxed{')[-1]
+            lt = len(resp)
+            counter, end = 1, None
+            for i in range(lt):
+                if resp[i] == '{':
+                    counter += 1
+                elif resp[i] == '}':
+                    counter -= 1
+                if counter == 0:
+                    end = i
+                    break
+                elif i == lt - 1:
+                    end = lt
+                    break
+            if end is not None:
+                generated_text = resp[:end]
+
+        if self.verbose:
+            print(f'\033[32m{generated_text}\033[0m')
+        return generated_text
+
+    def generate_inner(self, message, dataset=None):
+        if self.use_vllm:
+            return self.generate_inner_vllm(message, dataset=dataset)
+        elif self.use_lmdeploy:
+            return self.generate_inner_lmdeploy(message, dataset=dataset)
+        else:
+            return self.generate_inner_transformers(message, dataset=dataset)
+
+
+class Qwen2VLChatAguvis(Qwen2VLChat):
+    def __init__(self, mode=None, **kwargs):
+        self.mode = mode
+        super().__init__(**kwargs)
+        self.processor.max_pixels = self.max_pixels
+        self.processor.min_pixels = self.min_pixels
+
+    def generate_inner(self, message, dataset=None):
+        try:
+            from qwen_vl_utils import process_vision_info
+        except Exception as err:
+            logging.critical(
+                "qwen_vl_utils not found, please install it via 'pip install qwen-vl-utils'"
+            )
+            raise err
+
+        messages = []
+        user_message = []
+        for item in message:
+            if "role" in item.keys():
+                if item["role"] == "system":
+                    self.system_prompt = item["value"]
+                else:
+                    item.pop("role")
+                    user_message.append(item)
+            else:
+                user_message.append(item)
+        message = user_message
+
+        if self.system_prompt is not None:
+            messages.append({"role": "system", "content": self.system_prompt})
+        messages.append(
+            {"role": "user", "content": self._prepare_content(message, dataset=dataset)}
+        )
+        if self.verbose:
+            print(f"\033[31m{messages}\033[0m")
+
+        text = self.processor.apply_chat_template(
+            messages,
+            tokenize=False,
+            add_generation_prompt=False,
+            chat_template=CHAT_TEMPLATE,
+        )
+        # TODO: provide current action's low-level instruction
+        # if False:
+        #     # If low-level instruction is provided
+        #     # We enforce using "Action: {low_level_instruction} to guide generation"
+        #     recipient_text = f"<|im_start|>assistant<|recipient|>all\nAction: {low_level_instruction}\n"
+        if self.mode == "force-plan":
+            recipient_text = "<|im_start|>assistant<|recipient|>all\nThought: "
+        elif self.mode == "force-plan-l1":
+            recipient_text = "<|im_start|>assistant<|recipient|>all\nAction: "
+        elif self.mode == "force-plan-l3":
+            recipient_text = "<|im_start|>assistant<|recipient|>all\nObservation: "
+        elif self.mode == "grounding":
+            recipient_text = "<|im_start|>assistant<|recipient|>os\n"
+        elif self.mode == "force-plan-free":
+            recipient_text = "<|im_start|>assistant<|recipient|>all\n"
+        elif self.mode == "self-plan":
+            recipient_text = "<|im_start|>assistant<|recipient|>"
+        else:
+            raise ValueError(f"Invalid mode: {self.mode}")
+        text += recipient_text
+        # print(text)
+
+        images, videos = process_vision_info([messages])
+        inputs = self.processor(
+            text=[text], images=images, videos=videos, padding=True, return_tensors="pt"
+        )
+        inputs = inputs.to("cuda")
+
+        # stop_str = "<|diff_marker|>"
+        # keywords = [stop_str]
+        # stopping_criteria = KeywordsStoppingCriteria(
+        #     keywords, self.processor.tokenizer, inputs.input_ids
+        # )
+
+        generated_ids = self.model.generate(
+            **inputs,
+            **self.generate_kwargs,
+            # stopping_criteria=[stopping_criteria],
+        )
+        generated_ids = [
+            output_ids[len(input_ids):]
+            for input_ids, output_ids in zip(inputs.input_ids, generated_ids)
+        ]
+        out = self.processor.tokenizer.batch_decode(
+            generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False
+        )
+        response = out[0]
+        # for term in UNTIL:
+        #     if len(term) > 0:
+        #         response = response.split(term)[0]
+
+        if self.post_process:
+            resp = response.split("\\boxed{")[-1]
+            lt = len(resp)
+            counter, end = 1, None
+            for i in range(lt):
+                if resp[i] == "{":
+                    counter += 1
+                elif resp[i] == "}":
+                    counter -= 1
+                if counter == 0:
+                    end = i
+                    break
+                elif i == lt - 1:
+                    end = lt
+                    break
+            if end is not None:
+                response = resp[:end]
+
+        if self.verbose:
+            print(f"\033[32m{response}\033[0m")
+        return response
diff --git a/VLMEvalKit-sudoku/vlmeval/vlm/qwen2_vl/prompt.py b/VLMEvalKit-sudoku/vlmeval/vlm/qwen2_vl/prompt.py
new file mode 100644
index 0000000000000000000000000000000000000000..02faaa3c6a7e87d8abf1d23c171f2071052c2fc2
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/vlm/qwen2_vl/prompt.py
@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+
+class Qwen2VLPromptMixin:
+    """
+    Mixin class for Qwen2VLChat to build custom prompt for different datasets.
+
+    Requires the following methods to be implemented in the subclass:
+        - dump_image(line, dataset: str) -> str | list[str]
+
+    Implements the following methods:
+        - use_custom_prompt(dataset: str) -> bool
+        - build_prompt(line, dataset: str) -> list[dict[str, str]]
+    """
+
+    def __init__(self, *args, use_custom_prompt: bool = True, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._use_custom_prompt = use_custom_prompt
+
+    def set_dump_image(self, dump_image_func):
+        self.dump_image_func = dump_image_func
+
+    def dump_image(self, line, dataset):
+        return self.dump_image_func(line)
+
+    def use_custom_prompt(self, dataset: str) -> bool:
+        from vlmeval.dataset import DATASET_TYPE
+        dataset_type = DATASET_TYPE(dataset, default=None)
+
+        if not self._use_custom_prompt:
+            return False
+        if dataset in {'MMMU_DEV_VAL', 'MMMU_TEST'}:
+            return True
+        if dataset_type == 'MCQ':
+            if dataset is not None and 'LEGO' in dataset:
+                return False
+            return True
+        if dataset_type == 'Y/N' and dataset in {'HallusionBench', 'POPE'}:  # MME has it's own prompt
+            return True
+        if dataset_type == 'VQA' and dataset not in {'MMVet'}:  # MMVet VQA has it's own prompt
+            return True
+        return False
+
+    def build_prompt(self, line, dataset: str) -> list[dict[str, str]]:
+        from vlmeval.dataset import DATASET_TYPE
+
+        if dataset in {'MMMU_DEV_VAL', 'MMMU_TEST'}:
+            return self._build_mmmu_prompt(line, dataset)
+        dataset_type = DATASET_TYPE(dataset, default=None)
+        if dataset_type == 'MCQ':
+            return self._build_mcq_prompt(line, dataset)
+        if dataset_type == 'Y/N':
+            return self._build_yorn_prompt(line, dataset)
+        if dataset_type == 'VQA':
+            return self._build_vqa_prompt(line, dataset)
+        raise ValueError(f'Unsupported dataset: {dataset}')
+
+    def _build_mmmu_prompt(self, line, dataset: str) -> list[dict[str, str]]:
+        """change the prompt for MMMU dataset: keep all images at beginning."""
+
+        import string
+
+        import pandas as pd
+
+        tgt_path = self.dump_image(line, dataset)
+        question = line['question']
+        options = {cand: line[cand] for cand in string.ascii_uppercase if cand in line and not pd.isna(line[cand])}
+        options_prompt = 'Options:\n'
+        for key, item in options.items():
+            options_prompt += f'{key}. {item}\n'
+        hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+        prompt = ''
+        if hint is not None:
+            prompt += f'Hint: {hint}\n'
+        prompt += f'Question: {question}\n'
+        if len(options):
+            prompt += options_prompt
+            prompt += 'Please select the correct answer from the options above. \n'
+        prompt = prompt.rstrip()
+        msgs = []
+        if isinstance(tgt_path, list):
+            msgs.extend([dict(type='image', value=p) for p in tgt_path])
+        else:
+            msgs = [dict(type='image', value=tgt_path)]
+        msgs.append(dict(type='text', value=prompt))
+        return msgs
+
+    def _build_mcq_prompt(self, line, dataset: str) -> list[dict[str, str]]:
+        """change the prompt for MCQ dataset: use chinese prompt if the question contains chinese characters."""
+        MCQ_CN_PROMPT = '请直接回答选项字母。'
+        MCQ_EN_PROMPT = 'Please select the correct answer from the options above.'
+
+        import string
+
+        import pandas as pd
+
+        def cn_string(s):
+            import re
+
+            if re.search('[\u4e00-\u9fff]', s):
+                return True
+            return False
+
+        tgt_path = self.dump_image(line, dataset)
+        question = line['question']
+        options = {cand: line[cand] for cand in string.ascii_uppercase if cand in line and not pd.isna(line[cand])}
+        options_prompt = 'Options:\n'
+        for key, item in options.items():
+            options_prompt += f'{key}. {item}\n'
+        hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+        prompt = ''
+        if hint is not None:
+            prompt += f'Hint: {hint}\n'
+        prompt += f'Question: {question}\n'
+        if len(options):
+            prompt += options_prompt
+            prompt += MCQ_CN_PROMPT if cn_string(prompt) else MCQ_EN_PROMPT
+        prompt = prompt.rstrip()
+        msgs = []
+        if isinstance(tgt_path, list):
+            msgs.extend([dict(type='image', value=p) for p in tgt_path])
+        else:
+            msgs = [dict(type='image', value=tgt_path)]
+        msgs.append(dict(type='text', value=prompt))
+        return msgs
+
+    def _build_yorn_prompt(self, line, dataset: str) -> list[dict[str, str]]:
+        """change the prompt for YORN dataset:"""
+        YORN_PROMPT = ' Please answer yes or no.'
+
+        tgt_path = self.dump_image(line, dataset)
+        question = line['question']
+        msgs = []
+        if isinstance(tgt_path, list):
+            msgs.extend([dict(type='image', value=p) for p in tgt_path])
+        else:
+            msgs = [dict(type='image', value=tgt_path)]
+        msgs.append(dict(type='text', value=question))
+        assert msgs[-1]['type'] == 'text'
+        msgs[-1]['value'] += YORN_PROMPT
+        return msgs
+
+    def _build_vqa_prompt(self, line, dataset: str) -> list[dict[str, str]]:
+        """change the prompt for VQA dataset:"""
+        VQA_PROMPT = '\nPlease try to answer the question with short words or phrases if possible.'
+
+        tgt_path = self.dump_image(line, dataset)
+        question = line['question']
+        msgs = []
+        if isinstance(tgt_path, list):
+            msgs.extend([dict(type='image', value=p) for p in tgt_path])
+        else:
+            msgs = [dict(type='image', value=tgt_path)]
+        msgs.append(dict(type='text', value=question))
+        assert msgs[-1]['type'] == 'text'
+        msgs[-1]['value'] += VQA_PROMPT
+        return msgs
diff --git a/VLMEvalKit-sudoku/vlmeval/vlm/thyme/sandbox.py b/VLMEvalKit-sudoku/vlmeval/vlm/thyme/sandbox.py
new file mode 100644
index 0000000000000000000000000000000000000000..660798988b7cb6cfbc99f8f4a6f0b30bfade3453
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/vlm/thyme/sandbox.py
@@ -0,0 +1,990 @@
+import ast
+import contextlib
+import glob
+import importlib
+import io
+import json
+import math
+import os
+import pickle
+import random
+import re
+import shutil
+import stat
+import string
+import sys
+import textwrap
+import types
+
+import numpy
+import timeout_decorator  # For efficient timeout control
+from PIL import Image, UnidentifiedImageError
+
+# Attempt to import cv2, but make it optional if not strictly needed by
+# all sandbox uses
+try:
+    import cv2
+except ImportError:
+    cv2 = None  # Keep track if cv2 is not available
+    print(
+        "Warning: OpenCV (cv2) not found. cv2-dependent sandboxed code will fail.",
+        file=sys.stderr,
+    )
+
+
+# --- Enhanced Security: Prohibit dangerous system calls ---
+DANGEROUS_PATTERNS = [
+    r"\bsys\.",
+    r"\bsocket\.",
+    r"\bsubprocess\.",
+    r"\bexec\(",
+    r"\beval\(",
+    r"\bcompile\(",
+    r"\b__import__\(",
+    r"\bos\.(remove|unlink|rmdir)\b",
+    r"\bshutil\.rmtree\b",
+    r"\bshutil\.move\b",
+    r"\bos\.(rename|renames)\b",
+]
+
+
+def check_dangerous_code(code_string):
+    """
+    Performs a basic static analysis to detect dangerous patterns in the code.
+    Returns True if dangerous patterns are found, False otherwise.
+    """
+    for pattern in DANGEROUS_PATTERNS:
+        if re.search(pattern, code_string, re.IGNORECASE):
+            return True
+    return False
+
+
+# pandayin: set a time limit to avoid dead loop, e.x., while(1) type loops.
+EXEC_TIME_LIMIT = 10
+# Define the temporary folder for processed images
+# IMPORTANT: Ensure this directory exists and is writable by the script.
+# For local testing, you might want to change this, e.g.:
+TEMP_PROCESSED_IMAGES_DIR = "./temp_processed_images/"
+
+
+class ReadOnlyPath:
+    def __init__(self, path):
+        self.path = path if isinstance(path, str) else None
+        self.original_permissions = None
+
+    def __enter__(self):
+        if self.path and os.path.isfile(self.path):
+            try:
+                self.original_permissions = os.stat(self.path).st_mode
+                read_only_permissions = self.original_permissions & ~(
+                    stat.S_IWUSR | stat.S_IWGRP | stat.S_IWOTH
+                )
+                if self.original_permissions != read_only_permissions:
+                    os.chmod(self.path, read_only_permissions)
+            except OSError as e:
+                print(
+                    f"Warning: Could not make '{self.path}' read-only: {e}",
+                    file=sys.stderr,
+                )
+                self.original_permissions = None  # 确保我们不会在退出时尝试恢复权限
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if (
+            self.path
+            and self.original_permissions is not None
+            and os.path.isfile(self.path)
+        ):
+            try:
+                os.chmod(self.path, self.original_permissions)
+            except OSError as e:
+                print(
+                    f"Warning: Could not restore original permissions for '{self.path}': {e}",
+                    file=sys.stderr,
+                )
+
+
+def align_first_line_to_second(code_string: str) -> str:
+    lines = code_string.splitlines()
+
+    first_line_info = None
+    second_line_info = None
+
+    for index, line_content in enumerate(lines):
+        if line_content.strip():
+            if first_line_info is None:
+                first_line_info = {"index": index, "content": line_content}
+            elif second_line_info is None:
+                second_line_info = {"index": index, "content": line_content}
+                break
+
+    if not first_line_info or not second_line_info:
+        return code_string
+
+    first_line_content = first_line_info["content"]
+    second_line_content = second_line_info["content"]
+
+    first_line_indent = " " * (
+        len(first_line_content) - len(first_line_content.lstrip(" "))
+    )
+    second_line_indent = " " * (
+        len(second_line_content) - len(second_line_content.lstrip(" "))
+    )
+
+    if first_line_indent != second_line_indent:
+        original_index = first_line_info["index"]
+        stripped_content = first_line_content.lstrip(" ")
+        lines[original_index] = second_line_indent + stripped_content
+
+    return "\n".join(lines)
+
+
+def get_image_paths(temp_output_dir):
+    extensions = ["jpg", "jpeg", "png", "bmp", "gif", "tiff"]
+    image_paths = []
+
+    for ext in extensions:
+        pattern = os.path.join(temp_output_dir, f"*.{ext}")
+        image_paths.extend(glob.glob(pattern))
+
+    return image_paths
+
+
+VALID_IMAGE_EXTENSIONS = (
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".bmp",
+    ".tiff",
+    ".webp")
+ORIGINAL_OUTPUT_PREFIX = "/mnt/data/temp_processed_images/"
+
+
+class ImagePathTransformer(ast.NodeTransformer):
+    def __init__(self, replacement_path):
+        self.replacement_path = replacement_path
+        self.path_was_replaced = False
+
+    def visit_Assign(self, node):
+        # Process simple assignments: target_variable = "string_literal"
+        if len(node.targets) == 1 and isinstance(node.targets[0], ast.Name):
+            target_variable_name = node.targets[0].id
+
+            if target_variable_name == "image_path":  # Target specific variable name
+                current_path_value = None
+                # Extract string value from ast.Constant (Python 3.8+) or
+                # ast.Str (older Python)
+                if isinstance(node.value, ast.Constant) and isinstance(
+                    node.value.value, str
+                ):
+                    current_path_value = node.value.value
+                elif isinstance(node.value, ast.Str):  # For Python < 3.8
+                    current_path_value = node.value.s
+
+                if current_path_value is not None:
+                    is_valid_image_on_disk = False
+                    if (
+                        os.path.exists(current_path_value)
+                        and os.path.isfile(current_path_value)
+                        and any(
+                            current_path_value.lower().endswith(ext)
+                            for ext in VALID_IMAGE_EXTENSIONS
+                        )
+                    ):
+                        is_valid_image_on_disk = True
+
+                    if not is_valid_image_on_disk:
+                        # Replace the value of the AST node
+                        if hasattr(ast, "Constant"):  # Python 3.8+
+                            node.value = ast.Constant(
+                                value=self.replacement_path)
+                        else:  # Python < 3.8
+                            node.value = ast.Str(s=self.replacement_path)
+                        self.path_was_replaced = True
+
+        return self.generic_visit(node)  # Continue traversing
+
+
+MIN_CROP_DIMENSION = 64
+
+# Define a minimum dimension for the crop
+# MIN_CROP_DIMENSION = 64 # Duplicate definition
+
+
+class CropCoordinateTransformer(ast.NodeTransformer):
+    def __init__(self, image_width, image_height,
+                 main_image_variable_name="image"):
+        self.image_width = image_width
+        self.image_height = image_height
+        self.main_image_variable_name = main_image_variable_name  # New parameter
+        self.coordinates_clamped = False
+        # Add specific variable names to look for
+        self.known_coord_var_names = [
+            "crop_box",
+            "bbox",
+            "box",
+            "coordinates",
+            "coords",
+            "crop_coords",
+            "left_crop_coords",
+            "right_crop_coords",
+            "top_crop_coords",
+            "bottom_crop_coords",
+            # Add any other common names you anticipate
+        ]
+
+    def _get_numeric_value(self, node_value):
+        if isinstance(node_value, ast.Constant) and isinstance(
+            node_value.value, (int, float)
+        ):
+            return node_value.value
+        elif isinstance(node_value, ast.Num):  # Python < 3.8
+            return node_value.n
+        return None
+
+    def _create_numeric_node(self, value):
+        int_value = int(round(value))
+        if hasattr(ast, "Constant"):  # Python 3.8+
+            return ast.Constant(value=int_value)
+        else:  # Python < 3.8
+            return ast.Num(n=int_value)
+
+    def _clamp_coordinates(self, v_x1, v_y1, v_x2, v_y2):
+        img_w, img_h = float(self.image_width), float(self.image_height)
+
+        cx1 = min(v_x1, v_x2)
+        cx2 = max(v_x1, v_x2)
+        cy1 = min(v_y1, v_y2)
+        cy2 = max(v_y1, v_y2)
+
+        final_x1 = max(0.0, cx1)
+        final_x1 = min(final_x1, img_w - 1.0 if img_w > 0 else 0.0)
+        final_x2 = max(0.0, cx2)
+        final_x2 = min(final_x2, img_w)
+        if final_x1 >= final_x2 and img_w > 0:
+            final_x1 = max(0.0, final_x2 - 1.0)
+            if final_x2 <= final_x1:
+                final_x2 = min(img_w, final_x1 + 1.0)
+
+        final_y1 = max(0.0, cy1)
+        final_y1 = min(final_y1, img_h - 1.0 if img_h > 0 else 0.0)
+        final_y2 = max(0.0, cy2)
+        final_y2 = min(final_y2, img_h)
+        if final_y1 >= final_y2 and img_h > 0:
+            final_y1 = max(0.0, final_y2 - 1.0)
+            if final_y2 <= final_y1:
+                final_y2 = min(img_h, final_y1 + 1.0)
+
+        current_width = final_x2 - final_x1
+        if img_w > 0 and current_width < MIN_CROP_DIMENSION:
+            if img_w < MIN_CROP_DIMENSION:
+                final_x1 = 0.0
+                final_x2 = img_w
+            else:
+                final_x2 = final_x1 + MIN_CROP_DIMENSION
+                if final_x2 > img_w:
+                    final_x2 = img_w
+                    final_x1 = max(0.0, final_x2 - MIN_CROP_DIMENSION)
+
+        current_height = final_y2 - final_y1
+        if img_h > 0 and current_height < MIN_CROP_DIMENSION:
+            if img_h < MIN_CROP_DIMENSION:
+                final_y1 = 0.0
+                final_y2 = img_h
+            else:
+                final_y2 = final_y1 + MIN_CROP_DIMENSION
+                if final_y2 > img_h:
+                    final_y2 = img_h
+                    final_y1 = max(0.0, final_y2 - MIN_CROP_DIMENSION)
+
+        if img_w > 0 and final_x1 >= final_x2:
+            final_x2 = min(img_w, final_x1 + 1.0)
+        if img_h > 0 and final_y1 >= final_y2:
+            final_y2 = min(img_h, final_y1 + 1.0)
+
+        return [final_x1, final_y1, final_x2, final_y2]
+
+    def visit_Assign(self, node):
+        processed_node_values = False
+
+        # Case 1: Direct unpacking e.g., x1, y1, x2, y2 = (v1, v2, v3, v4)
+        # or var1, var2, var3, var4 = (v1, v2, v3, v4) if we assume any 4-tuple assign is coords.
+        # For safety, let's stick to explicit x1,y1,x2,y2 or similar, or rely
+        # on Case 2 for named tuples.
+        if (
+            len(node.targets) == 1
+            and isinstance(node.targets[0], ast.Tuple)
+            and len(node.targets[0].elts) == 4
+            and all(isinstance(t, ast.Name) for t in node.targets[0].elts)
+            and isinstance(node.value, ast.Tuple)
+            # Optional: check if target names match common patterns like x1,y1,x2,y2
+            # For now, any 4-tuple assignment to 4 variables is considered.
+            and len(node.value.elts) == 4
+        ):
+
+            target_names = [t.id.lower() for t in node.targets[0].elts]
+            # A heuristic: if names like 'x1', 'y1', 'x2', 'y2' or 'left',
+            # 'top', 'right', 'bottom' are used
+            is_likely_coords_unpacking = any(
+                name in target_names
+                for name in ["x1", "y1", "x2", "y2", "left", "top", "right", "bottom"]
+            )
+
+            if (
+                is_likely_coords_unpacking
+            ):  # Process if it seems like coordinate unpacking
+                raw_coords_from_code = [
+                    self._get_numeric_value(v) for v in node.value.elts
+                ]
+
+                if all(c is not None for c in raw_coords_from_code):
+                    # Assume order from the tuple assignment e.g. x1,y1,x2,y2
+                    current_x1, current_y1, current_x2, current_y2 = (
+                        raw_coords_from_code
+                    )
+                    clamped_values = self._clamp_coordinates(
+                        current_x1, current_y1, current_x2, current_y2
+                    )
+
+                    original_rounded = [int(round(c))
+                                        for c in raw_coords_from_code]
+                    final_rounded = [int(round(c)) for c in clamped_values]
+
+                    if final_rounded != original_rounded:
+                        self.coordinates_clamped = True
+                        for i in range(4):
+                            node.value.elts[i] = self._create_numeric_node(
+                                clamped_values[i]
+                            )
+                    processed_node_values = True
+
+        # Case 2: Assignment to a known variable name, e.g., crop_box = (v1, v2, v3, v4)
+        # This will now specifically catch 'left_crop_coords = ...' and 'right_crop_coords = ...'
+        # if they are in self.known_coord_var_names.
+        elif (
+            not processed_node_values
+            and len(node.targets) == 1
+            and isinstance(node.targets[0], ast.Name)
+            # Check against the list
+            and node.targets[0].id in self.known_coord_var_names
+            and isinstance(node.value, ast.Tuple)
+            and len(node.value.elts) == 4
+        ):
+
+            raw_coords_from_code = [
+                self._get_numeric_value(v) for v in node.value.elts]
+
+            if all(c is not None for c in raw_coords_from_code):
+                current_x1, current_y1, current_x2, current_y2 = raw_coords_from_code
+                clamped_values = self._clamp_coordinates(
+                    current_x1, current_y1, current_x2, current_y2
+                )
+
+                original_rounded = [int(round(c))
+                                    for c in raw_coords_from_code]
+                final_rounded = [int(round(c)) for c in clamped_values]
+
+                if final_rounded != original_rounded:
+                    self.coordinates_clamped = True
+                    for i in range(4):
+                        node.value.elts[i] = self._create_numeric_node(
+                            clamped_values[i]
+                        )
+
+        # Case 3: Direct slicing assignment, e.g., cropped_var =
+        # image_var[y1:y2, x1:x2]
+        if (
+            len(node.targets) == 1
+            and isinstance(node.targets[0], ast.Name)  # e.g. sony_crop = ...
+            # ... image[...]
+            and isinstance(node.value, ast.Subscript)
+            and isinstance(node.value.value, ast.Name)  # ... image variable ...
+            and node.value.value.id == self.main_image_variable_name  # ... is the one we care about
+            and isinstance(node.value.slice, ast.Index)  # ... [<slice_tuple>] ...
+            and isinstance(node.value.slice.value, ast.Tuple)  # ... (slice_y, slice_x)
+            and len(node.value.slice.value.elts) == 2
+            and all(isinstance(s, ast.Slice) for s in node.value.slice.value.elts)
+        ):  # both are Slices
+
+            slice_tuple_node = node.value.slice.value
+            y_slice_node = slice_tuple_node.elts[0]  # First slice is y-dim
+            x_slice_node = slice_tuple_node.elts[1]  # Second slice is x-dim
+
+            # Extract numeric values, converting None to 0 or full dimension
+            y1_val = self._get_numeric_value(y_slice_node.lower)
+            if y1_val is None and y_slice_node.lower is None:
+                y1_val = 0.0  # If original was None, treat as 0
+
+            y2_val = self._get_numeric_value(y_slice_node.upper)
+            if y2_val is None and y_slice_node.upper is None:
+                # If original was None, treat as full height
+                y2_val = float(self.image_height)
+
+            x1_val = self._get_numeric_value(x_slice_node.lower)
+            if x1_val is None and x_slice_node.lower is None:
+                x1_val = 0.0
+
+            x2_val = self._get_numeric_value(x_slice_node.upper)
+            if x2_val is None and x_slice_node.upper is None:
+                x2_val = float(self.image_width)
+
+            # If any original value was not a number or None (e.g. a variable
+            # name in slice), skip
+            if not all(isinstance(v, (int, float))
+                       for v in [y1_val, y2_val, x1_val, x2_val]):
+                # print(f"INFO: Skipping slice clamping for '{node.targets[0].id}' due to non-numeric slice parts.")
+                return self.generic_visit(node)
+
+            # Keep this order for comparison
+            # original_coords = [x1_val, y1_val, x2_val, y2_val]
+            clamped_x1, clamped_y1, clamped_x2, clamped_y2 = self._clamp_coordinates(
+                x1_val, y1_val, x2_val, y2_val)
+
+            final_coords_for_ast = [
+                clamped_y1,
+                clamped_y2,
+                clamped_x1,
+                clamped_x2,
+            ]  # y first for slice node update
+            original_coords_for_ast_compare = [y1_val, y2_val, x1_val, x2_val]
+
+            # Round for comparison
+            original_rounded = [int(round(c))
+                                for c in original_coords_for_ast_compare]
+            final_rounded = [int(round(c)) for c in final_coords_for_ast]
+
+            if final_rounded != original_rounded:
+                self.coordinates_clamped = True
+                # Update the AST Slice nodes
+                y_slice_node.lower = self._create_numeric_node(clamped_y1)
+                y_slice_node.upper = self._create_numeric_node(clamped_y2)
+                x_slice_node.lower = self._create_numeric_node(clamped_x1)
+                x_slice_node.upper = self._create_numeric_node(clamped_x2)
+
+        return self.generic_visit(node)  # Important to call for other nodes
+
+
+class OpenCVNamespaceTransformer(ast.NodeTransformer):
+    """
+    Transforms incorrect OpenCV namespace calls (e.g., cv., cv4.) to cv2.
+    """
+
+    def __init__(self, incorrect_prefixes=None, correct_prefix="cv2"):
+        if incorrect_prefixes is None:
+            self.incorrect_prefixes = [
+                "cv",
+                "cv4",
+                "cv3",
+                "CV",
+            ]  # Common incorrect ones
+        else:
+            self.incorrect_prefixes = incorrect_prefixes
+        self.correct_prefix = correct_prefix
+        self.namespace_updated = False
+
+    def visit_Attribute(self, node):
+        """
+        Called for attribute access like object.attribute or object.sub_object.attribute
+        We are interested in cases like:
+        - cv.imread(...) -> node.value is Name(id='cv'), node.attr is 'imread'
+        - cv.some_module.CONSTANT -> node.value is Name(id='cv'), node.attr is 'some_module'
+                                     (this will be visited first)
+                                     then later, cv2.some_module.CONSTANT,
+                                     node.value is Attribute(value=Name(id='cv2'), attr='some_module')
+        """
+        # Check if the base of the attribute access (e.g., 'cv' in 'cv.imread')
+        # is an ast.Name node and matches one of the incorrect prefixes.
+        if (
+            isinstance(node.value, ast.Name)
+            and node.value.id in self.incorrect_prefixes
+        ):
+            # original_prefix = node.value.id
+            # Change the id of the ast.Name node to the correct prefix
+            node.value.id = self.correct_prefix
+            self.namespace_updated = True
+        # Important: continue visiting child nodes.
+        # This handles cases like cv.submodule.function, ensuring 'cv' is
+        # replaced.
+        return self.generic_visit(node)
+
+
+def ensure_temp_dir(temp_output_dir):
+    """Ensures the temporary directory for processed images exists."""
+    os.makedirs(temp_output_dir, exist_ok=True)
+    # Also ensure the directory is writable (basic check)
+    if not os.access(temp_output_dir, os.W_OK):
+        raise PermissionError(
+            f"Temporary directory {temp_output_dir} is not writable.")
+
+
+# (Default) For Linux/Unix system, signal mechanism could be used (high-efficiency).
+# For Windows where signal support is invalid, this function will be
+# executed in a separate process via multi-processing mechanism.
+
+
+@timeout_decorator.timeout(EXEC_TIME_LIMIT, use_signals=True)
+def _sandboxed_execution_target(
+    code_to_execute,
+    input_image_path,
+    temp_output_dir,
+    item_id,
+    previous_execution_context=None,
+):
+    """
+    Target function for sandboxed code execution in a subprocess.
+    Results are put into return_dict.
+    `previous_execution_context` is a dict {'globals': ..., 'locals': ...}
+    """
+    return_dict = {}
+
+    # Prepare a restricted environment for exec()
+    allowed_builtins = {
+        "print": print,
+        "len": len,
+        "str": str,
+        "int": int,
+        "float": float,
+        "list": list,
+        "dict": dict,
+        "tuple": tuple,
+        "range": range,
+        "round": round,
+        "abs": abs,
+        "min": min,
+        "max": max,
+        "sum": sum,
+        "sorted": sorted,
+        "any": any,
+        "all": all,
+        "zip": zip,
+        "map": map,
+        "filter": filter,
+        "True": True,
+        "False": False,
+        "None": None,
+        "isinstance": isinstance,
+        "issubclass": issubclass,
+        "Exception": Exception,
+        "ValueError": ValueError,
+        "TypeError": TypeError,
+        "AttributeError": AttributeError,
+        "IndexError": IndexError,
+        "KeyError": KeyError,
+        "NotImplementedError": NotImplementedError,
+        "enumerate": enumerate,
+        "pow": pow,
+        "divmod": divmod,
+        "bin": bin,
+        "oct": oct,
+        "hex": hex,
+        "complex": complex,
+        "__import__": __import__,
+        "globals": globals,
+        "locals": locals,
+        "open": open,
+        # Modules accessible via __import__ or provided in sandbox_globals
+        "os": os,
+        "shutil": shutil,
+        "itertools": __import__("itertools"),
+        "re": __import__("re"),
+        "time": __import__("time"),
+        "datetime": __import__("datetime"),
+        "math": __import__("math"),
+        "cmath": __import__("cmath"),
+        "collections": __import__("collections"),
+        "json": json,
+        "PIL": __import__("PIL"),
+        "random": random,
+        "UnidentifiedImageError": UnidentifiedImageError,
+    }
+
+    sandbox_globals = {
+        "__builtins__": allowed_builtins,
+        "os": os,
+        "random": random,
+        "string": string,
+        "math": math,
+        "Image": Image,
+        "UnidentifiedImageError": UnidentifiedImageError,
+        "numpy": numpy,
+        "np": numpy,  # TODO: pandayin: Check this? this seems like a duplicate
+        "json": json,  # Make json directly available
+        "re": re,  # Make re directly available
+        # PIL is available via __import__ or Image class
+    }
+
+    if cv2:
+        sandbox_globals["cv2"] = cv2
+
+    sandbox_globals_always = sandbox_globals
+    sandbox_locals = {
+        "image_path": input_image_path,
+        "temp_output_dir": temp_output_dir,
+    }
+
+    if previous_execution_context:
+        # Restore picklable local variables from the previous step
+        sandbox_locals.update(previous_execution_context.get("locals", {}))
+
+        # Re-create imported modules from the previous step
+        imports_to_recreate = previous_execution_context.get("globals", {})
+        for alias, module_name in imports_to_recreate.items():
+            try:
+                # Re-import the module and add it to the current step's locals
+                module_obj = importlib.import_module(module_name)
+                sandbox_locals[alias] = module_obj
+            except ImportError:
+                print(
+                    f"Warning: Could not re-import module '{module_name}' (as '{alias}') from previous step."
+                )
+
+    code_to_execute = align_first_line_to_second(code_to_execute)
+    try:
+        import autopep8
+        dedented_code = textwrap.dedent(code_to_execute).strip()
+        code_to_execute = dedented_code
+        formatted_code = autopep8.fix_code(
+            code_to_execute, options={"aggressive": 2}
+        )
+        # if formatted_code.strip() != code_to_execute.strip():
+        #     print(f"INFO: Attempted to auto-format code for {item_id} using autopep8.")
+        code_to_execute = formatted_code
+    except Exception:
+        pass
+
+    # ... (AST transformations: ImagePathTransformer, CropCoordinateTransformer, OpenCVNamespaceTransformer) ...
+    # (These transformations should operate on code_to_execute before exec)
+    if input_image_path and isinstance(input_image_path, str):
+        try:
+            tree = ast.parse(code_to_execute)
+            transformer = ImagePathTransformer(input_image_path)
+            new_tree = transformer.visit(tree)
+            if transformer.path_was_replaced:
+                if hasattr(ast, "unparse"):
+                    code_to_execute = ast.unparse(new_tree)
+                else:
+                    print(
+                        "Warning: ast.unparse not available (requires Python 3.9+). "
+                        "Code for image_path replacement not updated. Consider installing"
+                        "'astor' for older Python versions or upgrading Python."
+                    )
+        except SyntaxError as e:
+            print(
+                f"Syntax error when parsing code for image_path replacement: {e}")
+        except Exception as e:
+            print(
+                f"An error occurred during image_path AST transformation: {e}")
+
+    actual_image_width, actual_image_height = None, None
+    if input_image_path and os.path.isfile(input_image_path):
+        try:
+            with Image.open(input_image_path) as img_obj:
+                actual_image_width, actual_image_height = img_obj.size
+            if actual_image_width is None or actual_image_height is None:
+                print(
+                    f"WARNING: Could not determine dimensions for '{input_image_path}' using PIL."
+                )
+        except Exception as e:
+            print(
+                f"WARNING: Could not read image dimensions from '{input_image_path}' using PIL: {e}"
+            )
+
+    if actual_image_width is not None and actual_image_height is not None:
+        if actual_image_width == 0 or actual_image_height == 0:
+            print(
+                f"WARNING: Input image '{input_image_path}' has zero width or height"
+                f"({actual_image_width}x{actual_image_height}). Clamping might result in zero-size crops."
+            )
+        try:
+            crop_ast_tree = ast.parse(code_to_execute)
+            crop_transformer = CropCoordinateTransformer(
+                actual_image_width, actual_image_height
+            )
+            new_crop_ast_tree = crop_transformer.visit(crop_ast_tree)
+            if crop_transformer.coordinates_clamped:
+                if hasattr(ast, "unparse"):
+                    code_to_execute = ast.unparse(new_crop_ast_tree)
+                else:
+                    print(
+                        "WARNING: ast.unparse not available (Python 3.9+)."
+                        "Crop coordinate clamping not fully updated in code string."
+                    )
+        except SyntaxError:
+            # print(f"ERROR: Syntax error when parsing code for crop coordinate clamping: {e}")
+            pass
+        except Exception as e:
+            print(
+                f"ERROR: An error occurred during crop coordinate AST transformation: {e}"
+            )
+            pass
+    else:
+        if input_image_path:
+            # print(
+            #     f"INFO: Skipping crop coordinate clamping because image dimensions"
+            #     f"could not be obtained for '{input_image_path}'.")
+            pass
+
+    try:  # Wrap AST parsing for OpenCV transformer in try-except
+        tree = ast.parse(code_to_execute)
+        cv_transformer = OpenCVNamespaceTransformer(correct_prefix="cv2")
+        new_tree = cv_transformer.visit(tree)
+
+        if cv_transformer.namespace_updated:
+            print("OpenCV namespace references were updated.")
+            if hasattr(ast, "unparse"):
+                code_to_execute = ast.unparse(new_tree)
+                print("Code updated using ast.unparse.")
+            else:
+                try:
+                    import astor
+
+                    code_to_execute = astor.to_source(new_tree)
+                    print("Code updated using astor.to_source.")
+                except ImportError:
+                    print(
+                        "WARNING: ast.unparse not available (Python 3.9+), and astor not installed."
+                    )
+                    print(
+                        "The AST was modified, but the code_to_execute string was not updated."
+                    )
+    except SyntaxError as e:
+        print(
+            f"ERROR: Syntax error when parsing code for OpenCV namespace transformation: {e}."
+        )
+    except Exception as e:
+        print(
+            f"ERROR: An error occurred during OpenCV namespace AST transformation: {e}"
+        )
+
+    captured_stdout = io.StringIO()
+    processed_path_from_code = None
+    processed_paths_list = []
+    error_msg = None
+    full_print_output = None
+
+    try:
+        with contextlib.redirect_stdout(captured_stdout):
+            original_prefix = "/mnt/data/temp_processed_images/"
+            replacement_target_path = temp_output_dir
+            if original_prefix.endswith(
+                    "/") and not temp_output_dir.endswith("/"):
+                replacement_target_path = temp_output_dir + "/"
+
+            # Create subdirectories if implied by paths in code
+            quoted_path_pattern_str = (
+                r"(['\"])(" + re.escape(original_prefix) + r"[^'\"]*)\1"
+            )
+            quoted_path_pattern = re.compile(quoted_path_pattern_str)
+            unique_paths_found = set()
+            for match in quoted_path_pattern.finditer(code_to_execute):
+                unique_paths_found.add(match.group(2))
+            for full_path_str in unique_paths_found:
+                if full_path_str.startswith(original_prefix):
+                    # relative_path_suffix = full_path_str[len(original_prefix):]
+                    # print('full_path_str', unique_paths_found)
+                    relative_path_suffix = full_path_str[
+                        len(original_prefix):
+                    ].replace(" ", "")
+                    if relative_path_suffix:
+                        path_directory_part = os.path.dirname(
+                            relative_path_suffix)
+                        if path_directory_part:
+                            target_subdir_to_create = os.path.join(
+                                temp_output_dir, path_directory_part
+                            )
+                            os.makedirs(target_subdir_to_create, exist_ok=True)
+
+            code_to_execute = code_to_execute.replace(
+                original_prefix, replacement_target_path
+            )
+            code_to_execute = re.sub(r":\.\d{1}f}", ":.8f}", code_to_execute)
+            exec(code_to_execute, sandbox_globals, sandbox_locals)
+
+        full_print_output = captured_stdout.getvalue().strip()
+
+        if "processed_path" in sandbox_locals and (
+            not previous_execution_context
+            or "processed_path" not in previous_execution_context.get("locals", {})
+        ):
+            processed_path_from_code = sandbox_locals["processed_path"]
+            if (
+                isinstance(processed_path_from_code, str)
+                and processed_path_from_code.startswith(temp_output_dir)
+                and os.path.isfile(processed_path_from_code)
+            ):
+                processed_paths_list.append(processed_path_from_code)
+            elif (
+                isinstance(processed_path_from_code, str)
+                and processed_path_from_code.startswith(temp_output_dir)
+                and not os.path.exists(processed_path_from_code)
+            ):
+                error_msg = (
+                    f"Sandbox for {item_id}: 'processed_path' variable set to "
+                    f"'{processed_path_from_code}', but file does not exist."
+                )
+                processed_path_from_code = None
+            elif processed_path_from_code is not None:
+                error_msg = (
+                    f"Sandbox for {item_id}: 'processed_path' variable was "
+                    f"'{processed_path_from_code}', which is not a valid file path in {temp_output_dir}."
+                )
+                processed_path_from_code = None
+        # print(full_print_output)
+        if full_print_output:
+            path_search_pattern = rf"({re.escape(temp_output_dir)}[^\s\'\"]+\.(?:jpg|jpeg|png|bmp|gif|tiff))"
+            possible_image_path_list = get_image_paths(temp_output_dir)
+            possible_error_msg = ""
+            num_parse_images = 0
+            for match in re.finditer(path_search_pattern, full_print_output):
+                potential_path_from_print = match.group(1)
+                num_parse_images += 1
+                if os.path.isfile(potential_path_from_print):
+                    if potential_path_from_print not in processed_paths_list:
+                        processed_paths_list.append(potential_path_from_print)
+                elif not error_msg:
+                    possible_error_msg = (
+                        f"Sandbox for {item_id}: Path '{potential_path_from_print}' "
+                        "found in print, but file does not exist or is not a file."
+                    )
+            if len(processed_paths_list) == 0:
+                if num_parse_images == len(possible_image_path_list):
+                    processed_paths_list = possible_image_path_list
+                else:
+                    path_search_pattern = (
+                        r"([^\s\'\"]+\.(?:jpg|jpeg|png|bmp|gif|tiff))"
+                    )
+                    list_of_all_matches = re.findall(
+                        path_search_pattern, full_print_output
+                    )
+                    if len(list_of_all_matches) == len(
+                            possible_image_path_list):
+                        processed_paths_list = possible_image_path_list
+                    else:
+                        error_msg = possible_error_msg
+
+            if not processed_paths_list and temp_output_dir not in code_to_execute:
+                try:
+                    processed_paths_list.append(full_print_output)
+                except ValueError:
+                    pass
+
+    except ImportError as e:
+        error_msg = (
+            f"Sandbox for {item_id}: Code execution failed due to ImportError. "
+            f"Ensure all required modules are available and correctly named: {e}"
+        )
+        if "cv2" in str(e).lower() and not cv2:
+            error_msg += (
+                f"(Note: cv2 was not available in the sandbox host environment): {e}"
+            )
+    except MemoryError as e:
+        error_msg = (
+            f"Sandbox for {item_id}: Code execution failed due to MemoryError. "
+            f"The operation likely consumed too much memory: {e}"
+        )
+    except SyntaxError as e:  # Catch syntax errors from exec itself
+        error_msg = (
+            f"Sandbox for {item_id}: Code execution failed due to SyntaxError: {e}"
+        )
+    except Exception as e:
+        error_msg = f"Sandbox for {item_id}: Code execution failed: {e}"
+
+    return_dict["processed_paths_list"] = processed_paths_list
+    return_dict["print_output"] = full_print_output
+    return_dict["error"] = error_msg
+
+    if full_print_output is not None and not processed_paths_list:
+        error_msg = f"Sandbox for {item_id}: Path/result output error, unable to match save path"
+
+    picklable_variables = {}
+    imports_to_persist = {}
+
+    for name, value in sandbox_locals.items():
+        if name == "__builtins__":
+            continue
+        if name in sandbox_globals_always.keys():
+            continue
+        if isinstance(value, types.ModuleType):
+            imports_to_persist[name] = value.__name__
+        else:
+            try:
+                # pickle.dumps(value)
+                picklable_variables[name] = value
+            except (pickle.PicklingError, TypeError):
+                print(
+                    f"Warning: Var '{name}' of type {type(value).__name__} is not picklable.",
+                    file=sys.stderr,
+                )
+
+    # Store the final state of globals and locals
+    return_dict["execution_context"] = {
+        "globals": imports_to_persist,
+        "locals": picklable_variables,
+    }
+    return return_dict
+
+
+def execute_code_in_sandbox(
+    code_to_execute,
+    input_image_path,
+    item_id="N/A",
+    temp_output_dir=None,
+    previous_execution_context=None,
+):
+    """
+    Executes Python code in a restricted sandbox using timeout_decorator.
+
+    Args:
+        code_to_execute (str): The Python code string to execute.
+        input_image_path (str): Path to the user image.
+        item_id (str): Identifier for logging.
+        temp_output_dir (str): Directory for processed images.
+        previous_execution_context (dict, optional): Context from a previous execution.
+
+    Returns:
+        tuple: (processed_file_paths_list, captured_print_output,
+                error_message_or_none, current_execution_context)
+    """
+    if temp_output_dir is None:
+        temp_output_dir = TEMP_PROCESSED_IMAGES_DIR
+    if check_dangerous_code(code_to_execute):
+        return (
+            [],
+            "",
+            (
+                f"Sandbox for {item_id}: Code contains potentially dangerous system operations "
+                "such as remove. Execution denied.",
+            ),
+            None,
+        )
+
+    ensure_temp_dir(temp_output_dir)
+    with ReadOnlyPath(input_image_path):
+        try:
+            # Directly call the decorated function
+            result_dict = _sandboxed_execution_target(
+                code_to_execute,
+                input_image_path,
+                temp_output_dir,
+                item_id,
+                previous_execution_context,
+            )
+
+            # Unpack results from the returned dictionary
+            processed_paths_list = result_dict.get("processed_paths_list", [])
+            full_print_output = result_dict.get("print_output", "")
+            error_msg = result_dict.get("error", None)
+            current_execution_context = result_dict.get(
+                "execution_context", {"globals": {}, "locals": {}}
+            )
+
+        except timeout_decorator.TimeoutError:
+            # Handle the timeout gracefully
+            error_msg = f"Sandbox for {item_id}: Execution timed out after {EXEC_TIME_LIMIT} seconds."
+            print(error_msg)
+            processed_paths_list = []
+            full_print_output = ""
+            current_execution_context = None
+
+    return processed_paths_list, full_print_output, error_msg, current_execution_context
diff --git a/VLMEvalKit-sudoku/vlmeval/vlm/valley/requirements_valley.txt b/VLMEvalKit-sudoku/vlmeval/vlm/valley/requirements_valley.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bf02cf41102849d570593ee460d3eb73b290e207
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/vlm/valley/requirements_valley.txt
@@ -0,0 +1,34 @@
+accelerate==0.34.2
+bert-score==0.3.13
+byted-wandb==0.13.72
+datasets==2.21.0
+einops==0.8.0
+evaluate==0.4.3
+fastapi==0.115.0
+flash_attn
+ftfy==6.2.3
+markdown2==2.5.0
+ninja==1.11.1.1
+nltk==3.9.1
+numpy==1.26.4
+omegaconf==2.3.0
+openai==0.28
+opencv-python-headless==4.10.0.84
+packaging==24.1
+pandas==2.2.2
+peft==0.5.0
+prettytable==3.11.0
+protobuf==3.20.3
+pyarrow==15.0.0
+pydantic==1.10.14
+qwen_vl_utils
+requests==2.32.3
+rouge-score==0.1.2
+scikit-image==0.24.0
+scikit-learn==1.5.2
+sentencepiece==0.1.97
+timm==0.6.7
+tokenizers>=0.13.3
+torchmetrics
+transformers==4.45.2
+uvicorn==0.30.6
diff --git a/VLMEvalKit-sudoku/vlmeval/vlm/valley/valley.py b/VLMEvalKit-sudoku/vlmeval/vlm/valley/valley.py
new file mode 100644
index 0000000000000000000000000000000000000000..ee4872ffa46e8882e20cf224192037b4521244be
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/vlm/valley/valley.py
@@ -0,0 +1,245 @@
+import re
+import torch
+import logging
+import string
+import pandas as pd
+from transformers import set_seed
+from transformers import AutoProcessor, AutoModel
+from ..base import BaseModel
+from ...dataset import DATASET_TYPE
+from ...smp import *
+
+
+class Valley2Chat(BaseModel):
+    """
+    A multimodal chat model interface for the Valley2 architecture. (https://arxiv.org/abs/2501.05901)
+
+    Attributes:
+        - seed (int): Random seed used for reproducibility. Default is 42.
+        - torch_dtype (torch.dtype): Data type for model weights (e.g., torch.bfloat16). Default is bfloat16.
+        - model_path (str): Hugging Face model path or local checkpoint directory for loading
+            the Valley2-DPO model. Default is 'bytedance-research/Valley2-DPO'.
+        - cot_output_trunc (bool): Whether to truncate model output by extracting the part between
+            <CONCLUSION> and </CONCLUSION> tags, if present. This is useful for structured
+            chain-of-thought outputs. Default is False.
+        - max_new_tokens (int): Maximum number of tokens to be generated during inference. Default is 2048.
+        - min_pixels (int): Minimum number of image pixels allowed after preprocessing. Default is 1280*28*28.
+        - max_pixels (int): Maximum number of image pixels allowed after preprocessing. Default is 16384*28*28.
+        - use_llava_cot_prompt (bool): Whether to enable LLaVA-CoT (Chain-of-Thought) prompting. If enabled,
+            "Please think step by step." is appended to the prompt to trigger detailed reasoning-style
+            outputs as in LLaVA-CoT (https://arxiv.org/abs/2411.10440). Default is False.
+        - use_custom_prompt (bool): Whether to enable custom prompts tailored to specific benchmarks. These prompts
+            have been manually optimized for individual datasets. Can be combined with `use_llava_cot_prompt`.
+            Default is True.
+        - use_custom_pixels (bool): Whether to enable benchmark-specific custom image pixel limits during
+            preprocessing. Some datasets benefit from lower or higher resolution constraints. Default is True.
+    """
+
+    def __init__(self,
+                 model_path='bytedance-research/Valley2-DPO',
+                 cot_output_trunc=False,
+                 max_new_tokens: int = 2048,
+                 seed=42,
+                 torch_dtype=torch.float16,
+                 min_pixels=1280 * 28 * 28,
+                 max_pixels=16384 * 28 * 28,
+                 use_llava_cot_prompt=False,
+                 use_custom_prompt=True,
+                 use_custom_pixels_limit=True,
+                 **kwargs):
+        set_seed(seed)
+        self.torch_dtype = torch_dtype
+        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+        logging.info(f"Start loading valley model from {model_path}")
+        self.model = AutoModel.from_pretrained(model_path, torch_dtype=self.torch_dtype, trust_remote_code=True)
+        self.model = self.model.to(self.device).half()
+        self.processor = AutoProcessor.from_pretrained(
+            model_path,
+            anyres=self.model.config.anyres,
+            max_pixels=max_pixels,
+            min_pixels=min_pixels,
+            trust_remote_code=True
+        )
+
+        self._use_llava_cot_prompt = use_llava_cot_prompt
+        self._use_custom_prompt = use_custom_prompt
+        self._use_custom_pixels_limit = use_custom_pixels_limit
+        self.cot_output_trunc = cot_output_trunc
+        self.max_pixels = max_pixels
+        self.min_pixels = min_pixels
+
+        kwargs_default = dict(do_sample=False, max_new_tokens=max_new_tokens, repetition_penalty=1.0) # noqa E501
+        kwargs_default.update(kwargs)
+        self.kwargs = kwargs_default
+
+    def use_custom_prompt(self, dataset):
+        if not self._use_custom_prompt:
+            return False
+        if any(dataset.startswith(prefix) for prefix in ['TextVQA', 'ChartQA', 'InfoVQA', 'DocVQA','CMMMU']):
+            return True
+        if any(dataset.startswith(prefix) for prefix in ['MMVet', 'MathVista', 'MathVerse', 'MathVision']):
+            return True
+        # if DATASET_TYPE(dataset) == 'Y/N' or DATASET_TYPE(dataset) == 'MCQ':
+        #     return True
+        return False
+
+    def build_yorn_prompt(self, line, dataset=None):
+        prompt = line['question']
+        prompt += '\nAnswer the question using a single word or phrase.'
+        return prompt
+
+    def build_multi_choice_prompt(self, line, dataset=None):
+        prompt = line['question']
+        hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+        if hint is not None:
+            prompt = hint + '\n' + prompt
+
+        options = {
+            cand: line[cand]
+            for cand in string.ascii_uppercase
+            if cand in line and not pd.isna(line[cand])
+        }
+        for key, item in options.items():
+            prompt += f'\n{key}. {item}'
+
+        if len(options):
+            prompt += "\nAnswer with the option's letter from the given choices directly."
+
+        return prompt
+
+    def build_mmvet_prompt(self, line, dataset=None):
+        prompt = line['question']
+        prompt += "\nProvide a step-by-step solution to the problem carefully."
+        return prompt
+
+    def build_math_prompt(self, line, dataset=None):
+        prompt = line['question']
+        prompt += (
+            "\nProvide a step-by-step solution to the problem, "
+            "and conclude with 'the answer is' followed by the final solution."
+        )
+        return prompt
+
+    def build_ocr_cmmmu_prompt(self, line, dataset=None):
+        prompt = line['question']
+        prompt += "\nPlease try to answer the question with short words or phrases if possible."
+        return prompt
+
+    def build_prompt(self, line, dataset=None):
+        assert self.use_custom_prompt(dataset)
+        assert isinstance(dataset, str)
+        tgt_path = self.dump_image(line, dataset)
+
+        if dataset == 'MMVet':
+            prompt = self.build_mmvet_prompt(line, dataset)
+        elif any(dataset.startswith(prefix) for prefix in ('TextVQA', 'ChartQA', 'InfoVQA', 'DocVQA','CMMMU')):
+            prompt = self.build_ocr_cmmmu_prompt(line, dataset)
+        elif any(dataset.startswith(prefix) for prefix in ('MathVista', 'MathVerse', 'MathVision')):
+            prompt = self.build_math_prompt(line, dataset)
+        # elif DATASET_TYPE(dataset) == 'Y/N':
+        #     prompt = self.build_yorn_prompt(line, dataset)
+        # elif DATASET_TYPE(dataset) == 'MCQ':
+        #     prompt = self.build_multi_choice_prompt(line, dataset)
+        else:
+            raise RuntimeError(f'Invalid dataset type: {DATASET_TYPE(dataset)}')
+
+        # add image to message
+        message = []
+        if isinstance(tgt_path, list):
+            message = [dict(type='image', value=p) for p in tgt_path]
+        else:
+            message = [dict(type='image', value=tgt_path)]
+
+        # add text to message
+        message.append(dict(type='text', value=prompt))
+        return message
+
+    def post_process(self, generation_text, dataset=None):
+        if any(dataset.startswith(prefix) for prefix in ('TextVQA', 'ChartQA', 'InfoVQA', 'DocVQA', 'CMMMU')):
+            self.cot_output_trunc = True  # froce truncate cot output
+
+        if self.cot_output_trunc:
+            pattern = r"(?:<CONCLUSION>)([\s\S]*?)(?:</CONCLUSION>)"
+            match = re.search(pattern, generation_text)
+            if match:
+                generation_text = match.group(1)
+
+        if any(dataset.startswith(prefix) for prefix in ('TextVQA', 'ChartQA', 'InfoVQA', 'DocVQA', 'CMMMU')):
+            generation_text = generation_text.strip()
+            if generation_text.endswith('.'):
+                generation_text = generation_text[:-1]
+        return generation_text
+
+    def get_pixels_limit(self, dataset=None):
+        if self._use_custom_pixels_limit and \
+                any(dataset.startswith(prefix) for prefix in ['OCRBench', 'HallusionBench', 'MMMU', 'MMBench']):
+            min_pixels = 100 * 28 * 28
+            max_pixels = 1280 * 28 * 28
+        else:
+            min_pixels = self.min_pixels
+            max_pixels = self.max_pixels
+        return min_pixels, max_pixels
+
+    def generate_inner(self, message, dataset=None):
+        # Construct messages and images
+        messages = []
+        text, images = '', []
+        for item in message:
+            if item['type'] == 'text':
+                text += item['value']
+            elif item['type'] == 'image':
+                text += ' <image> '
+                images.append(item['value'])
+
+        # Add CoT prompt, trigger the llava-cot output format
+        LLAVA_COT_PROMPT = "\nPlease think step by step."
+        if self._use_llava_cot_prompt:
+            messages.append({"role": 'user', "content": text + LLAVA_COT_PROMPT})
+        elif self._use_custom_prompt and dataset in ["MMMU_DEV_VAL", "MMStar", "OCRBench", "MMVet"]:
+            messages.append({"role": 'user', "content": text + LLAVA_COT_PROMPT})
+        else:
+            messages.append({"role": 'user', "content": text})
+
+        # Preprocess the messages and images
+        min_pixels, max_pixels = self.get_pixels_limit(dataset)
+        data_dict = self.processor(
+            {
+                "conversations": messages,
+                "images": images
+            },
+            min_pixels=min_pixels,
+            max_pixels=max_pixels
+        )
+
+        # Inference
+        with torch.inference_mode():
+            self.model.to(dtype=self.torch_dtype, device=self.device)
+
+            if type(data_dict["images"][0]) is list:
+                images = [
+                    [item.to(dtype=self.torch_dtype, device=self.device) for item in img]
+                    for img in data_dict["images"]
+                ]
+            else:
+                images = [img.to(dtype=self.torch_dtype, device=self.device) for img in data_dict["images"]]
+
+            output_ids = self.model.generate(
+                input_ids=data_dict["input_ids"].to(self.device),
+                images=images,
+                image_sizes=data_dict["image_sizes"],
+                pixel_values=data_dict["pixel_values"].to(dtype=self.torch_dtype, device=self.device),
+                image_grid_thw=data_dict["image_grid_thw"].to(self.device),
+                do_sample=self.kwargs["do_sample"],
+                max_new_tokens=self.kwargs["max_new_tokens"],
+                repetition_penalty=self.kwargs["repetition_penalty"],
+                return_dict_in_generate=True,
+                output_scores=True,
+            )
+        input_token_len = data_dict["input_ids"].shape[1]
+        generation_text = self.processor.batch_decode(output_ids.sequences[:, input_token_len:])[0]
+        generation_text = generation_text.replace("<|im_end|>", "")
+
+        # Postprocess
+        generation_text = self.post_process(generation_text, dataset)
+        return generation_text
diff --git a/VLMEvalKit-sudoku/vlmeval/vlm/xcomposer/__init__.py b/VLMEvalKit-sudoku/vlmeval/vlm/xcomposer/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..dbf4db400e3b7d60bde0214fb0e6a8a3fd3e0f5c
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/vlm/xcomposer/__init__.py
@@ -0,0 +1,7 @@
+from .sharecaptioner import ShareCaptioner
+from .xcomposer import XComposer
+from .xcomposer2 import XComposer2
+from .xcomposer2_4KHD import XComposer2_4KHD
+from .xcomposer2d5 import XComposer2d5
+
+__all__ = ['ShareCaptioner', 'XComposer', 'XComposer2', 'XComposer2_4KHD', 'XComposer2d5']
diff --git a/VLMEvalKit-sudoku/vlmeval/vlm/xcomposer/sharecaptioner.py b/VLMEvalKit-sudoku/vlmeval/vlm/xcomposer/sharecaptioner.py
new file mode 100644
index 0000000000000000000000000000000000000000..fddbef0f8fa6f76c5dbe0370b1a8acda843d83db
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/vlm/xcomposer/sharecaptioner.py
@@ -0,0 +1,92 @@
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from ..base import BaseModel
+from ...smp import *
+from ...dataset import DATASET_TYPE
+
+
+class ShareCaptioner(BaseModel):
+
+    INSTALL_REQ = False
+    INTERLEAVE = False
+
+    def __init__(self, model_path='Lin-Chen/ShareCaptioner', **kwargs):
+        assert model_path is not None
+        tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
+        self.model = AutoModelForCausalLM.from_pretrained(
+            model_path, device_map='cuda', trust_remote_code=True).eval()
+        self.model.tokenizer = tokenizer
+        self.model.cuda()
+        self.model.half()
+
+    def use_custom_prompt(self, dataset):
+        assert dataset is not None
+        if DATASET_TYPE(dataset) == 'MCQ':
+            return True
+        return False
+
+    def build_prompt(self, line, dataset=None):
+        assert dataset is None or isinstance(dataset, str)
+        assert self.use_custom_prompt(dataset)
+        tgt_path = self.dump_image(line, dataset)
+
+        if dataset is not None and DATASET_TYPE(dataset) == 'MCQ':
+            question = line['question']
+            hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+            if hint is not None:
+                question = hint + '\n' + question
+
+            option_candidate = string.ascii_uppercase
+            options = {
+                cand: line[cand]
+                for cand in option_candidate
+                if cand in line and not pd.isna(line[cand])
+            }
+            for key, item in options.items():
+                question += f'\n{key}. {item}'
+            prompt = question
+
+            if not cn_string(prompt):
+                prompt = prompt + '\n' + "Answer with the option's letter from the given choices directly."
+            else:
+                prompt = prompt + '\n' + '请直接回答选项字母。'
+        else:
+            prompt = line['question']
+        message = [dict(type='text', value=prompt)]
+        message.extend([dict(type='image', value=s) for s in tgt_path])
+        return message
+
+    def generate_inner(self, message, dataset=None):
+        prompt, image_path = self.message_to_promptimg(message, dataset=dataset)
+        seg1 = '<|User|>:'
+        seg2 = f'{prompt}{self.model.eoh}\n<|Bot|>:'
+        self.seg_emb1 = self.model.encode_text(seg1, add_special_tokens=True)
+        self.seg_emb2 = self.model.encode_text(seg2, add_special_tokens=False)
+
+        image = Image.open(image_path).convert('RGB')
+        image = self.model.vis_processor(image).unsqueeze(0)
+        image = image.to(self.model.device)
+        tmp_bs = image.shape[0]
+        tmp_seg_emb1 = self.seg_emb1.repeat(tmp_bs, 1, 1)
+        tmp_seg_emb2 = self.seg_emb2.repeat(tmp_bs, 1, 1)
+        with torch.cuda.amp.autocast():
+            with torch.no_grad():
+                image = self.model.encode_img(image)
+                input_emb = torch.cat(
+                    [tmp_seg_emb1, image, tmp_seg_emb2], dim=1)
+                out_embeds = self.model.internlm_model.generate(
+                    inputs_embeds=input_emb,
+                    max_length=500,
+                    num_beams=3,
+                    min_length=1,
+                    do_sample=True,
+                    repetition_penalty=1.5,
+                    length_penalty=1.0,
+                    temperature=1.,
+                    eos_token_id=self.model.tokenizer.eos_token_id,
+                    num_return_sequences=1)
+
+        for j, out in enumerate(out_embeds):
+            out[out == -1] = 2
+            response = self.model.decode_text([out])
+        return response
diff --git a/VLMEvalKit-sudoku/vlmeval/vlm/xcomposer/xcomposer.py b/VLMEvalKit-sudoku/vlmeval/vlm/xcomposer/xcomposer.py
new file mode 100644
index 0000000000000000000000000000000000000000..102a658238b0fa814477527d7d2ca910c99eb2b3
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/vlm/xcomposer/xcomposer.py
@@ -0,0 +1,148 @@
+import torch
+from transformers import AutoModel, AutoTokenizer
+from transformers import StoppingCriteria, StoppingCriteriaList
+from PIL import Image
+from ..base import BaseModel
+from ...smp import *
+from ...dataset import DATASET_TYPE
+
+
+class StoppingCriteriaSub(StoppingCriteria):
+    def __init__(self, stops=[], encounters=1):
+        super().__init__()
+        self.stops = stops
+
+    def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor):
+        for stop in self.stops:
+            if torch.all((stop == input_ids[0][-len(stop):])).item():
+                return True
+
+        return False
+
+
+class XComposer(BaseModel):
+
+    INSTALL_REQ = False
+    INTERLEAVE = False
+
+    def __init__(self, model_path='internlm/internlm-xcomposer-vl-7b', **kwargs):
+        assert model_path is not None
+        self.model_path = model_path
+
+        model = AutoModel.from_pretrained(self.model_path, device_map='cpu', trust_remote_code=True).cuda().eval()
+        tokenizer = AutoTokenizer.from_pretrained(self.model_path, trust_remote_code=True)
+        model.tokenizer = tokenizer
+        self.model = model
+        self.device = self.model.internlm_model.model.embed_tokens.weight.device
+        self.eoh = '<TOKENS_UNUSED_0>'
+        self.eoa = '<TOKENS_UNUSED_1>'
+        stop_words_ids = [
+            torch.tensor([103027]).to(self.device),  # end of human
+            torch.tensor([103028]).to(self.device),  # end of bot
+        ]
+        default_kwargs = {
+            'max_new_tokens': 512, 'num_beams': 5, 'do_sample': False,
+            'min_length': 1, 'repetition_penalty': 1.5, 'length_penalty': 1.0
+        }
+        default_kwargs.update(kwargs)
+        self.kwargs = default_kwargs
+        self.stopping_criteria = StoppingCriteriaList([StoppingCriteriaSub(stops=stop_words_ids)])
+
+    def generate_inner(self, message, dataset=None):
+        if len(message) == 2:
+            if message[0]['type'] == 'text' and message[1]['type'] == 'image':
+                message = [message[1], message[0]]
+        kwargs = cp.deepcopy(self.kwargs)
+        if dataset is not None:
+            if DATASET_TYPE(dataset) == 'MCQ':
+                kwargs['max_new_tokens'] = 5
+                kwargs['num_beams'] = 5
+
+        with torch.cuda.amp.autocast():
+            with torch.no_grad():
+                prompt_embs = self.message_to_prompt_embs(message, dataset)
+                outputs = self.model.internlm_model.generate(
+                    inputs_embeds=prompt_embs,
+                    stopping_criteria=self.stopping_criteria,
+                    **kwargs
+                )
+
+        output_token = outputs[0]
+        if output_token[0] == 0:
+            output_token = output_token[1:]
+        if output_token[0] == 1:
+            output_token = output_token[1:]
+        output_text = self.model.tokenizer.decode(output_token, add_special_tokens=False)
+
+        output_text = output_text.split(self.model.eoa)[0]
+        output_text = output_text.split('<|Bot|>')[-1].strip()
+        return output_text
+
+    def message_to_prompt_embs(self, message, dataset=None):
+        assert isinstance(message, list)
+        img_embeds = []
+        prompt_full = '<|User|>: '
+        for msg in message:
+            if msg['type'] == 'text':
+                prompt_full += msg['value']
+            elif msg['type'] == 'image':
+                image = Image.open(msg['value']).convert('RGB')
+                image = self.model.vis_processor(image).unsqueeze(0).to(self.device)
+                img_embeds.append(self.model.encode_img(image))
+                prompt_full += '<ImageHere>'
+
+        prompt_full += self.model.eoh + ' <|Bot|>: '
+        if dataset is not None and DATASET_TYPE(dataset) == 'MCQ':
+            prompt_full += 'Answer: The answer is '
+        elif dataset is not None and DATASET_TYPE(dataset) in ['VQA', 'QA', 'Y/N']:
+            prompt_full += 'Answer: '
+
+        prompt_segs = prompt_full.split('<ImageHere>')
+        assert len(prompt_segs) == len(img_embeds) + 1
+
+        prompt_seg_tokens = [
+            self.model.tokenizer(seg, return_tensors='pt', add_special_tokens=(i == 0)).to(self.device).input_ids.long()
+            for i, seg in enumerate(prompt_segs)
+        ]
+        prompt_seg_embs = [self.model.internlm_model.model.embed_tokens(seg) for seg in prompt_seg_tokens]
+        all_embeddings = []
+        for i in range(len(img_embeds)):
+            all_embeddings.extend([prompt_seg_embs[i], img_embeds[i]])
+        all_embeddings.append(prompt_seg_embs[-1])
+        prompt_embs = torch.cat(all_embeddings, dim=1)
+        return prompt_embs
+
+    def use_custom_prompt(self, dataset):
+        assert dataset is not None
+        if DATASET_TYPE(dataset) == 'MCQ':
+            return True
+        return False
+
+    def build_prompt(self, line, dataset=None):
+        assert dataset is None or isinstance(dataset, str)
+        assert self.use_custom_prompt(dataset)
+        tgt_path = self.dump_image(line, dataset)
+
+        question = line['question']
+        options = {
+            cand: line[cand]
+            for cand in string.ascii_uppercase
+            if cand in line and not pd.isna(line[cand])
+        }
+        options_prompt = ''
+        for key, item in options.items():
+            options_prompt += f'{key}. {item}\n'
+        hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+        context = 'N/A' if hint is None else hint
+        mid_prompt = 'Context: ' + context + '\nQuestion: ' + question
+        if len(options_prompt):
+            mid_prompt += '\nOptions: ' + options_prompt
+
+        if len(options):
+            txt_prompt = 'Please answer this question by choosing the correct choice.'
+        else:
+            txt_prompt = 'Please answer this question directly. '
+        prompt = txt_prompt + mid_prompt
+        message = [dict(type='text', value=prompt)]
+        message.extend([dict(type='image', value=s) for s in tgt_path])
+        return message
diff --git a/VLMEvalKit-sudoku/vlmeval/vlm/xcomposer/xcomposer2_4KHD.py b/VLMEvalKit-sudoku/vlmeval/vlm/xcomposer/xcomposer2_4KHD.py
new file mode 100644
index 0000000000000000000000000000000000000000..1ab2572752e230207f1ac9a1dadf33d63a9ddc01
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/vlm/xcomposer/xcomposer2_4KHD.py
@@ -0,0 +1,240 @@
+import torch
+from transformers import AutoModel, AutoTokenizer
+from PIL import Image
+from ..base import BaseModel
+from ...smp import *
+from ...dataset import DATASET_TYPE
+import numpy as np
+import torchvision.transforms as transforms
+
+import re
+pattern = re.compile(r'[A-Z]')
+
+
+def padding_336(b):
+    width, height = b.size
+    tar = int(np.ceil(height / 336) * 336)
+    top_padding = int((tar - height) / 2)
+    bottom_padding = tar - height - top_padding
+    left_padding = 0
+    right_padding = 0
+    b = transforms.functional.pad(b, [left_padding, top_padding, right_padding, bottom_padding], fill=[255, 255, 255])
+
+    return b
+
+
+def HD_transform(img, im_num=16):
+    width, height = img.size
+    trans = False
+    if width < height:
+        img = img.transpose(Image.TRANSPOSE)
+        trans = True
+        width, height = img.size
+    ratio = (width / height)
+    scale = 1
+    while scale * np.ceil(scale / ratio) <= im_num:
+        scale += 1
+    scale -= 1
+    new_w = int(scale * 336)
+    new_h = int(new_w / ratio)
+
+    img = transforms.functional.resize(img, [new_h, new_w],)
+    img = padding_336(img)
+    width, height = img.size
+    assert width * height <= im_num * 336 * 336
+    if trans:
+        img = img.transpose(Image.TRANSPOSE)
+
+    return img
+
+
+meta_instruction = """You are an AI assistant whose name is InternLM-XComposer (浦语·灵笔).
+- InternLM-XComposer (浦语·灵笔) is a multi-modality conversational language model that is developed\
+ by Shanghai AI Laboratory (上海人工智能实验室). It is designed to be helpful, honest, and harmless.
+- InternLM-XComposer (浦语·灵笔) can understand and communicate fluently in the language chosen by\
+ the user such as English and 中文.
+- InternLM-XComposer (浦语·灵笔) is capable of comprehending and articulating responses\
+ effectively based on the provided image."""
+
+
+def model_gen(model, text, images, need_bos=True, padding=False, beams=3, max_token=500):
+    pt1 = 0
+    embeds = []
+    im_mask = []
+    images = [images]
+    images_loc = [0]
+    for i, pts in enumerate(images_loc + [len(text)]):
+        subtext = text[pt1:pts]
+        if need_bos or len(subtext) > 0:
+            text_embeds = model.encode_text(subtext, add_special_tokens=need_bos)
+            embeds.append(text_embeds)
+            im_mask.append(torch.zeros(text_embeds.shape[:2]).cuda())
+            need_bos = False
+        if i < len(images):
+            try:
+                image = Image.open(images[i]).convert('RGB')
+            except:
+                image = images[i].convert('RGB')
+
+            image = HD_transform(image, im_num=model.hd_num)
+            image = model.vis_processor(image).unsqueeze(0).cuda()
+            image_embeds = model.encode_img(image)
+            embeds.append(image_embeds)
+            im_mask.append(torch.ones(image_embeds.shape[:2]).cuda())
+        pt1 = pts
+    embeds = torch.cat(embeds, dim=1)
+    im_mask = torch.cat(im_mask, dim=1)
+    im_mask = im_mask.bool()
+
+    outputs = model.generate(inputs_embeds=embeds, im_mask=im_mask,
+                             temperature=1.0, max_new_tokens=max_token, num_beams=beams,
+                             do_sample=False, repetition_penalty=1.0)
+    output_token = outputs[0]
+    if output_token[0] == 0 or output_token[0] == 1:
+        output_token = output_token[1:]
+    output_text = model.tokenizer.decode(output_token, add_special_tokens=False)
+    output_text = output_text.split('[UNUSED_TOKEN_145]')[0].strip()
+    return output_text
+
+
+class XComposer2_4KHD(BaseModel):
+
+    INSTALL_REQ = False
+    INTERLEAVE = False
+
+    def __init__(self, model_path='internlm/internlm-xcomposer2-4khd-7b', **kwargs):
+        assert model_path is not None
+        self.model_path = model_path
+
+        model = AutoModel.from_pretrained(self.model_path, device_map='cpu', trust_remote_code=True).cuda().eval()
+        model.half()
+        tokenizer = AutoTokenizer.from_pretrained(self.model_path, trust_remote_code=True)
+        model.tokenizer = tokenizer
+        self.model = model
+        self.device = self.model.model.tok_embeddings.weight.device
+        self.model.hd_num = 25
+
+    def generate_mme(self, image_path, text):
+        text = text.split('Please answer')[0].strip()
+        text = f'{text} Answer this question briefly'
+        text = f'[UNUSED_TOKEN_146]user\n{text}[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\n'
+
+        return model_gen(self.model, text, image_path, need_bos=True, padding=True, beams=5)
+
+    def generate_multichoice(self, image_path, text, dataset):
+        out = model_gen(self.model, text, image_path, need_bos=True, padding=False, beams=5, max_token=5)
+        if 'mmmu' in dataset.lower():
+            return out
+        res = pattern.findall(out)
+        if len(res) == 0:
+            print('Error:', out)
+            res = 'Z'
+        return res[0]
+
+    def generate_vqa(self, image_path, text):
+        out = model_gen(self.model, text, image_path, need_bos=True, max_token=100)
+        return out
+
+    def generate_vanilla(self, image_path, text):
+        out = model_gen(self.model, text, image_path, need_bos=True, max_token=500)
+        return out
+
+    def generate_brief(self, image_path, text):
+        text = '[UNUSED_TOKEN_146]user\nAnswer the question using a single word or phrase.{}\
+               [UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\n'.format(text)
+        out = model_gen(self.model, text, image_path, need_bos=True, max_token=10)
+        return out
+
+    def generate(self, message, dataset=None):
+        prompt, image_path = self.message_to_promptimg(message, dataset=dataset)
+        if listinstr(['docvqa_test', 'infovqa_test'], dataset.lower()):
+            self.model.hd_num = 65
+        elif listinstr(['docvqa_val', 'infovqa_val', 'OCRBench'], dataset.lower()):
+            self.model.hd_num = 55
+        elif listinstr(['mmlongbench_doc'], dataset.lower()):
+            self.model.hd_num = 45
+        elif listinstr(['mmmu', 'mmbench', 'mmvet'], dataset.lower()):
+            self.model.hd_num = 16
+        else:
+            self.model.hd_num = 25
+
+        with torch.cuda.amp.autocast():
+            if dataset is None:
+                return self.generate_vanilla(image_path, prompt)
+            assert isinstance(dataset, str)
+            if dataset == 'MME':
+                return self.generate_mme(image_path, prompt)
+
+            elif listinstr(['hallu'], dataset.lower()):
+                return self.generate_brief(image_path, prompt)
+
+            elif listinstr(['llava', 'mmvet'], dataset.lower()):
+                return self.generate_vanilla(image_path, prompt)
+
+            elif dataset is not None and DATASET_TYPE(dataset) == 'MCQ':
+                return self.generate_multichoice(image_path, prompt, dataset)
+
+            elif dataset is not None and DATASET_TYPE(dataset) == 'VQA':
+                return self.generate_vqa(image_path, prompt)
+
+            else:
+                return self.generate_vanilla(image_path, prompt)
+
+    def use_custom_prompt(self, dataset):
+        assert dataset is not None
+        if DATASET_TYPE(dataset) == 'MCQ' or DATASET_TYPE(dataset) == 'VQA':
+            return True
+        return False
+
+    def build_mcqa(self, line):
+        question = line['question']
+        options = {
+            cand: line[cand]
+            for cand in string.ascii_uppercase
+            if cand in line and not pd.isna(line[cand])
+        }
+        img_prompt = '[UNUSED_TOKEN_146]user\n'
+        if len(options):
+            options_prompt = ''
+            for key, item in options.items():
+                options_prompt += f'{key}. {item} '
+            options_prompt = options_prompt.strip()
+            hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+
+            context = 'N/A' if hint is None else hint
+            mid_prompt = 'Question: ' + question + '\nContext: ' + context + '\nOptions: ' + options_prompt
+            ans_prompt = '[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\nThe answer is'
+            prompt = img_prompt + mid_prompt + ans_prompt
+        else:
+            mid_prompt = f'Answer the question using a single word or phrase.{question}'
+            ans_prompt = '[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\n'
+            prompt = img_prompt + mid_prompt + ans_prompt
+
+        return prompt
+
+    def build_prompt(self, line, dataset=None):
+        assert dataset is None or isinstance(dataset, str)
+        assert self.use_custom_prompt(dataset)
+        tgt_path = self.dump_image(line, dataset)
+
+        if DATASET_TYPE(dataset) == 'MCQ':
+            prompt = self.build_mcqa(line)
+        elif DATASET_TYPE(dataset) == 'VQA':
+            if 'mathvista' in dataset.lower():
+                q = line['question']
+                prompt = f'[UNUSED_TOKEN_146]user\n{q}[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\n'
+            elif listinstr(['llava', 'mmvet'], dataset.lower()):
+                q = line['question']
+                prompt = '[UNUSED_TOKEN_146]system\n{}[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]user\n{}\
+                         Answer this question in detail.[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]\
+                         assistant\n'.format(meta_instruction, q)
+            elif listinstr(['mmlongbench_doc'], dataset.lower()):
+                q = line['question']
+                prompt = f'[UNUSED_TOKEN_146]user\n{q}[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\n'
+            else:
+                q = line['question']
+                prompt = f'[UNUSED_TOKEN_146]user\nAnswer the question using a single word or phrase.\
+                          {q}[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\n'
+        ret = [dict(type='text', value=prompt)]
+        ret.extend([dict(type='image', value=s) for s in tgt_path])
+        return ret
diff --git a/VLMEvalKit-sudoku/vlmeval/vlm/xcomposer/xcomposer2d5.py b/VLMEvalKit-sudoku/vlmeval/vlm/xcomposer/xcomposer2d5.py
new file mode 100644
index 0000000000000000000000000000000000000000..4120a5edfaaad7af500448ef43c5077b0f92dd83
--- /dev/null
+++ b/VLMEvalKit-sudoku/vlmeval/vlm/xcomposer/xcomposer2d5.py
@@ -0,0 +1,408 @@
+import re
+
+import numpy as np
+import torch
+import torchvision.transforms as transforms
+from PIL import Image, ImageDraw, ImageFont
+from transformers import AutoModel, AutoTokenizer
+
+from ...dataset import DATASET_TYPE
+from ...smp import *
+from ..base import BaseModel
+
+pattern = re.compile(r'[A-Z]')
+conv_pattern = '\\[UNUSED_TOKEN_146\\]user\\\n|\\[UNUSED_TOKEN_146\\]assistant\\\n|\\[UNUSED_TOKEN_145\\]'
+
+
+def get_font():
+    try:
+        truetype_url = "http://opencompass.openxlab.space/utils/Fonts/SimHei.ttf"
+        ff = urlopen(truetype_url)
+        font = ImageFont.truetype(ff, size=40)
+    except Exception as e:
+        logging.warning(f'{type(e)}: {e}')
+        logging.warning("Fail to download the font. Use the default one.")
+        font = ImageFont.load_default(size=40)
+    return font
+
+
+def padding_560(b):
+    width, height = b.size
+    tar = int(np.ceil(height / 560) * 560)
+    top_padding = int((tar - height) / 2)
+    bottom_padding = tar - height - top_padding
+    left_padding = 0
+    right_padding = 0
+    b = transforms.functional.pad(
+        b, [left_padding, top_padding, right_padding, bottom_padding], fill=[255, 255, 255])
+
+    return b
+
+
+def Identity_transform(img, hd_num=25):
+    width, height = img.size
+    trans = False
+    if width < height:
+        img = img.transpose(Image.TRANSPOSE)
+        trans = True
+        width, height = img.size
+    ratio = (width / height)
+    scale = 1
+    new_h = int(scale * 560)
+    new_w = int(new_h * ratio)
+    # print (new_h, new_w)
+
+    img = transforms.functional.resize(img, [new_h, new_w],)
+    img = img.transpose(Image.TRANSPOSE)
+    img = padding_560(img)
+    width, height = img.size
+    if not trans:
+        img = img.transpose(Image.TRANSPOSE)
+
+    return img
+
+
+def HD_transform(img, im_num=36, id_scale=1.5):
+    width, height = img.size
+    trans = False
+    if width < height:
+        img = img.transpose(Image.TRANSPOSE)
+        trans = True
+        width, height = img.size
+    ratio = (width / height)
+    scale = 1
+    while scale * np.ceil(scale / ratio) <= im_num:
+        scale += 1
+    scale -= 1
+
+    scale = min(np.ceil(width * id_scale / 560), scale)
+    new_w = int(scale * 560)
+    new_h = int(new_w / ratio)
+
+    try:
+        img = transforms.functional.resize(img, [new_h, new_w],)
+    except:
+        print((height, width))
+        print((new_h, new_w))
+        print(im_num)
+    img = padding_560(img)
+    width, height = img.size
+    assert width * height <= im_num * 560 * 560
+    if trans:
+        img = img.transpose(Image.TRANSPOSE)
+
+    return img
+
+
+def img_process(imgs):
+    new_imgs = []
+    for img in imgs:
+        w, h = img.size
+        scale = w / h
+        if w > h:
+            new_w = 560 * 2
+            new_h = int(560 * 2 / scale)
+        else:
+            new_w = int(560 * 2 * scale)
+            new_h = 560 * 2
+        img = transforms.functional.resize(img, [new_h, new_w],)
+        new_imgs.append(img)
+    imgs = new_imgs
+    new_w = 0
+    new_h = 0
+    pad = 40
+    if w > h:
+        for im in imgs:
+            w,h = im.size
+            new_w = max(new_w, w)
+            new_h += h + 10 + pad
+        font = get_font()
+        new_img = Image.new('RGB', (new_w, new_h), 'white')
+        draw = ImageDraw.Draw(new_img)
+        curr_h = 0
+        for idx, im in enumerate(imgs):
+            w,h = im.size
+            new_img.paste(im, (0, pad + curr_h))
+            draw.text((0, curr_h), f'<IMAGE {idx}>', font=font, fill='black')
+            if idx + 1 < len(imgs):
+                draw.line([(0, pad + curr_h + h + 5), (new_w, pad + curr_h + h + 5)], fill='black', width=2)
+            curr_h += h + 10 + pad
+        # print (new_w, new_h)
+    else:
+        for im in imgs:
+            w,h = im.size
+            new_w += w + 10
+            new_h = max(new_h, h)
+        new_h += pad
+        font = get_font()
+        new_img = Image.new('RGB', (new_w, new_h), 'white')
+        draw = ImageDraw.Draw(new_img)
+        curr_w = 0
+        for idx, im in enumerate(imgs):
+            w,h = im.size
+            new_img.paste(im, (curr_w, pad))
+            draw.text((curr_w, 0), f'<IMAGE {idx}>', font=font, fill='black')
+            if idx + 1 < len(imgs):
+                draw.line([(curr_w + w + 5, 0), (curr_w + w + 5, new_h)], fill='black', width=2)
+            curr_w += w + 10
+    return new_img
+
+
+meta_instruction = """You are an AI assistant whose name is InternLM (书生·浦语).\n" + "- InternLM (书生·浦语) \
+is a conversational language model that is developed by Shanghai AI Laboratory (上海人工智能实验室).
+It is designed to be helpful, honest, and harmless.\n"+"- InternLM (书生·浦语) \
+can understand and communicate fluently in the language chosen by the user such as English and 中文."""
+
+
+def model_gen(model, text, images, need_bos=True, padding=False, beams=3, max_token=2048, video_input=False):
+    embeds = []
+    im_mask = []
+    # print(text)
+
+    im_idx = 0
+    sub_q = text.split('<IM_POS>')
+    add_im = len(sub_q) - 1
+    for subtext in sub_q:
+        if need_bos or len(subtext) > 0:
+            text_embeds = model.encode_text(
+                subtext, add_special_tokens=need_bos)
+            embeds.append(text_embeds)
+            im_mask.append(torch.zeros(text_embeds.shape[:2]).to(model.device))
+            need_bos = False
+
+        if im_idx < len(images) and add_im:
+            image = images[im_idx]
+            if video_input:
+                image = Identity_transform(image)
+            else:
+                if len(images) > 1:
+                    image = HD_transform(image, im_num=max(4, model.hd_num // len(images)), id_scale=model.id_scale)
+                else:
+                    image = HD_transform(
+                        image, im_num=model.hd_num, id_scale=model.id_scale)
+            # print(image.size)
+            image = model.vis_processor(image).unsqueeze(0).to(model.device)
+            image_embeds = model.encode_img(image)
+            im_idx += 1
+            add_im -= 1
+            embeds.append(image_embeds)
+            im_mask.append(torch.ones(
+                image_embeds.shape[:2], dtype=torch.long).to(model.device))
+
+    embeds = torch.cat(embeds, dim=1)
+    im_mask = torch.cat(im_mask, dim=1)
+    im_mask = im_mask.bool()
+
+    outputs = model.generate(inputs_embeds=embeds, im_mask=im_mask,
+                             temperature=1.0, max_new_tokens=max_token, num_beams=beams,
+                             do_sample=False, repetition_penalty=1.0)
+
+    output_token = outputs[0]
+    if output_token[0] == 0 or output_token[0] == 1:
+        output_token = output_token[1:]
+    output_text = model.tokenizer.decode(output_token, add_special_tokens=False)
+    output_text = output_text.split('[UNUSED_TOKEN_145]')[0].strip().split('<|im_end|>')[0].strip().split('The answer is')[-1].strip()  # noqa
+    # print(output_text)
+    return output_text
+
+
+class XComposer2d5(BaseModel):
+
+    INSTALL_REQ = False
+    INTERLEAVE = True
+
+    def __init__(self, model_path='internlm/internlm-xcomposer2d5-7b', id_scale=1.5, beam=3, **kwargs):
+        assert model_path is not None
+        self.model_path = model_path
+        self.id_scale = id_scale
+        self.beam = beam
+
+        model = AutoModel.from_pretrained(
+            self.model_path, device_map='cpu', trust_remote_code=True, local_files_only=True).cuda().eval()
+        model.half()
+        tokenizer = AutoTokenizer.from_pretrained(
+            self.model_path, trust_remote_code=True)
+        model.tokenizer = tokenizer
+        self.model = model
+        self.device = self.model.model.tok_embeddings.weight.device
+        self.org_hd_num = 36
+        self.model.hd_num = 36
+        self.model.id_scale = self.id_scale
+
+    def message_to_promptimg(self, message, dataset=None, video_input=False):
+        num_images = len([x for x in message if x['type'] == 'image'])
+        if num_images == 0:
+            prompt = '\n'.join([x['value']
+                               for x in message if x['type'] == 'text'])
+            image = None
+
+        else:
+            image = [Image.open(x['value']).convert('RGB') for x in message if x['type'] == 'image']
+            if len(image) > 1:
+                self.model.hd_num = max(1, self.org_hd_num // len(image))
+            else:
+                self.set_max_num(dataset)
+
+            if video_input:
+                im_prompt = '<IM_POS>Here are some frames of a video.'
+                if len(image) > 64:
+                    step = len(image) / 64
+                    image = [image[int(i * step)] for i in range(64)]
+                image = [img_process(image)]
+
+            else:
+                if len(image) > 1:
+                    im_prompt = ' '.join([
+                        f'Image{im_idx + 1}: <IM_POS>;' for im_idx in range(len(image))])
+                else:
+                    im_prompt = '<IM_POS>'
+
+            prompt = ''
+            for x in message:
+                if x['type'] == 'text' and x.get('role', '') != 'system':
+                    prompt += x['value']
+            sp = [i for i in re.split(conv_pattern, prompt) if i != '' and i != '\n']
+            assert len(sp) <= 2
+            q = sp[0]
+            prompt = f'[UNUSED_TOKEN_146]user\n{im_prompt}{q}[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\n'
+
+            for idx in range(10):
+                idx = chr(65 + idx)
+                prompt = prompt.replace(f'({idx})', f'{idx}.')
+
+        return prompt, image
+
+    def generate_mme(self, image_path, text):
+        text = text.split('Please answer')[0].strip()
+        text = f'{text} Answer this question briefly'
+        text = f'[UNUSED_TOKEN_146]user\n{text}[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\n'
+
+        return model_gen(self.model, text, image_path, need_bos=True, padding=True, beams=self.beam)
+
+    def generate_multichoice(self, image_path, text, dataset):
+        out = model_gen(self.model, text, image_path,
+                        need_bos=True, padding=False, beams=self.beam, max_token=5)
+        if 'mmmu' in dataset.lower():
+            return out
+        res = pattern.findall(out)
+        if len(res) == 0:
+            print('Error:', out)
+            res = 'Z'
+        return res[0]
+
+    def generate_vqa(self, image_path, text):
+        out = model_gen(self.model, text, image_path, beams=self.beam,
+                        need_bos=True, max_token=100)
+        return out
+
+    def generate_vanilla(self, image_path, text):
+        out = model_gen(self.model, text, image_path, beams=self.beam,
+                        need_bos=True, max_token=500)
+        return out
+
+    def generate_brief(self, image_path, text):
+        text = '[UNUSED_TOKEN_146]user\nAnswer the question using a single word or phrase.{}\
+               [UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\n'.format(text)
+        out = model_gen(self.model, text, image_path, beams=self.beam,
+                        need_bos=True, max_token=10)
+        return out
+
+    def generate_video(self, image_path, text):
+        out = model_gen(
+            self.model, text, image_path, beams=1,  # self.beam,
+            need_bos=True, max_token=100, video_input=True)
+        return out
+
+    def set_max_num(self, dataset):
+        if dataset is not None and listinstr(['MME-RealWorld', 'MME-RealWorld-CN'], dataset):
+            self.model.hd_num = 25
+        else:
+            self.model.hd_num = self.org_hd_num
+
+    def generate_inner(self, message, dataset=None):
+        with torch.cuda.amp.autocast():
+            if dataset is None:
+                prompt, image_path = self.message_to_promptimg(message, dataset=dataset)
+                return self.generate_vanilla(image_path, prompt)
+            assert isinstance(dataset, str)
+
+            if listinstr(['video', 'mvbench'], dataset.lower()):
+                prompt, image_path = self.message_to_promptimg(message, dataset=dataset, video_input=True)
+                return self.generate_video(image_path, prompt)
+            else:
+                prompt, image_path = self.message_to_promptimg(message, dataset=dataset)
+                if dataset == 'MME':
+                    return self.generate_mme(image_path, prompt)
+                elif listinstr(['hallu', 'pope'], dataset.lower()):
+                    return self.generate_brief(image_path, prompt)
+                elif listinstr(['llava', 'mmvet'], dataset.lower()):
+                    return self.generate_vanilla(image_path, prompt)
+                elif dataset is not None and DATASET_TYPE(dataset) == 'MCQ':
+                    return self.generate_multichoice(image_path, prompt, dataset)
+                elif listinstr(['MME-RealWorld', 'MME-RealWorld-CN'], dataset):
+                    return self.generate_multichoice(image_path, prompt, dataset)
+                elif dataset is not None and DATASET_TYPE(dataset) == 'VQA':
+                    return self.generate_vqa(image_path, prompt)
+                else:
+                    return self.generate_vanilla(image_path, prompt)
+
+    def use_custom_prompt(self, dataset):
+        assert dataset is not None
+        if DATASET_TYPE(dataset) == 'MCQ' or DATASET_TYPE(dataset) == 'VQA':
+            return True
+        return False
+
+    def build_mcqa(self, line):
+        question = line['question']
+        options = {
+            cand: line[cand]
+            for cand in string.ascii_uppercase
+            if cand in line and not pd.isna(line[cand])
+        }
+        img_prompt = '[UNUSED_TOKEN_146]user\n'
+        if len(options):
+            options_prompt = ''
+            for key, item in options.items():
+                options_prompt += f'{key}. {item} '
+            options_prompt = options_prompt.strip()
+            hint = line['hint'] if (
+                'hint' in line and not pd.isna(line['hint'])) else None
+
+            context = 'N/A' if hint is None else hint
+            mid_prompt = 'Question: ' + question + '\nContext: ' + \
+                context + '\nOptions: ' + options_prompt
+            ans_prompt = '[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\nThe answer is'
+            prompt = img_prompt + mid_prompt + ans_prompt
+        else:
+            mid_prompt = f'Answer the question using a single word or phrase.{question}'
+            ans_prompt = '[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\n'
+            prompt = img_prompt + mid_prompt + ans_prompt
+
+        return prompt
+
+    def build_prompt(self, line, dataset=None):
+        assert dataset is None or isinstance(dataset, str)
+        assert self.use_custom_prompt(dataset)
+        tgt_path = self.dump_image(line, dataset)
+
+        if DATASET_TYPE(dataset) == 'MCQ':
+            prompt = self.build_mcqa(line)
+        elif DATASET_TYPE(dataset) == 'VQA':
+            if 'mathvista' in dataset.lower():
+                q = line['question']
+                prompt = f'[UNUSED_TOKEN_146]user\n{q}[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\n'
+            elif listinstr(['llava', 'mmvet'], dataset.lower()):
+                q = line['question']
+                prompt = '[UNUSED_TOKEN_146]system\n{}[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]user\n{}\
+                         Answer this question in detail.[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]\
+                         assistant\n'.format(meta_instruction, q)
+            elif listinstr(['mmlongbench_doc', 'dude', 'slidevqa'], dataset.lower()):
+                q = line['question']
+                prompt = f'[UNUSED_TOKEN_146]user\n{q}[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\n'
+            else:
+                q = line['question']
+                prefix = 'Answer the question using a single word or phrase.'
+                prompt = f'[UNUSED_TOKEN_146]user\n{prefix}{q}[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\n'
+        ret = [dict(type='text', value=prompt)]
+        ret.extend([dict(type='image', value=s) for s in tgt_path])
+        return ret