Add files using upload-large-folder tool

FinixDocBench_Eval_for_Markdown/examples/gt/sample_001.md

@@ -0,0 +1,10 @@
+# Sample Insurance Clause
+
+The policy covers accidental medical expenses during the insurance period.
+
+<table>
+  <tr><td>Item</td><td>Limit</td></tr>
+  <tr><td>Medical</td><td>10000</td></tr>
+</table>
+
+Final note.

FinixDocBench_Eval_for_Markdown/examples/pred/sample_001.md

@@ -0,0 +1,10 @@
+# Sample Insurance Clause
+
+The policy covers accidental medical expense during the insurance period.
+
+<table>
+  <tr><td>Item</td><td>Limit</td></tr>
+  <tr><td>Medical</td><td>9000</td></tr>
+</table>
+
+Final note.

FinixDocBench_Eval_for_Markdown/finixdoc_md_eval/metrics/table_metric.py

@@ -0,0 +1,260 @@
+# Copyright 2020 IBM
+# Author: peter.zhong@au1.ibm.com
+#
+# This is free software; you can redistribute it and/or modify
+# it under the terms of the Apache 2.0 License.
+#
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# Apache 2.0 License for more details.
+
+import Levenshtein
+# import rapidfuzz.distance as distance
+from apted import APTED, Config
+from apted.helpers import Tree
+from lxml import etree, html
+from collections import deque
+# from parallel import parallel_process
+from tqdm import tqdm
+
+class TableTree(Tree):
+    def __init__(self, tag, colspan=None, rowspan=None, content=None, *children):
+        self.tag = tag
+        self.colspan = colspan
+        self.rowspan = rowspan
+        self.content = content
+        self.children = list(children)
+
+    def bracket(self):
+        """Show tree using brackets notation"""
+        if self.tag == 'td':
+            result = '"tag": %s, "colspan": %d, "rowspan": %d, "text": %s' % \
+                     (self.tag, self.colspan, self.rowspan, self.content)
+        else:
+            result = '"tag": %s' % self.tag
+        for child in self.children:
+            result += child.bracket()
+        return "{{{}}}".format(result)
+
+
+class CustomConfig(Config):
+    @staticmethod
+    def maximum(*sequences):
+        """Get maximum possible value
+        """
+        return max(map(len, sequences))
+
+    def normalized_distance(self, *sequences):
+        """Get distance from 0 to 1
+        """
+        return float(Levenshtein.distance(*sequences)) / self.maximum(*sequences)
+
+    def rename(self, node1, node2):
+        """Compares attributes of trees"""
+        if (node1.tag != node2.tag) or (node1.colspan != node2.colspan) or (node1.rowspan != node2.rowspan):
+            return 1.
+        if node1.tag == 'td':
+            if node1.content or node2.content:
+                return self.normalized_distance(node1.content, node2.content)
+        return 0.
+
+
+class TEDS(object):
+    ''' Tree Edit Distance basead Similarity
+    '''
+    def __init__(self, structure_only=False, n_jobs=16, ignore_nodes=None):
+        assert isinstance(n_jobs, int) and (n_jobs >= 1), 'n_jobs must be an integer greather than 1'
+        self.structure_only = structure_only
+        self.n_jobs = n_jobs
+        self.ignore_nodes = ignore_nodes
+        self.__tokens__ = []
+
+    def tokenize(self, node):
+        ''' Tokenizes table cells
+        '''
+        self.__tokens__.append('<%s>' % node.tag)
+        if node.text is not None:
+            self.__tokens__ += list(node.text)
+        for n in node.getchildren():
+            self.tokenize(n)
+        if node.tag != 'unk':
+            self.__tokens__.append('</%s>' % node.tag)
+        if node.tag != 'td' and node.tail is not None:
+            self.__tokens__ += list(node.tail)
+
+    def load_html_tree(self, node, parent=None):
+        ''' Converts HTML tree to the format required by apted
+        '''
+        global __tokens__
+        if node.tag == 'td':
+            if self.structure_only:
+                cell = []
+            else:
+                self.__tokens__ = []
+                self.tokenize(node)
+                cell = self.__tokens__[1:-1].copy()
+            new_node = TableTree(node.tag,
+                                 int(node.attrib.get('colspan', '1')),
+                                 int(node.attrib.get('rowspan', '1')),
+                                 cell, *deque())
+        else:
+            new_node = TableTree(node.tag, None, None, None, *deque())
+        if parent is not None:
+            parent.children.append(new_node)
+        if node.tag != 'td':
+            for n in node.getchildren():
+                self.load_html_tree(n, new_node)
+        if parent is None:
+            return new_node
+
+    # def evaluate(self, pred, true):
+    #     ''' Computes TEDS score between the prediction and the ground truth of a
+    #         given sample
+    #     '''
+    #     if (not pred) or (not true):
+    #         return 0.0
+    #     parser = html.HTMLParser(remove_comments=True, encoding='utf-8')
+    #     pred = html.fromstring(pred, parser=parser)
+    #     true = html.fromstring(true, parser=parser)
+    #     if pred.xpath('body/table') and true.xpath('body/table'):
+    #         pred = pred.xpath('body/table')[0]
+    #         true = true.xpath('body/table')[0]
+    #         if self.ignore_nodes:
+    #             etree.strip_tags(pred, *self.ignore_nodes)
+    #             etree.strip_tags(true, *self.ignore_nodes)
+    #         n_nodes_pred = len(pred.xpath(".//*"))
+    #         n_nodes_true = len(true.xpath(".//*"))
+    #         n_nodes = max(n_nodes_pred, n_nodes_true)
+    #         tree_pred = self.load_html_tree(pred)
+    #         tree_true = self.load_html_tree(true)
+    #         distance = APTED(tree_pred, tree_true, CustomConfig()).compute_edit_distance()
+    #         return 1.0 - (float(distance) / n_nodes)
+    #     else:
+    #         return 0.0
+    # def evaluate(self, pred, true):
+    #     ''' Computes TEDS score between the prediction and the ground truth of a
+    #         given sample
+    #     '''
+    #     from multiprocessing import Process, Queue
+    #     import sys
+
+    #     def _evaluate_inner(pred, true, queue):
+    #         try:
+    #             if (not pred) or (not true):
+    #                 queue.put(0.0)
+    #                 return
+
+    #             parser = html.HTMLParser(remove_comments=True, encoding='utf-8')
+    #             pred_doc = html.fromstring(pred, parser=parser)
+    #             true_doc = html.fromstring(true, parser=parser)
+
+    #             if pred_doc.xpath('body/table') and true_doc.xpath('body/table'):
+    #                 pred_table = pred_doc.xpath('body/table')[0]
+    #                 true_table = true_doc.xpath('body/table')[0]
+    #                 if self.ignore_nodes:
+    #                     etree.strip_tags(pred_table, *self.ignore_nodes)
+    #                     etree.strip_tags(true_table, *self.ignore_nodes)
+    #                 n_nodes_pred = len(pred_table.xpath(".//*"))
+    #                 n_nodes_true = len(true_table.xpath(".//*"))
+    #                 n_nodes = max(n_nodes_pred, n_nodes_true)
+    #                 if n_nodes == 0:
+    #                     queue.put(1.0)
+    #                     return
+    #                 tree_pred = self.load_html_tree(pred_table)
+    #                 tree_true = self.load_html_tree(true_table)
+    #                 distance = APTED(tree_pred, tree_true, CustomConfig()).compute_edit_distance()
+    #                 score = 1.0 - (float(distance) / n_nodes)
+    #                 queue.put(score)
+    #             else:
+    #                 queue.put(0.0)
+    #         except Exception:
+    #             queue.put(0.0)
+
+    #     # 超时时间（秒），可调整
+    #     TIMEOUT_SECONDS = 60
+
+    #     q = Queue()
+    #     p = Process(target=_evaluate_inner, args=(pred, true, q))
+    #     p.start()
+    #     p.join(timeout=TIMEOUT_SECONDS)
+
+    #     if p.is_alive():
+    #         p.terminate()
+    #         p.join()
+    #         return 0.0
+    #     else:
+    #         if not q.empty():
+    #             return q.get()
+    #         else:
+    #             return 0.0
+
+    def evaluate(self, pred, true):
+        try:
+            if (not pred) or (not true):
+                return 0.0
+
+            parser = html.HTMLParser(remove_comments=True, encoding='utf-8')
+            pred_doc = html.fromstring(pred, parser=parser)
+            true_doc = html.fromstring(true, parser=parser)
+
+            pred_tables = pred_doc.xpath('//table')
+            true_tables = true_doc.xpath('//table')
+            if not pred_tables or not true_tables:
+                return 0.0
+
+            pred_table = pred_tables[0]
+            true_table = true_tables[0]
+
+            if self.ignore_nodes:
+                etree.strip_tags(pred_table, *self.ignore_nodes)
+                etree.strip_tags(true_table, *self.ignore_nodes)
+
+            n_td_pred = len(pred_table.xpath(".//td"))
+            n_td_true = len(true_table.xpath(".//td"))
+            if n_td_pred > 50000 or n_td_true > 50000:
+                print(f"Skipping large table: pred={n_td_pred}, true={n_td_true}", flush=True)
+                return 0.0
+
+            n_nodes_pred = len(pred_table.xpath(".//*"))
+            n_nodes_true = len(true_table.xpath(".//*"))
+            n_nodes = max(n_nodes_pred, n_nodes_true)
+            if n_nodes == 0:
+                return 1.0
+
+            tree_pred = self.load_html_tree(pred_table)
+            tree_true = self.load_html_tree(true_table)
+            distance = APTED(tree_pred, tree_true, CustomConfig()).compute_edit_distance()
+            return 1.0 - (float(distance) / n_nodes)
+        except Exception:
+            return 0.0
+
+
+    def batch_evaluate(self, pred_json, true_json):
+        ''' Computes TEDS score between the prediction and the ground truth of
+            a batch of samples
+            @params pred_json: {'FILENAME': 'HTML CODE', ...}
+            @params true_json: {'FILENAME': {'html': 'HTML CODE'}, ...}
+            @output: {'FILENAME': 'TEDS SCORE', ...}
+        '''
+        samples = true_json.keys()
+        # if self.n_jobs == 1:
+        scores = [self.evaluate(pred_json.get(filename, ''), true_json[filename]['html']) for filename in tqdm(samples)]
+        # else:
+        #     inputs = [{'pred': pred_json.get(filename, ''), 'true': true_json[filename]['html']} for filename in samples]
+        #     scores = parallel_process(inputs, self.evaluate, use_kwargs=True, n_jobs=self.n_jobs, front_num=1)
+        scores = dict(zip(samples, scores))
+        return scores
+
+
+if __name__ == '__main__':
+    import json
+    import pprint
+    with open('sample_pred.json') as fp:
+        pred_json = json.load(fp)
+    with open('sample_gt.json') as fp:
+        true_json = json.load(fp)
+    teds = TEDS(n_jobs=4)
+    scores = teds.batch_evaluate(pred_json, true_json)
+    pp = pprint.PrettyPrinter()
+    pp.pprint(scores)

FinixDocBench_Eval_for_Markdown/finixdoc_md_eval/omnidocbench_adapter.py

@@ -0,0 +1,226 @@
+import math
+import os
+from collections import defaultdict
+
+from .metrics.table_metric import TEDS
+from .utils.extract import md_tex_filter
+from .utils.match_quick import match_gt2pred_quick
+
+
+def _read_text(path):
+    with open(path, 'r', encoding='utf-8') as f:
+        return f.read()
+
+
+def _sequence_distance(a, b):
+    if a == b:
+        return 0
+    if a is None:
+        a = ''
+    if b is None:
+        b = ''
+    if len(a) < len(b):
+        a, b = b, a
+    if not b:
+        return len(a)
+
+    previous = list(range(len(b) + 1))
+    for i, ca in enumerate(a, 1):
+        current = [i]
+        for j, cb in enumerate(b, 1):
+            insert_cost = current[j - 1] + 1
+            delete_cost = previous[j] + 1
+            replace_cost = previous[j - 1] + (0 if ca == cb else 1)
+            current.append(min(insert_cost, delete_cost, replace_cost))
+        previous = current
+    return previous[-1]
+
+
+def _normalized_edit(a, b):
+    if a is None:
+        a = ''
+    if b is None:
+        b = ''
+    upper_len = max(len(a), len(b))
+    if upper_len == 0:
+        return 0.0, 0, 0
+    edit_num = _sequence_distance(a, b)
+    return edit_num / upper_len, edit_num, upper_len
+
+
+def _safe_mean(values, default=float('nan')):
+    values = [v for v in values if v is not None and not math.isnan(float(v))]
+    if not values:
+        return default
+    return sum(values) / len(values)
+
+
+def _get_order_paired(order_match_s, img_name):
+    matched = [
+        (item['gt_position'], item['pred_position'])
+        for item in order_match_s
+        if item['gt_position'] != [''] and item['pred_position'] != ''
+    ]
+    gt_idx_all = [item['gt_position'] for item in order_match_s if item['gt_position'] != ['']]
+    read_order_pred = [i[0] for i in sorted(matched, key=lambda x: x[1])]
+    read_order_gt = sum(gt_idx_all, [])
+    read_order_gt = [x for x in read_order_gt if x]
+    gt = sorted(read_order_gt)
+    pred = sum(read_order_pred, [])
+    pred = [x for x in pred if x]
+    if len(pred) > 0 or len(gt) > 0:
+        edit = _normalized_edit(gt, pred)[0]
+        return {
+            'gt': gt,
+            'pred': pred,
+            'img_id': img_name,
+            'edit': edit,
+        }
+    return {}
+
+
+def _calculate_edit_dist(samples):
+    if not samples:
+        return float('nan')
+
+    grouped = defaultdict(lambda: {'edit': 0, 'upper': 0})
+    for sample in samples:
+        img_name = sample['img_id']
+        if not (img_name.endswith('.jpg') or img_name.endswith('.png')):
+            img_name = '_'.join(img_name.split('_')[:-1])
+
+        gt = sample.get('norm_gt') if sample.get('norm_gt') is not None else sample.get('gt', '')
+        pred = sample.get('norm_pred') if sample.get('norm_pred') is not None else sample.get('pred', '')
+        _, edit_num, upper_len = _normalized_edit(pred, gt)
+        if upper_len == 0:
+            continue
+        grouped[img_name]['edit'] += edit_num
+        grouped[img_name]['upper'] += upper_len
+
+    page_scores = [
+        val['edit'] / val['upper']
+        for val in grouped.values()
+        if val['upper'] > 0
+    ]
+    return _safe_mean(page_scores)
+
+
+def _missing_table_samples(gt_tables, img_name):
+    samples = []
+    for idx, item in enumerate(gt_tables):
+        content = str(item.get('content', ''))
+        samples.append({
+            'gt_idx': [idx],
+            'gt': content,
+            'pred_idx': [''],
+            'pred': '',
+            'gt_position': [item.get('order') if item.get('order') else item.get('position', [''])[0]],
+            'pred_position': '',
+            'norm_gt': content,
+            'norm_pred': '',
+            'gt_category_type': item.get('fine_category_type') or item.get('category_type', 'table'),
+            'pred_category_type': '',
+            'gt_attribute': [item.get('attribute', {})],
+            'edit': 1,
+            'img_id': img_name,
+        })
+    return samples
+
+
+def _calculate_table_teds(table_samples):
+    if not table_samples:
+        return 100.0
+
+    teds = TEDS(structure_only=False)
+    scores = []
+    for sample in table_samples:
+        gt = sample.get('norm_gt') if sample.get('norm_gt') else sample.get('gt', '')
+        pred = sample.get('norm_pred') if sample.get('norm_pred') else sample.get('pred', '')
+        try:
+            score = teds.evaluate(pred, gt)
+        except Exception:
+            score = 0.0
+        scores.append(max(0.0, min(1.0, float(score))))
+    return _safe_mean(scores, default=0.0) * 100.0
+
+
+def _clamp(value, low, high):
+    if value is None or math.isnan(float(value)):
+        return value
+    return max(low, min(high, float(value)))
+
+
+def evaluate_md_dirs(gt_dir, pred_dir):
+    plain_text_match = []
+    html_table_match = []
+    latex_table_match = []
+    order_match = []
+
+    sample_names = sorted(name for name in os.listdir(gt_dir) if name.endswith('.md'))
+    for sample_name in sample_names:
+        img_name = sample_name[:-3] + '.jpg'
+        gt_content = _read_text(os.path.join(gt_dir, sample_name))
+        pred_path = os.path.join(pred_dir, sample_name)
+        pred_content = _read_text(pred_path) if os.path.exists(pred_path) else ''
+
+        gt_dataset = md_tex_filter(gt_content)
+        pred_dataset = md_tex_filter(pred_content)
+
+        plain_text_match_clean = []
+        if gt_dataset.get('text_all'):
+            plain_text_match_s = match_gt2pred_quick(
+                gt_dataset['text_all'],
+                pred_dataset.get('text_all', []),
+                'text',
+                img_name,
+            )
+            plain_text_match_clean = plain_text_match_s
+            plain_text_match.extend(plain_text_match_s)
+
+        if gt_dataset.get('latex_table'):
+            if pred_dataset.get('latex_table'):
+                table_match_s = match_gt2pred_quick(
+                    gt_dataset['latex_table'],
+                    pred_dataset['latex_table'],
+                    'latex_table',
+                    img_name,
+                )
+                latex_table_match.extend([x for x in table_match_s if x['gt_idx'] != ['']])
+            else:
+                latex_table_match.extend(_missing_table_samples(gt_dataset['latex_table'], img_name))
+        elif gt_dataset.get('html_table'):
+            if pred_dataset.get('html_table'):
+                table_match_s = match_gt2pred_quick(
+                    gt_dataset['html_table'],
+                    pred_dataset['html_table'],
+                    'html_table',
+                    img_name,
+                )
+                html_table_match.extend([x for x in table_match_s if x['gt_idx'] != ['']])
+            else:
+                html_table_match.extend(_missing_table_samples(gt_dataset['html_table'], img_name))
+
+        order_match_s = _get_order_paired(plain_text_match_clean, img_name)
+        if order_match_s:
+            order_match.append(order_match_s)
+
+    table_match = latex_table_match if latex_table_match else html_table_match
+    text_block_edit = _clamp(_calculate_edit_dist(plain_text_match), 0.0, 1.0)
+    reading_order_edit = _clamp(_calculate_edit_dist(order_match), 0.0, 1.0)
+    table_teds = _clamp(_calculate_table_teds(table_match), 0.0, 100.0)
+
+    if math.isnan(float(text_block_edit)):
+        text_block_edit = 0.0
+    if math.isnan(float(reading_order_edit)):
+        reading_order_edit = 0.0
+
+    overall = ((1 - text_block_edit) * 100.0 + (1 - reading_order_edit) * 100.0 + table_teds) / 3.0
+    overall = max(0.0, min(100.0, overall))
+
+    return {
+        'text_block_Edit_dist': text_block_edit,
+        'reading_order_Edit_dist': reading_order_edit,
+        'table_TEDS': table_teds,
+        'overall': overall,
+        'num_samples': len(sample_names),
+    }

FinixDocBench_Eval_for_Markdown/finixdoc_md_eval/utils/data_preprocess.py

@@ -0,0 +1,452 @@
+import re
+import unicodedata
+from pylatexenc.latex2text import LatexNodes2Text
+from bs4 import BeautifulSoup
+import subprocess
+import shutil
+import uuid
+import html
+import os
+
+def remove_markdown_fences(content):
+    content = re.sub(r'^```markdown\n?', '', content, flags=re.MULTILINE)
+    content = re.sub(r'^```html\n?', '', content, flags=re.MULTILINE)
+    content = re.sub(r'^```latex\n?', '', content, flags=re.MULTILINE)
+    content = re.sub(r'```\n?$', '', content, flags=re.MULTILINE)
+    return content
+
+# Standardize all consecutive characters
+def replace_repeated_chars(input_str):
+    input_str = re.sub(r'_{4,}', '____', input_str) # Replace more than 4 consecutive underscores with 4 underscores
+    input_str = re.sub(r' {4,}', '    ', input_str)   # Replace more than 4 consecutive spaces with 4 spaces
+    return input_str
+    # return re.sub(r'([^a-zA-Z0-9])\1{10,}', r'\1\1\1\1', input_str) # For other consecutive symbols (except numbers and letters), replace more than 10 occurrences with 4
+
+# Special Unicode handling
+def fullwidth_to_halfwidth(s):
+    result = []
+    for char in s:
+        code = ord(char)
+        # Convert full-width space to half-width space
+        if code == 0x3000:
+            code = 0x0020
+        # Convert other full-width characters to half-width
+        elif 0xFF01 <= code <= 0xFF5E:
+            code -= 0xFEE0
+        result.append(chr(code))
+    return ''.join(result)
+
+def find_special_unicode(s):
+    special_chars = {}
+    for char in s:
+        if ord(char) > 127:  # Non-ASCII characters
+            # unicode_name = unicodedata.name(char, None)
+            unicode_name = unicodedata.category(char)
+            special_chars[char] = f'U+{ord(char):04X} ({unicode_name})'
+    return special_chars
+
+# # Define dictionary for Unicode character replacements
+# unicode_replacements = {
+#     "\u00A9": r"$\copyright$",  # Copyright symbol © to latex
+#     "\u00AE": r"$^\circledR$",  # Registered trademark ® to latex
+#     "\u2122": r"$^\text{TM}$",   # Trademark ™ to latex
+#     "\u2018": "'",             # Left single quote to straight quote
+#     "\u2019": "'",             # Right single quote to straight quote
+#     "\u201C": "\"",            # Left double quote to straight quote
+#     "\u201D": "\"",            # Right double quote to straight quote
+#     "\u2013": "-",             # En dash to hyphen
+#     "\u2014": "-",             # Em dash to hyphen
+#     "\u2026": "...",           # Unicode ellipsis to three dots
+#     "\u2103": r"$\textdegree C$",  # ℃
+#     "\u03B1": r"$\alpha$",         # α
+#     "\u03B2": r"$\beta$",          # β
+#     "\u03A3": r"$\Sigma$",         # Σ
+# }
+
+# # Use regex to replace Unicode characters
+# def replace_unicode(match):
+#     char = match.group(0)
+#     return unicode_replacements.get(char, char)
+
+inline_reg = re.compile(
+    r'\$(.*?)\$|'
+    r'\\\((.*?)\\\)',
+)
+
+def textblock2unicode(text):
+    inline_matches = inline_reg.finditer(text)
+    removal_positions = []
+    for match in inline_matches:
+        position = [match.start(), match.end()]
+        content = match.group(1) if match.group(1) is not None else match.group(2)
+        # print('-------- content-------', content)
+        # Remove escape characters \
+        clean_content = re.sub(r'\\([\\_&%^])', '', content)
+
+        try:
+            if any(char in clean_content for char in r'\^_'):
+                if clean_content.endswith('\\'):
+                    clean_content += ' '
+                # inline_array.append(match.group(0))
+                unicode_content = LatexNodes2Text().latex_to_text(clean_content)
+                removal_positions.append((position[0], position[1], unicode_content))
+        except:
+            continue
+    
+    # Remove inline formulas from original text
+    for start, end, unicode_content in sorted(removal_positions, reverse=True):
+        text = text[:start] + unicode_content.strip() + text[end:]
+
+    return text
+
+def normalized_formula(text):
+    # Normalize math formulas before matching
+    filter_list = ['\\mathbf', '\\mathrm', '\\mathnormal', '\\mathit', '\\mathbb', '\\mathcal', '\\mathscr', '\\mathfrak', '\\mathsf', '\\mathtt', 
+                   '\\textbf', '\\text', '\\boldmath', '\\boldsymbol', '\\operatorname', '\\bm',
+                   '\\symbfit', '\\mathbfcal', '\\symbf', '\\scriptscriptstyle', '\\notag',
+                   '\\setlength', '\\coloneqq', '\\space', '\\thickspace', '\\thinspace', '\\medspace', '\\nobreakspace', '\\negmedspace',
+                   '\\quad', '\\qquad', '\\enspace', '\\substackw', ' ', '$$', '\\left', '\\right', '\\displaystyle', '\\text']
+                #    '\\left', '\\right', '{', '}', ' ']
+    
+    # delimiter_filter
+    text = text.strip().strip('$').strip('\n')
+    pattern = re.compile(r"\\\[(.+?)(?<!\\)\\\]")
+    match = pattern.search(text)
+
+    if match:
+        text = match.group(1).strip()
+    
+    tag_pattern = re.compile(r"\\tag\{.*?\}")
+    text = tag_pattern.sub('', text)
+    hspace_pattern = re.compile(r"\\hspace\{.*?\}")
+    text = hspace_pattern.sub('', text)
+    begin_pattern = re.compile(r"\\begin\{.*?\}")
+    text = begin_pattern.sub('', text)
+    end_pattern = re.compile(r"\\end\{.*?\}")
+    text = end_pattern.sub('', text)
+    col_sep = re.compile(r"\\arraycolsep.*?\}")
+    text = col_sep.sub('', text)
+    text = text.strip('.')
+    
+    for filter_text in filter_list:
+        text = text.replace(filter_text, '')
+        
+    # text = normalize_text(delimiter_filter(text))
+    # text = delimiter_filter(text)
+    text = text.lower()
+    return text
+
+def normalized_html_table(text):
+    def process_table_html(md_i):
+        """
+        pred_md format edit
+        """
+        def process_table_html(html_content):
+            soup = BeautifulSoup(html_content, 'html.parser')
+            th_tags = soup.find_all('th')
+            for th in th_tags:
+                th.name = 'td'
+            thead_tags = soup.find_all('thead')
+            for thead in thead_tags:
+                thead.unwrap()  # unwrap()会移除标签但保留其内容
+            math_tags = soup.find_all('math')
+            for math_tag in math_tags:
+                alttext = math_tag.get('alttext', '')
+                alttext = f'${alttext}$'
+                if alttext:
+                    math_tag.replace_with(alttext)
+            span_tags = soup.find_all('span')
+            for span in span_tags:
+                span.unwrap()
+            return str(soup)
+
+        table_res=''
+        table_res_no_space=''
+        if '<table' in md_i.replace(" ","").replace("'",'"'):
+            md_i = process_table_html(md_i)
+            table_res = html.unescape(md_i).replace('\n', '')
+            table_res = unicodedata.normalize('NFKC', table_res).strip()
+            pattern = r'<table\b[^>]*>(.*)</table>'
+            tables = re.findall(pattern, table_res, re.DOTALL | re.IGNORECASE)
+            table_res = ''.join(tables)
+            # table_res = re.sub('<table.*?>','',table_res)
+            table_res = re.sub('( style=".*?")', "", table_res)
+            table_res = re.sub('( height=".*?")', "", table_res)
+            table_res = re.sub('( width=".*?")', "", table_res)
+            table_res = re.sub('( align=".*?")', "", table_res)
+            table_res = re.sub('( class=".*?")', "", table_res)
+            table_res = re.sub('</?tbody>',"",table_res)
+            
+            table_res = re.sub(r'\s+', " ", table_res)
+            table_res_no_space = '<html><body><table border="1" >' + table_res.replace(' ','') + '</table></body></html>'
+            # table_res_no_space = re.sub(' (style=".*?")',"",table_res_no_space)
+            # table_res_no_space = re.sub(r'[ ]', " ", table_res_no_space)
+            table_res_no_space = re.sub('colspan="', ' colspan="', table_res_no_space)
+            table_res_no_space = re.sub('rowspan="', ' rowspan="', table_res_no_space)
+            table_res_no_space = re.sub('border="', ' border="', table_res_no_space)
+
+            table_res = '<html><body><table border="1" >' + table_res + '</table></body></html>'
+            # table_flow.append(table_res)
+            # table_flow_no_space.append(table_res_no_space)
+
+        return table_res, table_res_no_space
+    
+    def clean_table(input_str,flag=True):
+        if flag:
+            input_str = input_str.replace('<sup>', '').replace('</sup>', '')
+            input_str = input_str.replace('<sub>', '').replace('</sub>', '')
+            input_str = input_str.replace('<span>', '').replace('</span>', '')
+            input_str = input_str.replace('<div>', '').replace('</div>', '')
+            input_str = input_str.replace('<p>', '').replace('</p>', '')
+            input_str = input_str.replace('<spandata-span-identity="">', '')
+            input_str = re.sub('<colgroup>.*?</colgroup>','',input_str)
+        return input_str
+    
+    norm_text, _ = process_table_html(text)
+    norm_text = clean_table(norm_text)
+    return norm_text
+
+def normalized_latex_table(text):
+    def latex_template(latex_code):  
+        template = r'''
+        \documentclass[border=20pt]{article}
+        \usepackage{subcaption}
+        \usepackage{url}
+        \usepackage{graphicx}
+        \usepackage{caption}
+        \usepackage{multirow}
+        \usepackage{booktabs}
+        \usepackage{color}
+        \usepackage{colortbl}
+        \usepackage{xcolor,soul,framed}
+        \usepackage{fontspec}
+        \usepackage{amsmath,amssymb,mathtools,bm,mathrsfs,textcomp}
+        \setlength{\parindent}{0pt}''' + \
+        r'''
+        \begin{document}
+        ''' + \
+        latex_code + \
+        r'''
+        \end{document}'''
+    
+        return template
+
+    def process_table_latex(latex_code):
+        SPECIAL_STRINGS= [
+            ['\\\\vspace\\{.*?\\}', ''],
+            ['\\\\hspace\\{.*?\\}', ''],
+            ['\\\\rule\\{.*?\\}\\{.*?\\}', ''],
+            ['\\\\addlinespace\\[.*?\\]', ''],
+            ['\\\\addlinespace', ''],
+            ['\\\\renewcommand\\{\\\\arraystretch\\}\\{.*?\\}', ''],
+            ['\\\\arraystretch\\{.*?\\}', ''],
+            ['\\\\(row|column)?colors?\\{[^}]*\\}(\\{[^}]*\\}){0,2}', ''],
+            ['\\\\color\\{.*?\\}', ''],
+            ['\\\\textcolor\\{.*?\\}', ''],
+            ['\\\\rowcolor(\\[.*?\\])?\\{.*?\\}', ''],
+            ['\\\\columncolor(\\[.*?\\])?\\{.*?\\}', ''],
+            ['\\\\cellcolor(\\[.*?\\])?\\{.*?\\}', ''],
+            ['\\\\colorbox\\{.*?\\}', ''],
+            ['\\\\(tiny|scriptsize|footnotesize|small|normalsize|large|Large|LARGE|huge|Huge)', ''],
+            [r'\s+', ' '],
+            ['\\\\centering', ''],
+            ['\\\\begin\\{table\\}\\[.*?\\]', '\\\\begin{table}'],
+            ['\t', ''],
+            ['@{}', ''],
+            ['\\\\toprule(\\[.*?\\])?', '\\\\hline'],
+            ['\\\\bottomrule(\\[.*?\\])?', '\\\\hline'],
+            ['\\\\midrule(\\[.*?\\])?', '\\\\hline'],
+            ['p\\{[^}]*\\}', 'l'],
+            ['m\\{[^}]*\\}', 'c'],
+            ['\\\\scalebox\\{[^}]*\\}\\{([^}]*)\\}', '\\1'],
+            ['\\\\textbf\\{([^}]*)\\}', '\\1'],
+            ['\\\\textit\\{([^}]*)\\}', '\\1'],
+            ['\\\\cmidrule(\\[.*?\\])?\\(.*?\\)\\{([0-9]-[0-9])\\}', '\\\\cline{\\2}'],
+            ['\\\\hline', ''],
+            [r'\\multicolumn\{1\}\{[^}]*\}\{((?:[^{}]|(?:\{[^{}]*\}))*)\}', r'\1']
+        ]
+        pattern = r'\\begin\{tabular\}.*\\end\{tabular\}'  # 注意这里不用 .*?
+        matches = re.findall(pattern, latex_code, re.DOTALL)
+        latex_code = ' '.join(matches)
+
+        for special_str in SPECIAL_STRINGS:
+            latex_code = re.sub(fr'{special_str[0]}', fr'{special_str[1]}', latex_code)
+
+        return latex_code
+    
+    def convert_latex_to_html(latex_content, cache_dir='./temp'):
+        if not os.path.exists(cache_dir):
+            os.makedirs(cache_dir)
+
+        uuid_str = str(uuid.uuid1())
+        with open(f'{cache_dir}/{uuid_str}.tex', 'w') as f:
+            f.write(latex_template(latex_content))
+
+        cmd = ['latexmlc', '--quiet', '--nocomments', f'--log={cache_dir}/{uuid_str}.log',
+               f'{cache_dir}/{uuid_str}.tex', f'--dest={cache_dir}/{uuid_str}.html']
+        try:
+            subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            with open(f'{cache_dir}/{uuid_str}.html', 'r') as f:
+                html_content = f.read()
+
+            pattern = r'<table\b[^>]*>(.*)</table>'
+            tables = re.findall(pattern, html_content, re.DOTALL | re.IGNORECASE)
+            tables = [f'<table>{table}</table>' for table in tables]
+            html_content = '\n'.join(tables)
+        
+        except Exception as e:
+            html_content = ''
+        
+        shutil.rmtree(cache_dir)
+        return html_content
+    
+    html_text = convert_latex_to_html(text)
+    normlized_tables = normalized_html_table(html_text)
+    return normlized_tables
+
+
+def normalized_table(text, format='html'):
+    if format not in ['html', 'latex']:
+        raise ValueError('Invalid format: {}'.format(format))
+    else:
+        return globals()['normalized_{}_table'.format(format)](text)
+
+
+def textblock_with_norm_formula(text):
+    inline_matches = inline_reg.finditer(text)
+    removal_positions = []
+    for match in inline_matches:
+        position = [match.start(), match.end()]
+        content = match.group(1) if match.group(1) is not None else match.group(2)
+        # print('-------- content-------', content)
+
+        norm_content = normalized_formula(content)
+        removal_positions.append((position[0], position[1], norm_content))
+    
+    # Remove inline formulas from original text
+    for start, end, norm_content in sorted(removal_positions, reverse=True):
+        text = text[:start] + norm_content.strip() + text[end:]
+
+    return text
+
+# def inline_filter_unicode(text):
+#     # Ensure text is string type
+#     if not isinstance(text, str):
+#         text = str(text)
+    
+#     # Convert LaTeX content to Unicode representation
+#     text = LatexNodes2Text().latex_to_text(text)
+    
+#     inline_array = []
+#     inline_matches = inline_reg.finditer(text)
+    
+#     for match in inline_matches:
+#         position = [match.start(), match.end()]
+#         content = match.group(1) if match.group(1) is not None else match.group(2)
+        
+#         # Remove escape characters \
+#         clean_content = re.sub(r'\\([\\_&%^])', '', content)
+
+#         if any(char in clean_content for char in r'\^_'):
+#             # inline_array.append(match.group(0))
+#             inline_array.append({
+#                 'category_type': 'equation_inline',
+#                 'position': position,
+#                 'content': match.group(0),
+#             })
+#             text = text.replace(match.group(0), '')
+#             # print('-----Found inline formula: ', match.group(0))
+#         else:
+#             text = text.replace(match.group(0), content)
+#         # # Add to inline_array
+#         # inline_array.append({
+#         #     'category_type': 'equation_inline',
+#         #     'position': position,
+#         #     'content': content,
+#         # })
+        
+#         # # Remove matched formula from original text, can choose to replace with spaces or remove directly
+#         # text = text[:position[0]] + ' '*(position[1]-position[0]) + text[position[1]:]
+
+#     return text, inline_array
+
+def inline_filter_unicode(text):
+    # Ensure text is string type
+    if not isinstance(text, str):
+        text = str(text)
+    
+    # Replace inline formula boundary markers
+    #print('--------text-------',text)
+    placeholder = '__INLINE_FORMULA_BOUNDARY__'
+    text_copy = text.replace('$', placeholder).replace('\\(', placeholder).replace('\\)', placeholder)
+    #print('--------text_copy-------',text_copy)
+    # Convert LaTeX content to Unicode representation
+    text_copy = LatexNodes2Text().latex_to_text(text_copy)
+    #print('--------text_copy---unicode----',text_copy)
+    # Restore boundary markers
+    text_copy = text_copy.replace(placeholder, '$')
+    
+    inline_array = []
+    inline_matches = inline_reg.finditer(text_copy)
+    # Record positions of inline formulas to be removed
+    removal_positions = []
+    
+    for match in inline_matches:
+        position = [match.start(), match.end()]
+        content = match.group(1) if match.group(1) is not None else match.group(2)
+        print('-------- content-------', content)
+        # Remove escape characters \
+        clean_content = re.sub(r'\\([\\_&%^])', '', content)
+
+        if any(char in clean_content for char in r'\^_'):
+            # inline_array.append(match.group(0))
+            inline_array.append({
+                'category_type': 'equation_inline',
+                'position': position,
+                'content': content,
+            })
+            removal_positions.append((position[0], position[1]))
+    
+    # Remove inline formulas from original text
+    for start, end in sorted(removal_positions, reverse=True):
+        text = text[:start] + text[end:]
+
+    return text, inline_array
+
+def inline_filter(text):
+    # Ensure text is string type
+    if not isinstance(text, str):
+        text = str(text)
+    
+    inline_array = []
+    inline_matches = inline_reg.finditer(text)
+    
+    for match in inline_matches:
+        position = [match.start(), match.end()]
+        content = match.group(1) if match.group(1) is not None else match.group(2)
+        # print('inline_content: ', content)
+        
+        # Remove escape characters \
+        clean_content = re.sub(r'\\([\\_&%^])', '', content)
+
+        if any(char in clean_content for char in r'\^_'):
+            # inline_array.append(match.group(0))
+            inline_array.append({
+                'category_type': 'equation_inline',
+                'position': position,
+                'content': match.group(0),
+            })
+            text = text.replace(match.group(0), '')
+            # print('-----Found inline formula: ', match.group(0))
+        else:
+            text = text.replace(match.group(0), content)
+
+    return text, inline_array
+
+# Text OCR quality check processing:
+def clean_string(input_string):
+    # Use regex to keep Chinese characters, English letters and numbers
+    # input_string = input_string.replace('\\t', '').replace('\\n', '').replace('\t', '').replace('\n', '').replace('/t', '').replace('/n', '')
+    input_string = input_string.replace('\\t', '').replace('\\n', '').replace('\t', '').replace('\n', '').replace('/t', '').replace('/n', '')
+    cleaned_string = re.sub(r'[^\w\u4e00-\u9fff]', '', input_string)   # 只保留中英文和数字
+    return cleaned_string

FinixDocBench_Eval_for_Markdown/finixdoc_md_eval/utils/extract.py

@@ -0,0 +1,571 @@
+import re
+import os
+import json
+import copy
+#from  modules.table_utils import convert_markdown_to_html #end
+from .table_utils import convert_markdown_to_html
+import re
+import unicodedata
+from bs4 import BeautifulSoup
+from pylatexenc.latexencode import unicode_to_latex
+from pylatexenc.latex2text import LatexNodes2Text
+from pylatexenc.latexwalker import LatexWalker, LatexEnvironmentNode, LatexCharsNode, LatexGroupNode, LatexMacroNode, LatexSpecialsNode
+from collections import defaultdict
+import pdb
+from .data_preprocess import remove_markdown_fences, replace_repeated_chars, textblock_with_norm_formula, textblock2unicode
+
+
+def extract_tabular(text):
+    begin_pattern = r'\\begin{tabular}'
+    end_pattern = r'\\end{tabular}'
+
+    tabulars = []
+    positions = []
+    current_pos = 0
+    stack = []
+    
+    while current_pos < len(text):
+        begin_match = re.search(begin_pattern, text[current_pos:])
+        end_match = re.search(end_pattern, text[current_pos:])
+        
+        if not begin_match and not end_match:
+            break
+            
+        if begin_match and (not end_match or begin_match.start() < end_match.start()):
+            stack.append(current_pos + begin_match.start())
+            current_pos += begin_match.start() + len(end_pattern)
+        elif end_match:
+            if stack:
+                start_pos = stack.pop()
+                if not stack:
+                    end_pos = current_pos + end_match.start() + len(end_pattern)
+                    tabular_code = text[start_pos:end_pos]
+                    tabulars.append(tabular_code)
+                    positions.append((start_pos, end_pos))
+            current_pos += end_match.start() + len(end_pattern)
+        else:
+            current_pos += 1
+    
+    if stack:
+        new_start = stack[0] + len(begin_pattern)
+        new_tabulars, new_positions = extract_tabular(text[new_start:])
+        new_positions = [(start + new_start, end + new_start) for start, end in new_positions]
+        tabulars.extend(new_tabulars)
+        positions.extend(new_positions)
+
+    return tabulars, positions
+
+# math reg
+    # r'\\begin{equation\*?}(.*?)\\end{equation\*?}|'
+    # r'\\begin{align\*?}(.*?)\\end{align\*?}|'
+    # r'\\begin{gather\*?}(.*?)\\end{gather\*?}|'
+display_reg = re.compile(
+    # r'\\begin{equation\*?}(.*?)\\end{equation\*?}|'
+    # r'\\begin{align\*?}(.*?)\\end{align\*?}|'
+    # r'\\begin{gather\*?}(.*?)\\end{gather\*?}|'
+    # r'\\begin{array\*?}(.*?)\\end{array\*?}|'
+    r'\$\$(.*?)\$\$|'
+    r'\\\[(.*?)\\\]|'
+    r'\$(.*?)\$|'
+    r'\\\((.*?)\\\)',  
+    re.DOTALL
+)
+
+# inline_reg = re.compile(
+#     r'(?<!\$)\$(?!\$)(.*?)(?<!\$)\$(?!\$)|'
+#     r'\\\((.*?)\\\)',
+# )
+inline_reg = re.compile(
+    r'\$(.*?)\$|'
+    r'\\\((.*?)\\\)',
+)
+
+# table 
+table_reg = re.compile(
+    r'\\begin{table\*?}(.*?)\\end{table\*?}|'
+    r'\\begin{tabular\*?}(.*?)\\end{tabular\*?}',
+    re.DOTALL 
+)
+md_table_reg = re.compile(
+    r'\|\s*.*?\s*\|\n', 
+    re.DOTALL)
+html_table_reg = re.compile(
+    r'(<table.*?</table>)',
+    re.DOTALL
+)
+
+# title
+title_reg = re.compile(
+    r'^\s*#.*$', 
+    re.MULTILINE)
+
+# img
+img_pattern = r'!\[.*?\]\(.*?\)'
+
+# code block
+code_block_reg = re.compile(
+    r'```(\w+)\n(.*?)```',
+    re.DOTALL
+)
+
+def md_tex_filter(content):
+    '''
+    Input: 1 page md or tex content - String
+    Output: text, display, inline, table, title, code - list
+    '''
+    content = re.sub(img_pattern, '', content)  # remove image
+    content = remove_markdown_fences(content)   # remove markdown fences
+    content = replace_repeated_chars(content) # replace all consecutive characters
+    content = content.replace('<html>', '').replace('</html>', '').replace('<body>', '').replace('</body>', '')
+    
+    # # 使用正则表达式对unicode进行替换
+    # special_unicode = ''.join(unicode_replacements.keys())
+    # content = re.sub(f'[{special_unicode}]', replace_unicode, content)
+
+    # content = fullwidth_to_halfwidth(content)  # fullwidth to halfwidth, TODO: GT also needs this operation
+
+    # # pylatexenc's unicode to latex
+    # content = unicode_to_latex(content, unknown_char_warning=False)
+    # markdown_table_content[i, j] = LatexNodes2Text().latex_to_text(content_str)
+    # content_ori = copy.deepcopy(content)
+
+    # print('--------------After pre_process: \n', content)
+
+    pred_all = []
+    # deal with inline formula
+    # content_new, inline_array = inline_filter_unicode(content)
+    # #print('------------inline_array----------------',inline_array)
+    # for inline_item in inline_array:
+    #     inline_item['content'] = inline_to_unicode(inline_item['content'])
+    #     #print('------------inline_array_unicode----------------',inline_item['content'])
+    #     pred_all.append({
+    #         'category_type': 'text_all',
+    #         'position': inline_item['position'],
+    #         'content': inline_item['content'],
+    #         'fine_category_type': 'equation_inline'
+    #     })
+    
+    # extract latex table 
+    latex_table_array, table_positions = extract_tex_table(content)
+    for latex_table, position in zip(latex_table_array, table_positions):
+        position = [position[0], position[0]+len(latex_table)]   # !!!
+        pred_all.append({
+            'category_type': 'latex_table',
+            'position': position,
+            'content': latex_table
+        })
+        content = content[:position[0]] + ' '*(position[1]-position[0]) + content[position[1]:]  # replace latex table with space
+
+    # print('--------After latex table: \n', content)
+    # print('-------latex_table_array: \n', latex_table_array)
+
+    # extract html table  
+    html_table_array, table_positions = extract_html_table(content)
+    for html_table, position in zip(html_table_array, table_positions):
+        position = [position[0], position[0]+len(html_table)]
+        pred_all.append({
+            'category_type': 'html_table',
+            'position': position,
+            'content': html_table
+        })
+        content = content[:position[0]] + ' '*(position[1]-position[0]) + content[position[1]:]  # replace html table with space
+    # html_table_array = []
+    # html_table_matches = html_table_reg.finditer(content)
+    # if html_table_matches:
+    #     for match in html_table_matches:
+    #         matched = match.group(0)
+    #         position = [match.start(), match.end()]
+    #         html_table_array.append(matched.strip())
+    #         # content = content.replace(matched, ' '*len(matched)) # replace html table with space
+    #         content = content[:position[0]] + ' '*(position[1]-position[0]) + content[position[1]:]  # replace html table with space
+    #         pred_all.append({
+    #             'category_type': 'html_table',
+    #             'position': position,
+    #             'content': matched.strip()
+    #         })
+
+    # print('--------------After html table: \n', content)
+    # # extract tables in latex and html
+    # table_array = []
+    # table_matches = table_reg.finditer(content)
+    # tables = ""
+    # for match in table_matches:
+    #     matched = match.group(0)
+    #     if matched:
+    #         tables += matched
+    #         tables += "\n\n"
+    #         table_array.append(matched)
+    #         content = content.replace(matched, '')
+
+    # extract interline formula
+    display_matches = display_reg.finditer(content)
+    content_copy = content
+    for match in display_matches:
+        matched = match.group(0)
+        if matched:
+            # single_line = ''.join(matched.split())
+            single_line = ' '.join(matched.strip().split('\n'))
+            position = [match.start(), match.end()]
+            # replace $$ with \[\]
+            dollar_pattern = re.compile(r'\$\$(.*?)\$\$|\$(.*?)\$|\\\((.*?)\\\)', re.DOTALL)
+            sub_match = dollar_pattern.search(single_line)
+            if sub_match is None:
+                # pass
+                content = content[:position[0]] + ' '*(position[1]-position[0]) + content[position[1]:]
+                pred_all.append({
+                    'category_type': 'equation_isolated',
+                    'position': position,
+                    'content': single_line
+                })
+            elif sub_match.group(1):
+                single_line = re.sub(dollar_pattern, r'\\[\1\\]', single_line)
+                content = content[:position[0]] + ' '*(position[1]-position[0]) + content[position[1]:]  # replace equation with space
+                pred_all.append({
+                    'category_type': 'equation_isolated',
+                    'position': position,
+                    'content': single_line
+                })
+            else:
+                # start, end = match.span()
+                # char_before = content_copy[start-1] if start > 0           else '\n'
+                # char_after  = content_copy[end]   if end   < len(content_copy) else '\n'
+                # if char_before == '\n' or char_after == '\n':
+                #     single_line = re.sub(dollar_pattern, r'\\[\2\3\\]', single_line)
+                #     pred_all.append({
+                #         'category_type': 'equation_isolated',
+                #         'position': position,
+                #         'content': single_line,
+                #         'fine_category_type': 'equation_inline'
+                #     })
+                single_line = re.sub(dollar_pattern, r'\\[\2\3\\]', single_line)
+                pred_all.append({
+                    'category_type': 'equation_isolated',
+                    'position': position,
+                    'content': single_line,
+                    'fine_category_type': 'equation_inline'
+                })
+            # single_line = re.sub(dollar_pattern, r'\\[\1\2\3\\]', single_line)
+            # print('single_line: ', single_line)
+            # content = content.replace(matched, ' '*len(matched))
+            # pred_all.append({
+            #     'category_type': 'equation_isolated',
+            #     'position': position,
+            #     'content': single_line
+            # })
+            # print('-----Found display formula: ', matched)
+
+    # print('-------------After display: \n', content)
+    # extract md table with ||
+    md_table_mathces = md_table_reg.findall(content+'\n')
+    if len(md_table_mathces) >= 2:
+        # print("md table found!")
+        # print("content:", content)
+        content = convert_markdown_to_html(content)
+        # print('----------content after converting md table to html:', content)
+        html_table_matches = html_table_reg.finditer(content)
+        if html_table_matches:
+            for match in html_table_matches:
+                matched = match.group(0)
+                position = [match.start(), match.end()]
+                # content = content.replace(match, '')
+                # print('content after removing the md table:', content)
+                content = content[:position[0]] + ' '*(position[1]-position[0]) + content[position[1]:]  # replace md table with space
+                pred_all.append({
+                    'category_type': 'html_table',
+                    'position': position,
+                    'content': matched.strip(),
+                    'fine_category_type': 'md2html_table'
+                })
+    # print('---------After md table: \n', content)
+
+    # extract code blocks
+    code_matches = code_block_reg.finditer(content)
+    if code_matches:
+        for match in code_matches:
+            position = [match.start(), match.end()]
+            language = match.group(1)
+            code = match.group(2).strip()
+            # content = content.replace(match.group(0), '')
+            content = content[:position[0]] + ' '*(position[1]-position[0]) + content[position[1]:]  # replace code block with space
+            pred_all.append({
+                'category_type': 'text_all',
+                'position': position,
+                'content': code,
+                'language': language,
+                'fine_category_type': 'code'
+            })
+
+    # print('-------After code block: \n', content)
+
+    # # Extract titles: Do not extract titles, as some models do not wrap code blocks, causing all comments to be treated as titles
+    # title_matches = title_reg.finditer(content)
+    # if title_matches:
+    #     for match in title_matches:
+    #         position = [match.start(), match.end()]
+    #         matched = match.group(0)
+    #         matched = matched.replace("#", "").strip()
+    #         # content = content.replace(match, '')
+    #         # print('content after removing the titles:', content)
+    #         if matched:
+    #             # print('Add title: ', matched)
+    #             content = content[:position[0]] + ' '*(position[1]-position[0]) + content[position[1]:]
+    #             pred_all.append({
+    #                 'category_type': 'text_all',
+    #                 'position': position,
+    #                 'content': matched,
+    #                 'fine_category_type': 'title'
+    #             })
+    
+    # print('----------After title: \n', content)
+            
+    # # Delete extracted content
+    # extracted_position = [_['position'] for _ in pred_all]
+    # for start, end in sorted(extracted_position, reverse=True):
+    #     content = content[:start] + content[end:]
+
+    # print('----------After delete extracted: \n', content)
+
+    # Remove latex style
+    content = re.sub(r'\\title\{(.*?)\}', r'\1', content)
+    content = re.sub(r'\\title\s*\{\s*(.*?)\s*\}', r'\1', content, flags=re.DOTALL)
+    content = re.sub(r'\\text\s*\{\s*(.*?)\s*\}', r'\1', content, flags=re.DOTALL)
+    content = re.sub(r'\\section\*?\{(.*?)\}', r'\1', content)
+    content = re.sub(r'\\section\*?\{\s*(.*?)\s*\}', r'\1', content, flags=re.DOTALL)
+
+    # extract texts
+    res = content.split('\n\n')
+    if len(res) == 1:
+        res = content.split('\n')  # some models do not use double newlines, so use single newlines to split
+
+    content_position = 0
+    for text in res:
+        position = [content_position, content_position+len(text)]
+        content_position += len(text)
+        text = text.strip()
+        text = text.strip('\n')
+        # print('ori_text: ', text)
+        text = '\n'.join([_.strip() for _ in text.split('\n') if _.strip()])   # avoid some single newline content with many spaces
+        # print('after strip text: ', text)
+
+        if text:  # Check if the stripped text is not empty
+            if text.startswith('<table') and text.endswith('</table>'):
+                pred_all.append({
+                    'category_type': 'html_table',
+                    'position': position,
+                    'content': text,
+                })
+            # elif text.startswith('#') and '\n' not in text:
+            #     text = text.replace('#', '').strip()
+            #     if text:
+            #         # print('Add title: ', matched)
+            #         pred_all.append({
+            #             'category_type': 'text_all',
+            #             'position': position,
+            #             'content': text,
+            #             'fine_category_type': 'title'
+            #         })
+            elif text.startswith('$') and text.endswith('$'):
+                if text.replace('$', '').strip():
+                    pred_all.append({
+                        'category_type': 'equation_isolated',
+                        'position': position,
+                        'content': text.strip(),
+                    })
+            else:
+                text = text.strip()
+                if text:
+                    pred_all.append({
+                        'category_type': 'text_all',
+                        'position': position,
+                        'content': text,
+                        'fine_category_type': 'text_block'
+                    })
+                # if '$' in text:
+                #     for formula in re.findall(r'\$(.*?)\$', text):
+                #         formula_array.append(formula)
+
+    pred_dataset = defaultdict(list)
+    pred_all = sorted(pred_all, key=lambda x: x['position'][0])
+    for item in pred_all:
+        pred_dataset[item['category_type']].append(item)
+    # pdb.set_trace()
+    return pred_dataset
+
+
+# def replace_or_extract(match):
+#     content = match.group(1) if match.group(1) is not None else match.group(2)
+    
+#     if any(char in content for char in r'\^_'):
+#         inline_array.append(match.group(0))
+#         return ''
+#     else:
+#         return content
+
+# extract inline math equations in text
+# def inline_filter(text):
+
+#     inline_array = []
+#     inline_matches = inline_reg.finditer(text)
+#     for match in inline_matches:
+#         content = match.group(1) if match.group(1) is not None else match.group(2)
+        
+#         # remove \\, \_, \&, \%, \^
+#         clean_content = re.sub(r'\\([\\_&%^])', '', content)
+
+#         if any(char in clean_content for char in r'\^_'):
+#             inline_array.append(match.group(0))
+#             text = text.replace(match.group(0), '')
+#         else:
+#             text = text.replace(match.group(0), content)
+
+#     return text, inline_array
+
+# def extract_tex_table(content):
+#     tables = []
+#     positions = []
+
+#     walker = LatexWalker(content)
+#     nodes, _, _ = walker.get_latex_nodes()
+#     if nodes is None:
+#         return tables, positions
+
+#     for node in nodes:
+#         if isinstance(node, LatexEnvironmentNode) and (
+#             node.environmentname == 'tabular' or node.environmentname == 'table'):
+#             # table_latex = extract_node_content(node)
+#             table_latex = content[node.pos:node.pos_end]
+#             tables.append(table_latex)
+#             start_pos = node.pos
+#             end_pos = get_node_end_pos(node)
+#             positions.append((start_pos, end_pos))
+
+#     return tables, positions
+
+def extract_tex_table(content):
+    tables = []
+    tables_positions = []
+
+    pattern = r'\\begin{table}(.*?)\\end{table}'
+    for match in re.finditer(pattern, content, re.DOTALL):
+        start_pos = match.start()
+        end_pos = match.end()
+        table_content = match.group(0)
+        tables.append(table_content)
+        tables_positions.append((start_pos, end_pos))
+        content = content[:start_pos] + ' '*(end_pos-start_pos) + content[end_pos:]
+
+    tabulars, tabular_positions = extract_tabular(content)
+    all_tables = tables + tabulars
+    all_positions = tables_positions + tabular_positions
+
+    all_result = sorted([[pos, table]for pos, table in zip(all_positions, all_tables)], key=lambda x: x[0][0])
+    all_tables = [x[1] for x in all_result]
+    all_positions = [x[0] for x in all_result]
+
+    return all_tables, all_positions
+
+# def extract_html_table(content):
+#     soup = BeautifulSoup(content, 'html.parser')
+#     all_tables = soup.find_all('table')
+#     tables = []
+#     positions = []
+    
+#     for table in all_tables:
+#         if table.find_parent('table') is None:
+#             table_str = str(table)
+#             start_pos = content.find(table_str)
+#             end_pos = start_pos + len(table_str)
+            
+#             tables.append(table_str)
+#             positions.append((start_pos, end_pos))
+#     return tables, positions
+
+def extract_html_table(text):
+    begin_pattern = r'<table(?:[^>]*)>'
+    end_pattern = r'</table>'
+
+    tabulars = []
+    positions = []
+    current_pos = 0
+    stack = []
+    
+    while current_pos < len(text):
+        begin_match = re.search(begin_pattern, text[current_pos:])
+        end_match = re.search(end_pattern, text[current_pos:])
+        
+        if not begin_match and not end_match:
+            break
+            
+        if begin_match and (not end_match or begin_match.start() < end_match.start()):
+            stack.append(current_pos + begin_match.start())
+            current_pos += begin_match.start() + len(end_pattern)
+        elif end_match:
+            if stack:
+                start_pos = stack.pop()
+                if not stack:
+                    end_pos = current_pos + end_match.start() + len(end_pattern)
+                    tabular_code = text[start_pos:end_pos]
+                    tabulars.append(tabular_code)
+                    positions.append((start_pos, end_pos))
+            current_pos += end_match.start() + len(end_pattern)
+        else:
+            current_pos += 1
+    
+    if stack:
+        new_start = stack[0] + len(begin_pattern)
+        new_tabulars, new_positions = extract_html_table(text[new_start:])
+        new_positions = [(start + new_start, end + new_start) for start, end in new_positions]
+        tabulars.extend(new_tabulars)
+        positions.extend(new_positions)
+
+    return tabulars, positions
+
+
+def extract_node_content(node):
+    """ Recursively extract content from LatexEnvironmentNode and rebuild LaTeX table representation """
+    if isinstance(node, LatexCharsNode):
+        return node.chars  # Use chars attribute
+    elif isinstance(node, LatexGroupNode):
+        return "{" + "".join(extract_node_content(n) for n in node.nodelist) + "}"
+    elif isinstance(node, LatexMacroNode):
+        # Extract macro command and its arguments
+        macro_content = "\\" + node.macroname
+        if node.nodeargs:
+            macro_content += "".join([extract_node_content(arg) for arg in node.nodeargs])
+        return macro_content
+    elif isinstance(node, LatexEnvironmentNode):
+        # Extract environment, preserve environment name and arguments
+        content = "\\begin{" + node.environmentname + "}"
+        if node.nodeargd and node.nodeargd.argnlist:
+            # content += "".join("{" + extract_node_content(arg) + "}" for arg in node.nodeargd)
+            # content += "".join("{" + extract_node_content(node.nodeargd) + "}")
+            content += "{" + extract_node_content(node.nodeargd.argnlist[0]) + "}"
+        if node.nodelist:
+            content += "".join(extract_node_content(n) for n in node.nodelist)
+        content += "\\end{" + node.environmentname + "}"
+        return content
+    elif isinstance(node, LatexSpecialsNode):  # Changed to LatexSpecialsNode
+        return node.specials_chars
+    else:
+        return ""
+        
+def get_node_end_pos(node):
+    """Recursively determine the end position of a node"""
+    if hasattr(node, 'nodelist') and node.nodelist:
+        # If the node has child nodes, recursively find the end position of the last child node
+        return get_node_end_pos(node.nodelist[-1])
+    elif hasattr(node, 'pos_end'):
+        # If the node has pos_end attribute, return it directly
+        return node.pos_end
+    else:
+        # If there are no child nodes, assume the node ends at the last character of its content
+        return node.pos + len(str(node))
+
+def remove_tex_table(content):
+    tables, positions = extract_tex_table(content)
+
+    # Delete in reverse order by position to avoid affecting unprocessed start positions
+    for start, end in sorted(positions, reverse=True):
+        content = content[:start] + content[end:]  # Remove table content
+
+    return content

FinixDocBench_Eval_for_Markdown/finixdoc_md_eval/utils/match.py

@@ -0,0 +1,310 @@
+from scipy.optimize import linear_sum_assignment
+import Levenshtein
+import numpy as np
+import re
+import sys
+import pdb
+from .data_preprocess import textblock_with_norm_formula, normalized_formula, textblock2unicode, clean_string
+import re
+from bs4 import BeautifulSoup
+from copy import deepcopy
+
+def get_pred_category_type(pred_idx, pred_items):
+    if pred_items[pred_idx].get('fine_category_type'):
+        pred_pred_category_type = pred_items[pred_idx]['fine_category_type']
+    else:
+        pred_pred_category_type = pred_items[pred_idx]['category_type']
+    return pred_pred_category_type
+
+
+def compute_edit_distance_matrix_new(gt_lines, matched_lines):
+    try:
+        distance_matrix = np.zeros((len(gt_lines), len(matched_lines)))
+        for i, gt_line in enumerate(gt_lines):
+            for j, matched_line in enumerate(matched_lines):
+                if len(gt_line) == 0 and len(matched_line) == 0:
+                    distance_matrix[i][j] = 0  
+                else:
+                    distance_matrix[i][j] = Levenshtein.distance(gt_line, matched_line) / max(len(matched_line), len(gt_line))
+        return distance_matrix
+    except ZeroDivisionError:
+        raise  
+
+
+## 混合匹配here  0403
+def get_gt_pred_lines(gt_mix,pred_dataset_mix,line_type):
+
+    norm_html_lines,gt_lines,pred_lines,norm_gt_lines,norm_pred_lines,gt_cat_list = [],[],[],[],[],[]
+    if line_type in ['html_table','latex_table']:
+        for item in gt_mix:
+            if item.get('fine_category_type'):
+                gt_cat_list.append(item['fine_category_type'])
+            else:
+                gt_cat_list.append(item['category_type'])
+            if item.get('content'):
+                gt_lines.append(str(item['content']))
+                norm_html_lines.append(str(item['content']))
+            elif line_type == 'text':
+                gt_lines.append(str(item['text']))
+            elif line_type == 'html_table':
+                gt_lines.append(str(item['html']))
+            elif line_type == 'formula':
+                gt_lines.append(str(item['latex']))
+            elif line_type == 'latex_table':
+                try:
+                    gt_lines.append(str(item['latex']))
+                except:
+                    print(item)
+                    gt_lines.append("")
+                norm_html_lines.append(str(item['html']))
+        
+        pred_lines = [str(item['content']) for item in pred_dataset_mix]
+        if line_type == 'formula':
+            norm_gt_lines = [normalized_formula(_) for _ in gt_lines]
+            norm_pred_lines = [normalized_formula(_) for _ in pred_lines]
+        elif line_type == 'text':
+            norm_gt_lines = [clean_string(textblock2unicode(_)) for _ in gt_lines]
+            norm_pred_lines = [clean_string(textblock2unicode(_)) for _ in pred_lines]
+        else:
+            norm_gt_lines = gt_lines
+            norm_pred_lines = pred_lines
+        if line_type == 'latex_table':
+            gt_lines = norm_html_lines
+
+    else:
+        for item in pred_dataset_mix:
+            # text
+            if item['category_type'] == 'text_all':
+                pred_lines.append(str(item['content']))
+                norm_pred_lines.append(clean_string(textblock2unicode(str(item['content']))))
+            # formula
+            elif  item['category_type']=='equation_isolated':
+                pred_lines.append(str(item['content']))
+                norm_pred_lines.append(normalized_formula(str(item['content'])))
+            # table
+            else:
+                pred_lines.append(str(item['content']))
+                norm_pred_lines.append(str(item['content']))
+        
+        for item in gt_mix:
+            if item.get('content'):
+                gt_lines.append(str(item['content']))
+                if item['category_type'] == 'text_all':              
+                    norm_gt_lines.append(clean_string(textblock2unicode(str(item['content']))))
+                else:
+                   norm_gt_lines.append(item['content'])
+                
+                norm_html_lines.append(str(item['content']))
+
+                if item.get('fine_category_type'):
+                    gt_cat_list.append(item['fine_category_type'])
+                else:
+                    gt_cat_list.append(item['category_type'])
+            # text      
+            elif item['category_type'] in ['text_block', 'title', 'code_txt', 'code_txt_caption', 'reference', 'equation_caption','figure_caption', 'figure_footnote', 'table_caption', 'table_footnote', 'code_algorithm', 'code_algorithm_caption','header', 'footer', 'page_footnote', 'page_number']:
+                gt_lines.append(str(item['text']))
+                norm_gt_lines.append(clean_string(textblock2unicode(str(item['text']))))
+
+                if item.get('fine_category_type'):
+                    gt_cat_list.append(item['fine_category_type'])
+                else:
+                    gt_cat_list.append(item['category_type'])
+
+            # formula
+            elif item['category_type'] == 'equation_isolated':
+                gt_lines.append(str(item['latex']))
+                norm_gt_lines.append(normalized_formula(str(item['latex'])))
+
+                if item.get('fine_category_type'):
+                    gt_cat_list.append(item['fine_category_type'])
+                else:
+                    gt_cat_list.append(item['category_type'])
+            # table
+            # elif item['category_type'] == 'table':
+            #     gt_lines.append(str(item['html']))
+            #     norm_gt_lines.append(str(item['html']))
+
+            #     if item.get('fine_category_type'):
+            #         gt_cat_list.append(item['fine_category_type'])
+            #     else:
+            #         gt_cat_list.append(item['category_type'])
+
+
+    filtered_lists = [(a, b, c) for a, b, c in zip(gt_lines, norm_gt_lines, gt_cat_list) if a and b]
+
+    # decompress to three lists
+    if filtered_lists:
+        gt_lines_c, norm_gt_lines_c, gt_cat_list_c = zip(*filtered_lists)
+
+        # convert to lists
+        gt_lines_c = list(gt_lines_c)
+        norm_gt_lines_c = list(norm_gt_lines_c)
+        gt_cat_list_c = list(gt_cat_list_c)
+    else:
+        gt_lines_c = []
+        norm_gt_lines_c = []
+        gt_cat_list_c = []
+
+    # pred's empty values
+    filtered_lists = [(a, b) for a, b in zip(pred_lines, norm_pred_lines) if a and b]
+
+    # decompress to two lists
+    if filtered_lists:
+        pred_lines_c, norm_pred_lines_c = zip(*filtered_lists)
+
+        # convert to lists
+        pred_lines_c = list(pred_lines_c)
+        norm_pred_lines_c = list(norm_pred_lines_c)
+    else:
+        pred_lines_c = []
+        norm_pred_lines_c = []
+
+    return gt_lines_c, norm_gt_lines_c, gt_cat_list_c, pred_lines_c, norm_pred_lines_c, gt_mix, pred_dataset_mix
+
+
+def match_gt2pred_simple(gt_items, pred_items, line_type, img_name):
+
+    gt_lines, norm_gt_lines, gt_cat_list, pred_lines, norm_pred_lines, gt_items, pred_items = get_gt_pred_lines(gt_items, pred_items,line_type)
+    match_list = []
+
+    if not norm_gt_lines: # not matched pred should be concatenate
+        pred_idx_list = range(len(norm_pred_lines))
+        match_list.append({
+            'gt_idx': [""],
+            'gt': "",
+            'pred_idx': pred_idx_list,
+            'pred': ''.join(pred_lines[_] for _ in pred_idx_list), 
+            'gt_position': [""],
+            'pred_position': pred_items[pred_idx_list[0]]['position'][0],  # get the first pred's position
+            'norm_gt': "",
+            'norm_pred': ''.join(norm_pred_lines[_] for _ in pred_idx_list),
+            'gt_category_type': "",
+            'pred_category_type': get_pred_category_type(pred_idx_list[0], pred_items), # get the first pred's category
+            'gt_attribute': [{}],
+            'edit': 1,
+            'img_id': img_name
+        })
+        return match_list,None
+    elif not norm_pred_lines: # not matched gt should be separated
+        for gt_idx in range(len(norm_gt_lines)):
+            match_list.append({
+                'gt_idx': [gt_idx],
+                'gt': gt_lines[gt_idx],
+                'pred_idx': [""],
+                'pred': "",
+                'gt_position': [gt_items[gt_idx].get('order') if gt_items[gt_idx].get('order') else gt_items[gt_idx].get('position', [""])[0]],
+                'pred_position': "",
+                'norm_gt': norm_gt_lines[gt_idx],
+                'norm_pred': "",
+                'gt_category_type': gt_cat_list[gt_idx],
+                'pred_category_type': "",
+                'gt_attribute': [gt_items[gt_idx].get("attribute", {})],
+                'edit': 1,
+                'img_id': img_name
+            })
+        return match_list,None
+    
+    cost_matrix = compute_edit_distance_matrix_new(norm_gt_lines, norm_pred_lines)
+
+    row_ind, col_ind = linear_sum_assignment(cost_matrix)
+
+    
+    for gt_idx in range(len(norm_gt_lines)):
+        if gt_idx in row_ind:
+            row_i = list(row_ind).index(gt_idx)
+            pred_idx = int(col_ind[row_i])
+            pred_line = pred_lines[pred_idx]
+            norm_pred_line = norm_pred_lines[pred_idx]
+            edit = cost_matrix[gt_idx][pred_idx]
+        else:
+            pred_idx = ""
+            pred_line = ""
+            norm_pred_line = ""
+            edit = 1
+        
+
+        match_list.append({
+            'gt_idx': [gt_idx],
+            'gt': gt_lines[gt_idx],
+            'norm_gt': norm_gt_lines[gt_idx],
+            'gt_category_type': gt_cat_list[gt_idx],
+            'gt_position': [gt_items[gt_idx].get('order') if gt_items[gt_idx].get('order') else gt_items[gt_idx].get('position', [""])[0]],
+            'gt_attribute': [gt_items[gt_idx].get("attribute", {})],
+            'pred_idx': [pred_idx],
+            'pred': pred_line,
+            'norm_pred': norm_pred_line,
+            'pred_category_type': get_pred_category_type(pred_idx, pred_items) if pred_idx else "",
+            'pred_position': pred_items[pred_idx]['position'][0] if pred_idx else "",
+            'edit': edit,
+            'img_id': img_name
+        })
+    
+    pred_idx_list = [pred_idx for pred_idx in range(len(norm_pred_lines)) if pred_idx not in col_ind] # get not matched preds
+    if pred_idx_list:
+        if line_type in ['html_table', 'latex_table']:
+            unmatch_table_pred = []
+            for i in pred_idx_list:
+                original_item = pred_items[i]
+                soup = BeautifulSoup(original_item.get('content'),'html.parser')
+                text_block = [re.sub(r'\$\\cdot\$','',item.string).strip() for item in soup.findAll('td') if item.string]
+                for concatenate_text in text_block:
+                    new_item = deepcopy(original_item)
+                    new_item['content'] = concatenate_text
+                    new_item['category_type'] = 'text_all'  
+                    unmatch_table_pred.append(new_item)
+            return match_list, unmatch_table_pred  
+        
+        else:
+            match_list.append({
+                'gt_idx': [""],
+                'gt': "",
+                'pred_idx': pred_idx_list,
+                'pred': ''.join(pred_lines[_] for _ in pred_idx_list), 
+                'gt_position': [""],
+                'pred_position': pred_items[pred_idx_list[0]]['position'][0],  # get the first pred's position
+                'norm_gt': "",
+                'norm_pred': ''.join(norm_pred_lines[_] for _ in pred_idx_list),
+                'gt_category_type': "",
+                'pred_category_type': get_pred_category_type(pred_idx_list[0], pred_items), # get the first pred's category
+                'gt_attribute': [{}],
+                'edit': 1,
+                'img_id': img_name
+            })
+    return match_list,None
+
+
+def match_gt2pred_no_split(gt_items, pred_items, line_type, img_name):
+    # directly concatenate gt and pred by position
+    gt_lines, norm_gt_lines, gt_cat_list, pred_lines, norm_pred_lines = get_gt_pred_lines(gt_items, pred_items)
+    gt_line_with_position = []
+    for gt_line, norm_gt_line, gt_item in zip(gt_lines, norm_gt_lines, gt_items):
+        gt_position = gt_item['order'] if gt_item.get('order') else gt_item.get('position', [""])[0]
+        if gt_position:
+            gt_line_with_position.append((gt_position, gt_line, norm_gt_line))
+    sorted_gt_lines = sorted(gt_line_with_position, key=lambda x: x[0])
+    gt = '\n\n'.join([_[1] for _ in sorted_gt_lines])
+    norm_gt = '\n\n'.join([_[2] for _ in sorted_gt_lines])
+    pred_line_with_position = [(pred_item['position'], pred_line, pred_norm_line) for pred_line, pred_norm_line, pred_item in zip(pred_lines, norm_pred_lines, pred_items)]
+    sorted_pred_lines = sorted(pred_line_with_position, key=lambda x: x[0])
+    pred = '\n\n'.join([_[1] for _ in sorted_pred_lines])
+    norm_pred = '\n\n'.join([_[2] for _ in sorted_pred_lines])
+    # edit = Levenshtein.distance(norm_gt, norm_pred)/max(len(norm_gt), len(norm_pred))
+    if norm_gt or norm_pred:
+        return [{
+                'gt_idx': [0],
+                'gt': gt,
+                'norm_gt': norm_gt,
+                'gt_category_type': "text_merge",
+                'gt_position': [""],
+                'gt_attribute': [{}],
+                'pred_idx': [0],
+                'pred': pred,
+                'norm_pred': norm_pred,
+                'pred_category_type': "text_merge",
+                'pred_position': "",
+                # 'edit': edit,
+                'img_id': img_name
+            }]
+    else:
+        return []
+    

FinixDocBench_Eval_for_Markdown/finixdoc_md_eval/utils/match_quick.py

@@ -0,0 +1,1292 @@
+from scipy.optimize import linear_sum_assignment
+# from rapidfuzz.distance import Levenshtein
+import Levenshtein
+from collections import defaultdict
+import copy
+from .match import compute_edit_distance_matrix_new, get_gt_pred_lines, get_pred_category_type
+import pdb
+import numpy as np
+from collections import Counter
+from Levenshtein import distance as Levenshtein_distance
+
+import re
+from copy import deepcopy
+from typing import List, Dict, Any
+
+# ARRAY_RE = re.compile(
+#     r'\\begin\{array\}\{[^}]*\}(.*?)\\end\{array\}', re.S
+# )
+
+# def split_gt_equation_arrays(data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+#     """
+#     拆分带 \\begin{array} … \\end{array} 的 GT 字典条目。
+
+#     - 仅针对 category_type == 'equation_isolated' 且 latex 含 array。
+#     - 每行公式拆出一个新条目：
+#         * 更新 'latex'
+#         * 若存在 line_with_spans，则同步替换其内部 latex
+#         * 'order' 由 7 --> 7.1, 7.2, …
+#     """
+#     output = []
+
+#     for item in data:
+#         # 只处理满足条件的字典
+#         if (item.get("category_type") == "equation_isolated" and
+#                 "\\begin{array" in item.get("latex", "")):
+
+#             # 抽取 array 内部内容
+#             match = ARRAY_RE.search(item["latex"])
+#             if match:
+#                 body = match.group(1)           # 去掉 array 外壳
+#                 # 按 LaTeX 行分隔符 \\\\ 拆分
+#                 lines = [ln.strip() for ln in re.split(r'\\\\', body) if ln.strip()]
+
+#                 base_order = float(item["order"])  # 7 -> 7.0，可兼容 float/int
+
+#                 for idx, line in enumerate(lines, start=1):
+#                     new_item = deepcopy(item)
+#                     new_item["latex"] = f"\\[{line}\\]"
+#                     new_item["order"] = round(base_order + idx / 10, 1)
+#                     output.append(new_item)
+#                 continue  # 跳过把原 item 加入
+#         # 其它情况不修改
+#         output.append(item)
+
+#     return output
+
+# def _wrap(line: str) -> str:
+#     """给单行公式重新包 \\[ ... \\]"""
+#     return f"\\[{line.strip()}\\]"
+
+# def split_equation_arrays(data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+#     """
+#     处理 category_type == 'equation_isolated' 且含 \\begin{array} … 的条目：
+#     * 拆分多行公式
+#     * 重新包装 content
+#     * **重计算 position / positions**
+#     """
+#     out: List[Dict[str, Any]] = []
+
+#     for item in data:
+#         if (item.get("category_type") == "equation_isolated" and
+#                 "\\begin{array" in item.get("content", "")):
+
+#             content = item["content"]
+#             m = ARRAY_RE.search(content)
+#             if not m:
+#                 out.append(item)
+#                 continue
+
+#             body = m.group(1)
+#             lines = [ln.strip() for ln in re.split(r'\\\\', body) if ln.strip()]
+
+#             # 全局起始字符索引
+#             pos_key = "position" if "position" in item else "positions"
+#             global_start = item[pos_key][0]
+
+#             # array 正文在原 content 内的起点
+#             body_start_in_content = m.start(1)
+
+#             search_from = 0  # 在 body 中的游标
+#             for ln in lines:
+#                 # 在 body 中找到当前行的偏移
+#                 idx_in_body = body.find(ln, search_from)
+#                 if idx_in_body == -1:
+#                     # 不太可能发生；保守处理
+#                     idx_in_body = search_from
+#                 search_from = idx_in_body + len(ln)  # 更新游标
+
+#                 # 计算全局索引
+#                 line_start_global = global_start + body_start_in_content + idx_in_body
+#                 line_end_global   = line_start_global + len(ln) - 1
+
+#                 new_item = deepcopy(item)
+#                 new_item["content"] = _wrap(ln)
+#                 new_item[pos_key]   = [line_start_global, line_end_global]
+
+#                 out.append(new_item)
+
+#             # 拆分完成，不保留原条目
+#             continue
+
+#         # 其它条目直接加入
+#         out.append(item)
+
+#     return out
+
+ARRAY_RE = re.compile(
+    r'\\begin\{array\}\{(?P<spec>[^}]*)\}(?P<body>.*?)\\end\{array\}',
+    re.S
+)
+
+def is_all_l(spec: str) -> bool:
+    """检查是否为单列array格式，用于排除矩阵等多列格式。这个函数只拆分单列的array"""
+    spec = re.sub(r'\s+|\|', '', spec)          # 删空白与竖线
+    spec = re.sub(r'@{[^}]*}', '', spec)        # 删 @{…} 修饰
+    spec = re.sub(r'!{[^}]*}', '', spec)        # 删 !{…} 修饰
+    # 检查是否为单列基本对齐格式：l, c, r
+    return bool(spec) and len(spec) == 1 and spec in {'l', 'c', 'r'}
+
+# def is_all_l(spec: str) -> bool:
+#     """忽略空格 / 竖线 / @{…} 之后，判断列格式是否只剩基本对齐格式。这个函数会将多行多列的array按行拆分"""
+#     spec = re.sub(r'\s+|\|', '', spec)          # 删空白与竖线
+#     spec = re.sub(r'@{[^}]*}', '', spec)        # 删 @{…} 修饰
+#     spec = re.sub(r'!{[^}]*}', '', spec)        # 删 !{…} 修饰
+#     # 检查是否只包含基本对齐格式：l, c, r
+#     return bool(spec) and set(spec) <= {'l', 'c', 'r'}
+
+def split_gt_equation_arrays(data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """
+    拆分带 \\begin{array} … \\end{array} 的 GT 字典条目。
+
+    - 仅针对 category_type == 'equation_isolated' 且 latex 含 array。
+    - 每行公式拆出一个新条目：
+        * 更新 'latex'
+        * 若存在 line_with_spans，则同步替换其内部 latex
+        * 'order' 由 7 --> 7.1, 7.2, …
+    """
+    output = []
+
+    for item in data:
+        # 只处理满足条件的字典
+        if (item.get("category_type") == "equation_isolated" and
+                "\\begin{array" in item.get("latex", "")):
+
+            # 抽取 array 内部内容
+            match = ARRAY_RE.search(item["latex"])
+            if match:
+
+                spec = match.group("spec")
+                if not is_all_l(spec):
+                    # 若列里混有 r / c / p{…} 等，直接保留原条目
+                    output.append(item)
+                    continue
+                
+                body  = match.group("body")
+                # body = match.group(1)           # 去掉 array 外壳
+                # 按 LaTeX 行分隔符 \\\\ 拆分
+                lines = [ln.strip() for ln in re.split(r'\\\\', body) if ln.strip()]
+
+                base_order = float(item["order"])  # 7 -> 7.0，可兼容 float/int
+
+                for idx, line in enumerate(lines, start=1):
+                    new_item = deepcopy(item)
+                    new_item["latex"] = f"\\[{line}\\]"
+                    new_item["order"] = round(base_order + idx / 10, 1)
+                    output.append(new_item)
+                continue  # 跳过把原 item 加入
+        # 其它情况不修改
+        output.append(item)
+
+    return output
+
+def _wrap(line: str) -> str:
+    """给单行公式重新包 \\[ ... \\]"""
+    return f"\\[{line.strip()}\\]"
+
+def split_equation_arrays(data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """
+    处理 category_type == 'equation_isolated' 且含 \\begin{array} … 的条目：
+    * 拆分多行公式
+    * 重新包装 content
+    * **重计算 position / positions**
+    """
+    out: List[Dict[str, Any]] = []
+
+    for item in data:
+        if (item.get("category_type") == "equation_isolated" and
+                "\\begin{array" in item.get("content", "")):
+
+            content = item["content"]
+            m = ARRAY_RE.search(content)
+            if not m:
+                out.append(item)
+                continue
+
+            if not is_all_l(m.group('spec')):
+                out.append(item)
+                continue
+            
+            # body = m.group(1)
+            body = m.group('body')
+            lines = [ln.strip() for ln in re.split(r'\\\\', body) if ln.strip()]
+
+            # 全局起始字符索引
+            pos_key = "position" if "position" in item else "positions"
+            global_start = item[pos_key][0]
+
+            # array 正文在原 content 内的起点
+            # body_start_in_content = m.start(1)
+            body_start_in_content = m.start('body')
+
+            search_from = 0  # 在 body 中的游标
+            for ln in lines:
+                # 在 body 中找到当前行的偏移
+                idx_in_body = body.find(ln, search_from)
+                if idx_in_body == -1:
+                    # 不太可能发生；保守处理
+                    idx_in_body = search_from
+                search_from = idx_in_body + len(ln)  # 更新游标
+
+                # 计算全局索引
+                line_start_global = global_start + body_start_in_content + idx_in_body
+                line_end_global   = line_start_global + len(ln) - 1
+
+                new_item = deepcopy(item)
+                new_item["content"] = _wrap(ln)
+                new_item[pos_key]   = [line_start_global, line_end_global]
+
+                out.append(new_item)
+
+            # 拆分完成，不保留原条目
+            continue
+
+        # 其它条目直接加入
+        out.append(item)
+
+    return out
+
+def sort_by_position_skip_inline(items: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """
+    先按 position[0] 从小到大排序；
+    若 fine_category_type == 'equation_inline'，则统一放到最后，
+    并保持它们在原列表中的相对顺序（稳定排序）。
+    """
+    # enumerate 保留原始顺序索引，用于 equation_inline “并列时” 的稳定性
+    return sorted(
+        enumerate(items),
+        key=lambda pair: (
+            pair[1].get('fine_category_type') == 'equation_inline',  # False < True
+            pair[1]['position'][0],                                   # 位置起点
+            pair[0]                                                   # 原序号，确保稳定
+        )
+    )
+def match_gt2pred_quick(gt_items, pred_items, line_type, img_name):
+    # ========== 降级匹配阈值检测 ==========
+    # 当 pred_items 过多且远超 gt_items 时，降级为整体匹配，避免 O(m*n) 复杂度过高
+    MAX_PRED_ITEMS = 50000       # pred项数超过此值触发检查
+    RATIO_THRESHOLD = 100        # pred/gt 比例超过此值则降级
+    MAX_TOTAL_LENGTH = 10000000  # 内容总长度超过此值也降级
+    MAX_SINGLE_ITEM_LENGTH = 10000000  # 单个项内容超过此值也降级（针对大表格）
+
+    gt_count = len(gt_items)
+    pred_count = len(pred_items)
+
+    # 计算内容总长度
+    def get_item_content(item):
+        content = item.get('content')
+        if content is None:
+            content = item.get('text', '')
+        return str(content) if content else ''
+
+    gt_total_len = sum(len(get_item_content(item)) for item in gt_items)
+    pred_total_len = sum(len(get_item_content(item)) for item in pred_items)
+
+    # 计算单个项最大长度（针对大表格）
+    gt_max_len = max((len(get_item_content(item)) for item in gt_items), default=0)
+    pred_max_len = max((len(get_item_content(item)) for item in pred_items), default=0)
+
+    # 判断是否需要降级：项数过多 或 内容过大
+    need_downgrade = False
+    downgrade_reason = ""
+
+    if pred_count > MAX_PRED_ITEMS and gt_count > 0 and pred_count > RATIO_THRESHOLD * gt_count:
+        need_downgrade = True
+        downgrade_reason = f"pred_items({pred_count})/gt_items({gt_count})={pred_count/gt_count:.1f}"
+    elif gt_total_len > MAX_TOTAL_LENGTH or pred_total_len > MAX_TOTAL_LENGTH:
+        need_downgrade = True
+        downgrade_reason = f"content_too_large(gt_len={gt_total_len},pred_len={pred_total_len})"
+    elif gt_max_len > MAX_SINGLE_ITEM_LENGTH or pred_max_len > MAX_SINGLE_ITEM_LENGTH:
+        # 单个项内容过大（针对大表格导致的慢速编辑距离计算）
+        need_downgrade = True
+        downgrade_reason = f"single_item_too_large(gt_max={gt_max_len},pred_max={pred_max_len})"
+
+    if need_downgrade:
+        # 判断是否为表格类型
+        is_table_type = line_type in ['html_table', 'latex_table']
+
+        if is_table_type:
+            # 表格类型：不允许随意拼接，直接给低分
+            # 如果 GT 和 Pred 数量相同，尝试一一配对；否则 TEDS=0
+            print(f"[DOWNGRADE-TABLE] {img_name}: {downgrade_reason}, TEDS=0")
+
+            gt_positions = []
+            for item in gt_items:
+                pos = item.get('order')
+                if pos is None:
+                    pos = item.get('position', [''])[0] if item.get('position') else ''
+                gt_positions.append(pos)
+
+            pred_positions = []
+            for item in pred_items:
+                pos = item.get('order')
+                if pos is None:
+                    pos = item.get('position', [''])[0] if item.get('position') else ''
+                pred_positions.append(pos)
+
+            gt_category = gt_items[0].get('fine_category_type') or gt_items[0].get('category_type', line_type) if gt_items else line_type
+            pred_category = pred_items[0].get('fine_category_type') or pred_items[0].get('category_type', line_type) if pred_items else line_type
+
+            # 对于表格，返回一个 TEDS=0 的结果
+            gt_all = '\n'.join([get_item_content(item) for item in gt_items])
+            pred_all = '\n'.join([get_item_content(item) for item in pred_items])
+
+            return [{
+                'gt_idx': list(range(gt_count)),
+                'gt': gt_all,
+                'pred_idx': list(range(pred_count)),
+                'pred': pred_all,
+                'gt_position': gt_positions,
+                'pred_position': pred_positions[0] if pred_positions else "",
+                'norm_gt': gt_all,
+                'norm_pred': pred_all,
+                'gt_category_type': gt_category,
+                'pred_category_type': pred_category,
+                'gt_attribute': [item.get('attribute', {}) for item in gt_items],
+                'edit': 1.0,  # edit 距离给最大值（表示完全不同）
+                'TEDS': 0.0,  # TEDS 分数直接给 0
+                'img_id': img_name,
+                'downgrade': True,
+                'downgrade_reason': downgrade_reason
+            }]
+        else:
+            # 非表格类型：拼接后计算 edit_distance
+            gt_positions = []
+            for item in gt_items:
+                pos = item.get('order')
+                if pos is None:
+                    pos = item.get('position', [''])[0] if item.get('position') else ''
+                gt_positions.append(pos)
+
+            pred_positions = []
+            for item in pred_items:
+                pos = item.get('order')
+                if pos is None:
+                    pos = item.get('position', [''])[0] if item.get('position') else ''
+                pred_positions.append(pos)
+
+            gt_all = '\n'.join([get_item_content(item) for item in gt_items])
+            pred_all = '\n'.join([get_item_content(item) for item in pred_items])
+
+            if not gt_all and not pred_all:
+                edit = 0.0
+            elif not gt_all or not pred_all:
+                edit = 1.0
+            else:
+                edit_distance = Levenshtein_distance(gt_all, pred_all)
+                edit = edit_distance / max(len(gt_all), len(pred_all))
+
+            gt_category = gt_items[0].get('fine_category_type') or gt_items[0].get('category_type', line_type) if gt_items else line_type
+            pred_category = pred_items[0].get('fine_category_type') or pred_items[0].get('category_type', line_type) if pred_items else line_type
+
+            print(f"[DOWNGRADE] {img_name}: {downgrade_reason}, edit={edit:.4f}")
+
+            return [{
+                'gt_idx': list(range(gt_count)),
+                'gt': gt_all,
+                'pred_idx': list(range(pred_count)),
+                'pred': pred_all,
+                'gt_position': gt_positions,
+                'pred_position': pred_positions[0] if pred_positions else "",
+                'norm_gt': gt_all,
+                'norm_pred': pred_all,
+                'gt_category_type': gt_category,
+                'pred_category_type': pred_category,
+                'gt_attribute': [item.get('attribute', {}) for item in gt_items],
+                'edit': edit,
+                'img_id': img_name,
+                'downgrade': True,
+                'downgrade_reason': downgrade_reason
+            }]
+    # ========== 降级匹配检测结束 ==========
+
+    gt_items = split_gt_equation_arrays(gt_items)
+    
+    # pred_items = sorted(pred_items, key=lambda x: x['position'][0])
+    pred_items = [pair[1] for pair in sort_by_position_skip_inline(pred_items)]
+
+    pred_items = split_equation_arrays(pred_items)
+
+    # gt_lines, norm_gt_lines, gt_cat_list, pred_lines, norm_pred_lines= get_gt_pred_lines(gt_items, pred_items, line_type)
+    gt_lines, norm_gt_lines, gt_cat_list, pred_lines, norm_pred_lines, gt_items, pred_items = get_gt_pred_lines(gt_items, pred_items, None)
+    all_gt_indices = set(range(len(norm_gt_lines)))  
+    all_pred_indices = set(range(len(norm_pred_lines)))  
+    
+    if not norm_gt_lines:
+        match_list = []
+        for pred_idx in range(len(norm_pred_lines)):
+            match_list.append({
+                'gt_idx': [""],
+                'gt': "",
+                'pred_idx': [pred_idx],
+                'pred': pred_lines[pred_idx],
+                'gt_position': [""],
+                'pred_position': pred_items[pred_idx]['position'][0],
+                'norm_gt': "",
+                'norm_pred': norm_pred_lines[pred_idx],
+                'gt_category_type': "",
+                'pred_category_type': get_pred_category_type(pred_idx, pred_items),
+                'gt_attribute': [{}],
+                'edit': 1,
+                'img_id': img_name
+            })
+        return match_list
+    elif not norm_pred_lines:
+        match_list = []
+        for gt_idx in range(len(norm_gt_lines)):
+            match_list.append({
+                'gt_idx': [gt_idx],
+                'gt': gt_lines[gt_idx],
+                'pred_idx': [""],
+                'pred': "",
+                'gt_position': [gt_items[gt_idx].get('order') if gt_items[gt_idx].get('order') else gt_items[gt_idx].get('position', [""])[0]],
+                'pred_position': "",
+                'norm_gt': norm_gt_lines[gt_idx],
+                'norm_pred': "",
+                'gt_category_type': gt_cat_list[gt_idx],
+                'pred_category_type': "",
+                'gt_attribute': [gt_items[gt_idx].get("attribute", {})],
+                'edit': 1,
+                'img_id': img_name
+            })
+        return match_list
+    elif len(norm_gt_lines) == 1 and len(norm_pred_lines) == 1:
+        edit_distance = Levenshtein_distance(norm_gt_lines[0], norm_pred_lines[0])
+        normalized_edit_distance = edit_distance / max(len(norm_gt_lines[0]), len(norm_pred_lines[0]))
+        return [{
+            'gt_idx': [0],
+            'gt': gt_lines[0],
+            'pred_idx': [0],
+            'pred': pred_lines[0],
+            'gt_position': [gt_items[0].get('order') if gt_items[0].get('order') else gt_items[0].get('position', [""])[0]],
+            'pred_position': pred_items[0]['position'][0],
+            'norm_gt': norm_gt_lines[0],
+            'norm_pred': norm_pred_lines[0],
+            'gt_category_type': gt_cat_list[0],
+            'pred_category_type': get_pred_category_type(0, pred_items),
+            'gt_attribute': [gt_items[0].get("attribute", {})],
+            'edit': normalized_edit_distance,
+            'img_id': img_name
+        }]
+    
+    # match category ignore first
+    ignores = ['figure_caption', 'figure_footnote', 'table_caption', 'table_footnote', 'code_algorithm', 
+               'code_algorithm_caption', 'header', 'footer', 'page_footnote', 'page_number', 'equation_caption']
+    
+    ignore_gt_lines = []
+    ignores_ori_gt_lines= []
+    ignores_gt_items = []
+    ignore_gt_idxs = []
+    ignores_gt_cat_list = []
+    
+    no_ignores_gt_lines = []
+    no_ignores_ori_gt_lines = []
+    no_ignores_gt_idxs = []
+    no_ignores_gt_items = []
+    no_ignores_gt_cat_list = []
+
+    for i, line in enumerate(norm_gt_lines):
+        if gt_cat_list[i] in ignores:
+            ignore_gt_lines.append(line)
+            ignores_ori_gt_lines.append(gt_lines[i])
+            ignores_gt_items.append(gt_items[i])
+            ignore_gt_idxs.append(i)
+            ignores_gt_cat_list.append(gt_cat_list[i])
+        else:
+            no_ignores_gt_lines.append(line)
+            no_ignores_ori_gt_lines.append(gt_lines[i])
+            no_ignores_gt_items.append(gt_items[i])
+            no_ignores_gt_cat_list.append(gt_cat_list[i])
+            no_ignores_gt_idxs.append(i)
+
+    # print("-------------ignore_gt_lines-------------------")
+    # for idx, line in zip(ignore_idx,ignore_gt_lines):
+    #     print(f"{gt_cat_list[idx]}: {line}")
+    
+    # print("-------------no_ignores_gt_lines-------------------")
+    # for line in no_ignores_gt_lines:
+    #     print(line)
+
+    ignore_pred_idxs = []
+    ignore_pred_lines = []
+    ignores_pred_items = []
+    ignores_ori_pred_lines = []
+
+    merged_ignore_results = []
+
+    if len(ignore_gt_lines) > 0:
+        
+        ignore_matches_dict = {}
+
+        ignore_matrix = compute_edit_distance_matrix_new(ignore_gt_lines, norm_pred_lines)
+        # print("-------------ignore_matrix-------------")
+        # print(ignore_matrix)
+        
+        ignores_gt_indices = set(range(len(ignore_gt_lines)))  
+        ignores_pred_indices = set(range(len(ignore_pred_lines)))
+
+        ignore_matches = np.argwhere(ignore_matrix < 0.25) 
+        # print("-------------ignore_matches-------------")
+        # print(ignore_matches)
+        if len(ignore_matches) > 0:
+            ignore_pred_idxs = [_[1] for _ in ignore_matches]
+            ignore_gt_matched_idxs = [ignore_gt_idxs[_[0]] for _ in ignore_matches]
+            # print("-------------ignore_pred_idxs-------------")
+            # print(ignore_pred_idxs)
+            # print("-------------ignore_gt_matched_idxs-------------")
+            # print(ignore_gt_matched_idxs)
+
+            for i in ignore_pred_idxs:
+                ignore_pred_lines.append(norm_pred_lines[i])
+                ignores_ori_pred_lines.append(pred_lines[i])
+                ignores_pred_items.append(pred_items[i])
+            # print("-------------ignore_pred_lines-------------")
+            # for i in ignore_pred_lines:
+            #     print(i)
+
+                ignores_gt_indices = set(range(len(ignore_gt_lines)))  
+                ignores_pred_indices = set(range(len(ignore_pred_lines))) 
+
+            for idx, i in enumerate(ignore_matches):
+                ignore_matches_dict[i[0]] = {
+                    'pred_indices': [idx],
+                    'edit_distance': ignore_matrix[i[0]][i[1]]
+                }
+            # print("-------------ignore_matches_dict-------------")
+            # print(ignore_matches_dict)
+
+        ignore_final_matches = merge_matches(ignore_matches_dict, {})
+        # print("-------------ignore_final_matches-------------")
+        # print(ignore_final_matches)
+        
+        recalculate_edit_distances(ignore_final_matches, {}, ignore_gt_lines, ignore_pred_lines)
+        # print("-------------recalculate_ignore_final_matches-------------")
+        # print(ignore_final_matches)
+
+        converted_ignore_results = convert_final_matches(ignore_final_matches, ignore_gt_lines, ignore_pred_lines)
+        # print("-------------converted_ignore_results-------------")
+        # for i in converted_ignore_results:
+        #     print(i)
+            
+        merged_ignore_results = merge_duplicates_add_unmatched(converted_ignore_results, ignore_gt_lines, ignore_pred_lines, ignores_ori_gt_lines, ignores_ori_pred_lines, ignores_gt_indices, ignores_pred_indices)
+
+        for entry in merged_ignore_results:
+            entry['gt_idx'] = [entry['gt_idx']] if not isinstance(entry['gt_idx'], list) else entry['gt_idx']
+            entry['pred_idx'] = [entry['pred_idx']] if not isinstance(entry['pred_idx'], list) else entry['pred_idx']
+            entry['gt_position'] = [ignores_gt_items[_].get('order') if ignores_gt_items[_].get('order') else ignores_gt_items[_].get('position', [""])[0] for _ in entry['gt_idx']] if entry['gt_idx'] != [""] else [""]
+            entry['pred_position'] = ignores_pred_items[entry['pred_idx'][0]]['position'][0] if entry['pred_idx'] != [""] else "" 
+            entry['gt'] = ''.join([ignores_ori_gt_lines[_] for _ in entry['gt_idx']]) if entry['gt_idx'] != [""] else ""
+            entry['pred'] = ''.join([ignores_ori_pred_lines[_] for _ in entry['pred_idx']]) if entry['pred_idx'] != [""] else ""
+            entry['norm_gt'] = ''.join([ignore_gt_lines[_] for _ in entry['gt_idx']]) if entry['gt_idx'] != [""] else ""
+            entry['norm_pred'] = ''.join([ignore_pred_lines[_] for _ in entry['pred_idx']]) if entry['pred_idx'] != [""] else ""
+
+            if entry['gt_idx'] != [""]:
+                ignore_type = ['figure_caption', 'figure_footnote', 'table_caption', 'table_footnote', 'code_algorithm', 'code_algorithm_caption', 'header', 'footer', 'page_footnote', 'page_number', 'equation_caption']
+                gt_cagegory_clean = [ignores_gt_cat_list[_] for _ in entry['gt_idx'] if ignores_gt_cat_list[_] not in ignore_type] 
+                if gt_cagegory_clean:
+                    entry['gt_category_type'] = Counter(gt_cagegory_clean).most_common(1)[0][0] 
+                else:
+                    entry['gt_category_type'] = Counter([ignores_gt_cat_list[_] for _ in entry['gt_idx']]).most_common(1)[0][0] 
+            else:
+                entry['gt_category_type'] = ""
+                entry['pred_category_type'] = get_pred_category_type(entry['pred_idx'][0], ignores_pred_items) if entry['pred_idx'] != [""] else ""
+                if entry['pred_category_type'] == 'equation_inline':
+                    merged_ignore_results.remove(entry)
+            entry['pred_category_type'] = get_pred_category_type(entry['pred_idx'][0], ignores_pred_items) if entry['pred_idx'] != [""] else ""
+            entry['gt_attribute'] = [ignores_gt_items[_].get("attribute", {}) for _ in entry['gt_idx']] if entry['gt_idx'] != [""] else [{}] 
+            entry['img_id'] = img_name
+        
+        for entry in merged_ignore_results:
+            if isinstance(entry['gt_idx'], list) and entry['gt_idx'] != [""]:
+                gt_idx = []
+                for i in entry['gt_idx']:
+                    gt_idx.append(ignore_gt_idxs[i])
+                entry['gt_idx'] = gt_idx
+            if isinstance(entry['pred_idx'], list) and entry['pred_idx'] != [""]:
+                pred_idx = []
+                for i in entry['pred_idx']:
+                    pred_idx.append(int(ignore_pred_idxs[i]))
+                entry['pred_idx'] = pred_idx
+
+        # print("-------------merged_ignore_results-------------")
+        # for i in merged_ignore_results:
+        #     print(i)
+
+    no_ignores_pred_lines = []
+    no_ignores_ori_pred_lines = []
+    no_ignores_pred_indices = []
+    no_ignores_pred_items = []
+    no_ignore_pred_idxs = []
+
+    for idx, line in enumerate(norm_pred_lines):
+        if not idx in ignore_pred_idxs:
+            no_ignores_pred_lines.append(line)
+            no_ignores_ori_pred_lines.append(pred_lines[idx])
+            # no_ignores_pred_indices.append(idx)
+            no_ignores_pred_items.append(pred_items[idx])
+            no_ignore_pred_idxs.append(idx)
+    
+    # initialize new indices for lines without ignore categories
+    no_ignores_gt_indices = set(range(len(no_ignores_gt_lines)))  
+    no_ignores_pred_indices = set(range(len(no_ignores_pred_lines)))  
+    
+    # exclude ignore categories
+    cost_matrix = compute_edit_distance_matrix_new(no_ignores_gt_lines, no_ignores_pred_lines)
+    # print("-------------cost matrix-------------")
+    # print(cost_matrix)
+
+    matched_col_idx, row_ind, cost_list = cal_final_match(cost_matrix, no_ignores_gt_lines, no_ignores_pred_lines)
+    # print("-------------matched_col_idx-------------")
+    # print(matched_col_idx)
+    
+    # print("-------------gt_row_ind-------------")
+    # print(row_ind)
+
+    # print("-------------cost_list-------------")
+    # print(cost_list)
+        
+    gt_lens_dict, pred_lens_dict = initialize_indices(no_ignores_gt_lines, no_ignores_pred_lines)
+    # print("-------------gt_lens_dict-------------")
+    # print(gt_lens_dict)
+
+    # print("-------------pred_lens_dict-------------")
+    # print(pred_lens_dict)
+    
+    matches, unmatched_gt_indices, unmatched_pred_indices = process_matches(matched_col_idx, row_ind, cost_list, no_ignores_gt_lines, no_ignores_pred_lines, no_ignores_ori_pred_lines)
+
+    # print("-------------matches-------------")
+    # print(matches)
+
+    # print("-------------unmatched_gt_indices-------------")
+    # print(unmatched_gt_indices)
+
+    # print("-------------unmatched_pred_indices-------------")
+    # print(unmatched_pred_indices)
+    
+    matching_dict = fuzzy_match_unmatched_items(unmatched_gt_indices, no_ignores_gt_lines, no_ignores_pred_lines)
+    # print("-------------matching_dict-------------")
+    # print(matching_dict)
+    
+    final_matches = merge_matches(matches, matching_dict)
+    # print("-------------final_matches-------------")
+    # print(final_matches)
+
+    recalculate_edit_distances(final_matches, gt_lens_dict, no_ignores_gt_lines, no_ignores_pred_lines)
+    # print("-------------recalculate_edit_distances-------------")
+    # print(final_matches)
+    
+    converted_results = convert_final_matches(final_matches, no_ignores_gt_lines, no_ignores_pred_lines)
+    # print("-------------converted_results-------------")
+    # print(converted_results)
+    
+    merged_results = merge_duplicates_add_unmatched(converted_results, no_ignores_gt_lines, no_ignores_pred_lines, no_ignores_ori_gt_lines, no_ignores_ori_pred_lines, no_ignores_gt_indices, no_ignores_pred_indices)
+
+    for entry in merged_results:
+        if entry['gt_idx'] != [""]:
+            ignore_type = ['figure_caption', 'figure_footnote', 'table_caption', 'table_footnote', 'code_algorithm', 'code_algorithm_caption', 'header', 'footer', 'page_footnote', 'page_number', 'equation_caption']
+            gt_cagegory_clean = [no_ignores_gt_cat_list[_] for _ in entry['gt_idx'] if no_ignores_gt_cat_list[_] not in ignore_type] 
+            if gt_cagegory_clean:
+                entry['gt_category_type'] = Counter(gt_cagegory_clean).most_common(1)[0][0] 
+            else:
+                entry['gt_category_type'] = Counter([no_ignores_gt_cat_list[_] for _ in entry['gt_idx']]).most_common(1)[0][0] 
+        else:
+            entry['gt_category_type'] = ""
+            entry['pred_category_type'] = get_pred_category_type(entry['pred_idx'][0], no_ignores_pred_items) if entry['pred_idx'] != [""] else ""
+            if entry['pred_category_type'] == 'equation_inline':
+                merged_results.remove(entry)
+
+
+        entry['gt_idx'] = [entry['gt_idx']] if not isinstance(entry['gt_idx'], list) else entry['gt_idx']
+        entry['pred_idx'] = [entry['pred_idx']] if not isinstance(entry['pred_idx'], list) else entry['pred_idx']
+        entry['gt_position'] = [no_ignores_gt_items[_].get('order') if no_ignores_gt_items[_].get('order') else no_ignores_gt_items[_].get('position', [""])[0] for _ in entry['gt_idx']] if entry['gt_idx'] != [""] else [""]
+        entry['pred_position'] = no_ignores_pred_items[entry['pred_idx'][0]]['position'][0] if entry['pred_idx'] != [""] else "" 
+        #  0507 多行公式拼接修改
+        if entry['gt_category_type'] == 'equation_isolated' and len(entry['gt_idx']) > 1:
+            mutli_formula  = ' \\\\ '.join(['{'+no_ignores_ori_gt_lines[_].strip('$$').strip('\n')+'}' for _ in  entry['gt_idx']]) if entry['gt_idx'] != [""] else ""
+            mutli_formula = '\\\\begin{array}{l} ' + mutli_formula + ' \\\\end{array}'
+            entry['gt'] = mutli_formula
+        else:
+            entry['gt'] = ''.join([no_ignores_ori_gt_lines[_] for _ in entry['gt_idx']]) if entry['gt_idx'] != [""] else ""
+
+        entry['pred_category_type'] = get_pred_category_type(entry['pred_idx'][0], no_ignores_pred_items) if entry['pred_idx'] != [""] else ""
+        entry['gt_attribute'] = [no_ignores_gt_items[_].get("attribute", {}) for _ in entry['gt_idx']] if entry['gt_idx'] != [""] else [{}] 
+        entry['img_id'] = img_name
+        
+        #  0724 多行公式拼接修改pred
+        if 'equation' in entry['pred_category_type'] and len(entry['pred_idx']) > 1:
+            mutli_formula  = ' \\\\ '.join(['{'+no_ignores_ori_pred_lines[_].strip('$$').strip('\n')+'}' for _ in  entry['pred_idx']]) if entry['pred_idx'] != [""] else ""
+            mutli_formula = '\\\\begin{array}{l} ' + mutli_formula + ' \\\\end{array}'
+            entry['pred'] = mutli_formula
+        else:
+            entry['pred'] = ''.join([no_ignores_ori_pred_lines[_] for _ in entry['pred_idx']]) if entry['pred_idx'] != [""] else ""
+
+        entry['norm_gt'] = ''.join([no_ignores_gt_lines[_] for _ in entry['gt_idx']]) if entry['gt_idx'] != [""] else ""
+        entry['norm_pred'] = ''.join([no_ignores_pred_lines[_] for _ in entry['pred_idx']]) if entry['pred_idx'] != [""] else ""
+
+    
+    # print("-------------merged_results-------------")
+    # for i in merged_results:
+    #     print(i)
+    for entry in merged_results:
+        if isinstance(entry['gt_idx'], list) and entry['gt_idx'] != [""]:
+            gt_idx = []
+            for i in entry['gt_idx']:
+                gt_idx.append(no_ignores_gt_idxs[i])
+            entry['gt_idx'] = gt_idx
+        if isinstance(entry['pred_idx'], list) and entry['pred_idx'] != [""]:
+            pred_idx = []
+            for i in entry['pred_idx']:
+                pred_idx.append(int(no_ignore_pred_idxs[i]))
+            entry['pred_idx'] = pred_idx
+
+    if len(merged_ignore_results) > 0:
+        merged_results.extend(merged_ignore_results)
+        # for i in merged_ignore_results:
+        #     merged_results.append(i)
+
+    return merged_results
+
+    # cost_matrix = compute_edit_distance_matrix_new(norm_gt_lines, norm_pred_lines)
+    
+    # matched_col_idx, row_ind, cost_list = cal_final_match(cost_matrix, norm_gt_lines, norm_pred_lines)
+    
+    # gt_lens_dict, pred_lens_dict = initialize_indices(norm_gt_lines, norm_pred_lines)
+    
+    # matches, unmatched_gt_indices, unmatched_pred_indices = process_matches(matched_col_idx, row_ind, cost_list, norm_gt_lines, norm_pred_lines, pred_lines)
+    
+    # matching_dict = fuzzy_match_unmatched_items(unmatched_gt_indices, norm_gt_lines, norm_pred_lines)
+    
+    # final_matches = merge_matches(matches, matching_dict)
+    
+    # recalculate_edit_distances(final_matches, gt_lens_dict, norm_gt_lines, norm_pred_lines)
+    
+    # converted_results = convert_final_matches(final_matches, norm_gt_lines, norm_pred_lines)
+    
+    # merged_results = merge_duplicates_add_unmatched(converted_results, norm_gt_lines, norm_pred_lines, gt_lines, pred_lines, all_gt_indices, all_pred_indices)
+
+    # for entry in merged_results:
+    #         entry['gt_idx'] = [entry['gt_idx']] if not isinstance(entry['gt_idx'], list) else entry['gt_idx']
+    #         entry['pred_idx'] = [entry['pred_idx']] if not isinstance(entry['pred_idx'], list) else entry['pred_idx']
+    #         entry['gt_position'] = [gt_items[_].get('order') if gt_items[_].get('order') else gt_items[_].get('position', [""])[0] for _ in entry['gt_idx']] if entry['gt_idx'] != [""] else [""]
+    #         entry['pred_position'] = pred_items[entry['pred_idx'][0]]['position'][0] if entry['pred_idx'] != [""] else "" 
+    #         entry['gt'] = ''.join([gt_lines[_] for _ in entry['gt_idx']]) if entry['gt_idx'] != [""] else ""
+    #         entry['pred'] = ''.join([pred_lines[_] for _ in entry['pred_idx']]) if entry['pred_idx'] != [""] else ""
+    #         entry['norm_gt'] = ''.join([norm_gt_lines[_] for _ in entry['gt_idx']]) if entry['gt_idx'] != [""] else ""
+    #         entry['norm_pred'] = ''.join([norm_pred_lines[_] for _ in entry['pred_idx']]) if entry['pred_idx'] != [""] else ""
+
+    #         if entry['gt_idx'] != [""]:
+    #             ignore_type = ['figure_caption', 'figure_footnote', 'table_caption', 'table_footnote', 'code_algorithm', 'code_algorithm_caption', 'header', 'footer', 'page_footnote', 'page_number', 'equation_caption']
+    #             gt_cagegory_clean = [gt_cat_list[_] for _ in entry['gt_idx'] if gt_cat_list[_] not in ignore_type] 
+    #             if gt_cagegory_clean:
+    #                 entry['gt_category_type'] = Counter(gt_cagegory_clean).most_common(1)[0][0] 
+    #             else:
+    #                 entry['gt_category_type'] = Counter([gt_cat_list[_] for _ in entry['gt_idx']]).most_common(1)[0][0] 
+    #         else:
+    #             entry['gt_category_type'] = ""
+    #         entry['pred_category_type'] = get_pred_category_type(entry['pred_idx'][0], pred_items) if entry['pred_idx'] != [""] else ""
+    #         entry['gt_attribute'] = [gt_items[_].get("attribute", {}) for _ in entry['gt_idx']] if entry['gt_idx'] != [""] else [{}] 
+    #         entry['img_id'] = img_name
+        
+    # return merged_results
+
+
+def merge_duplicates_add_unmatched(converted_results, norm_gt_lines, norm_pred_lines, gt_lines, pred_lines, all_gt_indices, all_pred_indices):
+    merged_results = []
+    processed_pred = set()
+    processed_gt = set()
+
+    for entry in converted_results:
+        pred_idx = tuple(entry['pred_idx']) if isinstance(entry['pred_idx'], list) else (entry['pred_idx'],)
+        if pred_idx not in processed_pred and pred_idx != ("",):
+            merged_entry = {
+                'gt_idx': [entry['gt_idx']],
+                'gt': entry['gt'],
+                'pred_idx': entry['pred_idx'],
+                'pred': entry['pred'],
+                'edit': entry['edit']
+            }
+            for other_entry in converted_results:
+                other_pred_idx = tuple(other_entry['pred_idx']) if isinstance(other_entry['pred_idx'], list) else (other_entry['pred_idx'],)
+                if other_pred_idx == pred_idx and other_entry is not entry:
+                    merged_entry['gt_idx'].append(other_entry['gt_idx'])
+                    merged_entry['gt'] += other_entry['gt']
+                    processed_gt.add(other_entry['gt_idx'])
+            merged_results.append(merged_entry)
+            processed_pred.add(pred_idx)
+            processed_gt.add(entry['gt_idx'])
+
+    # for entry in converted_results:
+    #     if entry['gt_idx'] not in processed_gt:
+    #         merged_results.append(entry)
+
+    for gt_idx in range(len(norm_gt_lines)):
+        if gt_idx not in processed_gt:
+            merged_results.append({
+                'gt_idx': [gt_idx],
+                'gt': gt_lines[gt_idx],
+                'pred_idx': [""],
+                'pred': "",
+                'edit': 1
+            })
+    return merged_results
+
+
+
+
+def formula_format(formula_matches, img_name):
+    return [
+        {
+            "gt": item["gt"],
+            "pred": item["pred"],
+            "img_id": f"{img_name}_{i}"
+        }
+        for i, item in enumerate(formula_matches)
+    ]
+
+
+def merge_lists_with_sublists(main_list, sub_lists):
+    main_list_final = list(copy.deepcopy(main_list))
+    for sub_list in sub_lists:
+        pop_idx = main_list_final.index(sub_list[0])
+        for _ in sub_list: 
+            main_list_final.pop(pop_idx)
+        main_list_final.insert(pop_idx, sub_list) 
+    return main_list_final   
+
+
+def sub_pred_fuzzy_matching(gt, pred):
+    
+    min_d = float('inf')
+    # pos = -1
+
+    gt_len = len(gt)
+    pred_len = len(pred)
+
+    if gt_len >= pred_len and pred_len > 0:
+        for i in range(gt_len - pred_len + 1):
+            sub = gt[i:i + pred_len]
+            dist = Levenshtein_distance(sub, pred)/pred_len
+            if dist < min_d:
+                min_d = dist
+                pos = i
+
+        return min_d
+    else:
+        return False
+        
+def sub_gt_fuzzy_matching(pred, gt):  
+    
+    min_d = float('inf')  
+    pos = ""  
+    matched_sub = ""  
+    gt_len = len(gt)  
+    pred_len = len(pred)  
+    
+    if pred_len >= gt_len and gt_len > 0:  
+        for i in range(pred_len - gt_len + 1):  
+            sub = pred[i:i + gt_len]  
+            dist = Levenshtein.distance(sub, gt)  /gt_len
+            if dist < min_d:  
+                min_d = dist  
+                pos = i  
+                matched_sub = sub  
+        return min_d, pos, gt_len, matched_sub  
+    else:  
+        return 1, "", gt_len, "" 
+        
+        
+def get_final_subset(subset_certain, subset_certain_cost):
+    if not subset_certain or not subset_certain_cost:
+        return []  
+
+    subset_turple = sorted([(a, b) for a, b in zip(subset_certain, subset_certain_cost)], key=lambda x: x[0][0])
+
+    group_list = defaultdict(list)
+    group_idx = 0
+    group_list[group_idx].append(subset_turple[0])
+
+    for item in subset_turple[1:]:
+        overlap_flag = False
+        for subset in group_list[group_idx]:
+            for idx in item[0]:
+                if idx in subset[0]:
+                    overlap_flag = True
+                    break
+            if overlap_flag:
+                break
+        if overlap_flag:
+            group_list[group_idx].append(item)
+        else:
+            group_idx += 1
+            group_list[group_idx].append(item)
+
+    final_subset = []
+    for _, group in group_list.items():
+        if len(group) == 1: 
+            final_subset.append(group[0][0])
+        else:
+            path_dict = defaultdict(list)
+            path_idx = 0
+            path_dict[path_idx].append(group[0])
+            
+            for subset in group[1:]:
+                new_path = True
+                for path_idx_s, path_items in path_dict.items():
+                    is_dup = False
+                    is_same = False
+                    for path_item in path_items:
+                        if path_item[0] == subset[0]:
+                            is_dup = True
+                            is_same = True
+                            if path_item[1] > subset[1]:
+                                path_dict[path_idx_s].pop(path_dict[path_idx_s].index(path_item))
+                                path_dict[path_idx_s].append(subset)
+                        else:
+                            for num_1 in path_item[0]:
+                                for num_2 in subset[0]:
+                                    if num_1 == num_2:
+                                        is_dup = True
+                    if not is_dup:
+                        path_dict[path_idx_s].append(subset)
+                        new_path = False
+                    if is_same:
+                        new_path = False
+                if new_path:
+                    path_idx = len(path_dict.keys())
+                    path_dict[path_idx].append(subset)
+
+            saved_cost = float('inf')
+            saved_subset = []  
+            for path_idx, path in path_dict.items():
+                avg_cost = sum([i[1] for i in path]) / len(path)
+                if avg_cost < saved_cost:
+                    saved_subset = [i[0] for i in path]
+                    saved_cost = avg_cost
+
+            final_subset.extend(saved_subset)
+
+    return final_subset
+
+def judge_pred_merge(gt_list, pred_list, threshold=0.6):
+    if len(pred_list) == 1:
+        return False, False
+
+    cur_pred = ' '.join(pred_list[:-1])
+    merged_pred = ' '.join(pred_list)
+    
+    cur_dist = Levenshtein.distance(gt_list[0], cur_pred) / max(len(gt_list[0]), len(cur_pred))
+    merged_dist = Levenshtein.distance(gt_list[0], merged_pred) / max(len(gt_list[0]), len(merged_pred))
+    
+    if merged_dist > cur_dist:
+        return False, False
+
+    cur_fuzzy_dists = [sub_pred_fuzzy_matching(gt_list[0], cur_pred) for cur_pred in pred_list[:-1]]
+    if any(dist is False or dist > threshold for dist in cur_fuzzy_dists):
+        return False, False
+
+    add_fuzzy_dist = sub_pred_fuzzy_matching(gt_list[0], pred_list[-1])
+    if add_fuzzy_dist is False:
+        return False, False
+
+    merged_pred_flag = add_fuzzy_dist < threshold
+    continue_flag = len(merged_pred) <= len(gt_list[0])
+
+    return merged_pred_flag, continue_flag
+    
+def deal_with_truncated(cost_matrix, norm_gt_lines, norm_pred_lines):
+    matched_first = np.argwhere(cost_matrix < 0.25)
+    masked_gt_idx = [i[0] for i in matched_first]
+    unmasked_gt_idx = [i for i in range(cost_matrix.shape[0]) if i not in masked_gt_idx]
+    masked_pred_idx = [i[1] for i in matched_first]
+    unmasked_pred_idx = [i for i in range(cost_matrix.shape[1]) if i not in masked_pred_idx]
+
+    merges_gt_dict = {}
+    merges_pred_dict = {}
+    merged_gt_subsets = []
+
+    for gt_idx in unmasked_gt_idx:
+        check_merge_subset = []
+        merged_dist = []
+
+        for pred_idx in unmasked_pred_idx: 
+            step = 1
+            merged_pred = [norm_pred_lines[pred_idx]]
+
+            while True:
+                if pred_idx + step in masked_pred_idx or pred_idx + step >= len(norm_pred_lines):
+                    break
+                else:
+                    merged_pred.append(norm_pred_lines[pred_idx + step])
+                    merged_pred_flag, continue_flag = judge_pred_merge([norm_gt_lines[gt_idx]], merged_pred) 
+                    if not merged_pred_flag:
+                        break
+                    else:
+                        step += 1
+                    if not continue_flag:
+                        break
+
+            check_merge_subset.append(list(range(pred_idx, pred_idx + step)))
+            matched_line = ' '.join([norm_pred_lines[i] for i in range(pred_idx, pred_idx + step)])
+            dist = Levenshtein_distance(norm_gt_lines[gt_idx], matched_line) / max(len(matched_line), len(norm_gt_lines[gt_idx]))
+            merged_dist.append(dist)
+
+        if not merged_dist:
+            subset_certain = []
+            min_cost_idx = ""
+            min_cost = float('inf')
+        else:
+            min_cost = min(merged_dist)
+            min_cost_idx = merged_dist.index(min_cost)
+            subset_certain = check_merge_subset[min_cost_idx]
+
+        merges_gt_dict[gt_idx] = {
+            'merge_subset': check_merge_subset,
+            'merged_cost': merged_dist,
+            'min_cost_idx': min_cost_idx,
+            'subset_certain': subset_certain,
+            'min_cost': min_cost
+        }
+
+    subset_certain = [merges_gt_dict[gt_idx]['subset_certain'] for gt_idx in unmasked_gt_idx if merges_gt_dict[gt_idx]['subset_certain']]
+    subset_certain_cost = [merges_gt_dict[gt_idx]['min_cost'] for gt_idx in unmasked_gt_idx if merges_gt_dict[gt_idx]['subset_certain']]
+
+    subset_certain_final = get_final_subset(subset_certain, subset_certain_cost)
+
+    if not subset_certain_final:  
+        return cost_matrix, norm_pred_lines, range(len(norm_pred_lines))
+
+    final_pred_idx_list = merge_lists_with_sublists(range(len(norm_pred_lines)), subset_certain_final)
+    final_norm_pred_lines = [' '.join(norm_pred_lines[idx_list[0]:idx_list[-1]+1]) if isinstance(idx_list, list) else norm_pred_lines[idx_list] for idx_list in final_pred_idx_list]
+
+    new_cost_matrix = compute_edit_distance_matrix_new(norm_gt_lines, final_norm_pred_lines)
+
+    return new_cost_matrix, final_norm_pred_lines, final_pred_idx_list
+    
+def cal_move_dist(gt, pred):
+    assert len(gt) == len(pred), 'Not right length'
+    step = 0
+    for i, gt_c in enumerate(gt):
+        if gt_c != pred[i]:
+            step += abs(i - pred.index(gt_c))
+            pred[i], pred[pred.index(gt_c)] = pred[pred.index(gt_c)], pred[i]
+    return step / len(gt)
+
+def cal_final_match(cost_matrix, norm_gt_lines, norm_pred_lines):
+    # min_indice = cost_matrix.argmax(axis=1)
+
+    new_cost_matrix, final_norm_pred_lines, final_pred_idx_list = deal_with_truncated(cost_matrix, norm_gt_lines, norm_pred_lines)
+
+    row_ind, col_ind = linear_sum_assignment(new_cost_matrix)
+
+    cost_list = [new_cost_matrix[r][c] for r, c in zip(row_ind, col_ind)]
+    matched_col_idx = [final_pred_idx_list[i] for i in col_ind]
+
+    return matched_col_idx, row_ind, cost_list
+
+def initialize_indices(norm_gt_lines, norm_pred_lines):
+    gt_lens_dict = {idx: len(gt_line) for idx, gt_line in enumerate(norm_gt_lines)}
+    pred_lens_dict = {idx: len(pred_line) for idx, pred_line in enumerate(norm_pred_lines)}
+    return gt_lens_dict, pred_lens_dict
+
+def process_matches(matched_col_idx, row_ind, cost_list, norm_gt_lines, norm_pred_lines, pred_lines):
+    matches = {}
+    unmatched_gt_indices = []
+    unmatched_pred_indices = []
+
+    for i in range(len(norm_gt_lines)):
+        if i in row_ind:
+            idx = list(row_ind).index(i)
+            pred_idx = matched_col_idx[idx]
+
+            if pred_idx is None or (isinstance(pred_idx, list) and None in pred_idx):
+                unmatched_pred_indices.append(pred_idx)
+                continue
+
+            if isinstance(pred_idx, list):
+                pred_line = ' | '.join(norm_pred_lines[pred_idx[0]:pred_idx[-1]+1])
+                ori_pred_line = ' | '.join(pred_lines[pred_idx[0]:pred_idx[-1]+1])
+                matched_pred_indices_range = list(range(pred_idx[0], pred_idx[-1]+1))
+            else:
+                pred_line = norm_pred_lines[pred_idx]
+                ori_pred_line = pred_lines[pred_idx]
+                matched_pred_indices_range = [pred_idx]
+
+            edit = cost_list[idx]
+
+            if edit > 0.7:
+                unmatched_pred_indices.extend(matched_pred_indices_range)
+                unmatched_gt_indices.append(i)
+            else:
+                matches[i] = {
+                    'pred_indices': matched_pred_indices_range,
+                    'edit_distance': edit,
+                }
+                for matched_pred_idx in matched_pred_indices_range:
+                    if matched_pred_idx in unmatched_pred_indices:
+                        unmatched_pred_indices.remove(matched_pred_idx)
+        else:
+            unmatched_gt_indices.append(i)
+
+    return matches, unmatched_gt_indices, unmatched_pred_indices
+
+def fuzzy_match_unmatched_items(unmatched_gt_indices, norm_gt_lines, norm_pred_lines):
+    matching_dict = {}
+
+    for pred_idx, pred_content in enumerate(norm_pred_lines):
+        if isinstance(pred_idx, list):
+            continue
+
+        matching_indices = []
+
+        for unmatched_gt_idx in unmatched_gt_indices:
+            gt_content = norm_gt_lines[unmatched_gt_idx]
+            cur_fuzzy_dist_unmatch, cur_pos, gt_lens, matched_field = sub_gt_fuzzy_matching(pred_content, gt_content)
+            if cur_fuzzy_dist_unmatch < 0.4:
+                matching_indices.append(unmatched_gt_idx)
+
+        if matching_indices:
+            matching_dict[pred_idx] = matching_indices
+
+    return matching_dict
+
+def merge_matches(matches, matching_dict):
+    final_matches = {}
+    processed_gt_indices = set() 
+
+    for gt_idx, match_info in matches.items():
+        pred_indices = match_info['pred_indices']
+        edit_distance = match_info['edit_distance']
+
+        pred_key = tuple(sorted(pred_indices))
+
+        if pred_key in final_matches:
+            if gt_idx not in processed_gt_indices:
+                final_matches[pred_key]['gt_indices'].append(gt_idx)
+                processed_gt_indices.add(gt_idx)
+        else:
+            final_matches[pred_key] = {
+                'gt_indices': [gt_idx],
+                'edit_distance': edit_distance
+            }
+            processed_gt_indices.add(gt_idx)
+
+    for pred_idx, gt_indices in matching_dict.items():
+        pred_key = (pred_idx,) if not isinstance(pred_idx, (list, tuple)) else tuple(sorted(pred_idx))
+
+        if pred_key in final_matches:
+            for gt_idx in gt_indices:
+                if gt_idx not in processed_gt_indices:
+                    final_matches[pred_key]['gt_indices'].append(gt_idx)
+                    processed_gt_indices.add(gt_idx)
+        else:
+            final_matches[pred_key] = {
+                'gt_indices': [gt_idx for gt_idx in gt_indices if gt_idx not in processed_gt_indices],
+                'edit_distance': None
+            }
+            processed_gt_indices.update(final_matches[pred_key]['gt_indices'])
+
+    return final_matches
+    
+
+
+def recalculate_edit_distances(final_matches, gt_lens_dict, norm_gt_lines, norm_pred_lines):
+    for pred_key, info in final_matches.items():
+        gt_indices = sorted(set(info['gt_indices']))
+
+        if not gt_indices:
+            info['edit_distance'] = 1
+            continue
+
+        if len(gt_indices) > 1:
+            merged_gt_content = ''.join(norm_gt_lines[gt_idx] for gt_idx in gt_indices)
+            pred_content = norm_pred_lines[pred_key[0]] if isinstance(pred_key[0], int) else ''
+
+            try:
+                edit_distance = Levenshtein_distance(merged_gt_content, pred_content)
+                normalized_edit_distance = edit_distance / max(len(merged_gt_content), len(pred_content))
+            except ZeroDivisionError:
+                normalized_edit_distance = 1
+
+            info['edit_distance'] = normalized_edit_distance
+        else:
+            gt_idx = gt_indices[0]
+            pred_content = ' '.join(norm_pred_lines[pred_idx] for pred_idx in pred_key if isinstance(pred_idx, int))
+
+            try:
+                edit_distance = Levenshtein_distance(norm_gt_lines[gt_idx], pred_content)
+                normalized_edit_distance = edit_distance / max(len(norm_gt_lines[gt_idx]), len(pred_content))
+            except ZeroDivisionError:
+                normalized_edit_distance = 1
+
+            info['edit_distance'] = normalized_edit_distance
+            info['pred_content'] = pred_content
+
+
+def convert_final_matches(final_matches, norm_gt_lines, norm_pred_lines):
+    converted_results = []
+
+    all_gt_indices = set(range(len(norm_gt_lines)))
+    all_pred_indices = set(range(len(norm_pred_lines)))
+
+    for pred_key, info in final_matches.items():
+        pred_content = ' '.join(norm_pred_lines[pred_idx] for pred_idx in pred_key if isinstance(pred_idx, int))
+        
+        for gt_idx in sorted(set(info['gt_indices'])):
+            result_entry = {
+                'gt_idx': int(gt_idx),
+                'gt': norm_gt_lines[gt_idx],
+                'pred_idx': list(pred_key),
+                'pred': pred_content,
+                'edit': info['edit_distance']
+            }
+            converted_results.append(result_entry)
+    
+    matched_gt_indices = set().union(*[set(info['gt_indices']) for info in final_matches.values()])
+    unmatched_gt_indices = all_gt_indices - matched_gt_indices
+    matched_pred_indices = set(idx for pred_key in final_matches.keys() for idx in pred_key if isinstance(idx, int))
+    unmatched_pred_indices = all_pred_indices - matched_pred_indices
+
+    if unmatched_pred_indices:
+        if unmatched_gt_indices:
+            distance_matrix = [
+                # [Levenshtein_distance(norm_gt_lines[gt_idx], norm_pred_lines[pred_idx]) for pred_idx in unmatched_pred_indices]
+                [Levenshtein_distance(norm_gt_lines[gt_idx], norm_pred_lines[pred_idx])/max(len(norm_gt_lines[gt_idx]), len(norm_pred_lines[pred_idx])) for pred_idx in unmatched_pred_indices]
+                for gt_idx in unmatched_gt_indices
+            ]
+
+            row_ind, col_ind = linear_sum_assignment(distance_matrix)
+
+            for i, j in zip(row_ind, col_ind):
+                gt_idx = list(unmatched_gt_indices)[i]
+                pred_idx = list(unmatched_pred_indices)[j]
+                result_entry = {
+                    'gt_idx': int(gt_idx),
+                    'gt': norm_gt_lines[gt_idx],
+                    'pred_idx': [pred_idx],
+                    'pred': norm_pred_lines[pred_idx],
+                    'edit': 1
+                }
+                converted_results.append(result_entry)
+
+            matched_gt_indices.update(list(unmatched_gt_indices)[i] for i in row_ind)
+        else:
+            result_entry = {
+                'gt_idx': "",
+                'gt': '',
+                'pred_idx': list(unmatched_pred_indices),
+                'pred': ' '.join(norm_pred_lines[pred_idx] for pred_idx in unmatched_pred_indices),
+                'edit': 1
+            }
+            converted_results.append(result_entry)
+    else:
+        for gt_idx in unmatched_gt_indices:
+            result_entry = {
+                'gt_idx': int(gt_idx),
+                'gt': norm_gt_lines[gt_idx],
+                'pred_idx': "",
+                'pred': '',
+                'edit': 1
+            }
+            converted_results.append(result_entry)
+
+    return converted_results

FinixDocBench_Eval_for_Markdown/finixdoc_md_eval/utils/table_utils.py

@@ -0,0 +1,100 @@
+import re
+
+
+def markdown_to_html(markdown_table):
+    rows = [row.strip() for row in markdown_table.strip().split('\n') if row.strip()]
+    if len(rows) < 2:
+        return markdown_table
+
+    html_table = '<table>\n  <thead>\n    <tr>\n'
+    header_cells = [cell.strip() for cell in rows[0].split('|')[1:-1]]
+    for cell in header_cells:
+        html_table += f'      <th>{cell}</th>\n'
+    html_table += '    </tr>\n  </thead>\n  <tbody>\n'
+
+    for row in rows[2:]:
+        cells = [cell.strip() for cell in row.split('|')[1:-1]]
+        html_table += '    <tr>\n'
+        for cell in cells:
+            html_table += f'      <td>{cell}</td>\n'
+        html_table += '    </tr>\n'
+
+    html_table += '  </tbody>\n</table>\n'
+    return html_table
+
+
+def convert_table_str(s):
+    s = re.sub(r'<table.*?>', '<table>', s)
+    s = re.sub(r'<th', '<td', s)
+    s = re.sub(r'</th>', '</td>', s)
+    res = '\n\n'
+    temp_item = ''
+    for c in s:
+        temp_item += c
+        if c == '>' and not re.search(r'<td.*?>\$', temp_item):
+            res += temp_item + '\n'
+            temp_item = ''
+    return res + '\n'
+
+
+def find_md_table_mode(line):
+    return bool(re.search(r'-*?:', line) or re.search(r'---', line) or re.search(r':-*?', line))
+
+
+def delete_table_and_body(input_list):
+    return [line for line in input_list if not re.search(r'</?t(able|head|body)>', line)]
+
+
+def merge_table(md):
+    return convert_table_str(''.join(md))
+
+
+def replace_table_with_placeholder(input_string):
+    lines = input_string.split('\n')
+    output_lines = []
+    in_table_block = False
+    temp_block = ''
+    last_line = ''
+
+    for line in lines:
+        if '<table>' in line:
+            in_table_block = True
+            temp_block += last_line
+        elif in_table_block:
+            if not find_md_table_mode(last_line) and '</thead>' not in last_line:
+                temp_block += '\n' + last_line
+            if '</table>' in last_line:
+                if '<table>' not in line:
+                    in_table_block = False
+                    output_lines.append(merge_table(temp_block))
+                    temp_block = ''
+        else:
+            output_lines.append(last_line)
+        last_line = line
+
+    if last_line:
+        if in_table_block or '</table>' in last_line:
+            temp_block += '\n' + last_line
+            output_lines.append(merge_table(temp_block))
+        else:
+            output_lines.append(last_line)
+
+    return '\n'.join(output_lines)
+
+
+def convert_table(input_str):
+    output_str = input_str.replace('<table>', '<table border="1" >')
+    output_str = output_str.replace('<td>', '<td colspan="1" rowspan="1">')
+    return output_str
+
+
+def convert_markdown_to_html(markdown_content):
+    markdown_content = markdown_content.replace('\r', '') + '\n'
+    pattern = re.compile(r'\|\s*.*?\s*\|\n', re.DOTALL)
+    matches = pattern.findall(markdown_content)
+
+    for match in matches:
+        html_table = markdown_to_html(match)
+        markdown_content = markdown_content.replace(match, html_table, 1)
+
+    return convert_table(replace_table_with_placeholder(markdown_content))

track2_finixphoto_300/mds/00c07dff-e570-5c66-9caa-37b6254d859c.md

@@ -0,0 +1,47 @@
+住院次数 1
+
+# 河南省医疗住院收费票据
+
+呼吸内科
+
+票据代码:豫H010214
+
+票据校验码:RH010
+
+业务流水号: 0110600129 病案号: 28 09
+
+院区号:
+
+住院时间:
+
+10月19日
+
+287 09
+
+出院日期: 21
+
+NO.
+
+姓名:
+
+男
+
+社会保障号码:
+
+城镇职工（金保）
+
+<table><tr><th>收费项目</th><th>金额</th><th>个人支付金额</th><th>收费项目</th><th>金额</th><th>个人支付金额</th><th>收费项目</th><th>金额</th><th>个人支付金额</th></tr><tr><td>西药费</td><td>2318.58</td><td></td><td>中成药费</td><td>310.65</td><td></td><td>治疗费</td><td>468.50</td><td></td></tr><tr><td>放射费</td><td>390.00</td><td></td><td>化验费</td><td>2916.00</td><td></td><td>材料费</td><td>7.95</td><td></td></tr><tr><td>床位费</td><td>420.00</td><td></td><td>诊查费</td><td>63.00</td><td></td><td>其它</td><td>52.50</td><td></td></tr><tr><td>检查费</td><td>810.00</td><td></td><td></td><td></td><td></td><td>护理费</td><td>105.00</td><td></td></tr></table>
+
+本票据为财务专用章，严禁伪造、变造，否则无效
+
+医保卡余额: 201.48
+
+自费费用: 1455.93
+
+个人自付：364.56
+
+按比例自付：666.25
+
+<table><tr><td>合计（大写）：</td><td>柒仟壹佰陆拾贰元壹角捌分</td><td>7162.18</td><td>大额记账：</td><td>0</td></tr><tr><td>预缴金额：</td><td>3500.00</td><td>补缴金额：</td><td>0.00</td><td>退费金额：</td><td>113.26</td><td>公务员记账：</td><td>0</td></tr><tr><td>起付标准：</td><td>900</td><td>医保统筹支付：</td><td>3775.44</td><td>个人账户支付：</td><td>0</td><td>其他医保支付：</td><td>3386.74</td></tr><tr><td>收款单位(章)：</td><td colspan=7></td></tr><tr><td>收款人(签章)：</td><td colspan=7></td></tr></table>
+
+收款人(章)：

track2_finixphoto_300/mds/00cedd70-e693-42ac-855f-d8f9b0ccf8f3.md

@@ -0,0 +1,61 @@
+# 湖北省医疗单位住院收费票据
+
+费单位 武汉大学中南医院
+
+院科室 心脏血管外科病区
+
+00184902
+
+性别
+
+年龄
+
+住院
+
+时间
+
+2018年11月27日
+
+医保类型
+
+入院日期：2018年09月27日
+
+出院日期 2018年11月27日
+
+共住院 61 天
+
+结肠镜 300.00
+病室治疗费 211066.95
+住院费 3060.00
+同位素 80.00
+病检费 1515.00
+
+化验费 89815.00
+肺功能 4776.00
+心电图 485.00
+透析费 68910.00
+胃镜检查 4900.00
+
+B超费 4637.00
+西药费 478038.29
+手术费用 11128.60
+放射费 1085.00
+检查费 43464.00
+
+介入治疗 9000.00
+血费 59680.00
+中药费 4511.87
+CT费 1152.00
+仪器监测 37505.00
+
+纤支镜  5040.00
+
+（预收:924000.00(信用卡:924000) 补收: 信用卡:116139.71
+
+金额合计(大写)：壹佰零肆万零壹佰叁拾玖元柒角壹分
+
+￥1040139.71
+
+002501
+
+0002318

track2_finixphoto_300/mds/00e93638-9af3-4bca-b249-c414440b54dd.md

@@ -0,0 +1,53 @@
+发票号:9102454
+
+2020-06-29 16:16
+
+# 山西省医疗门诊收费票据
+
+56313.
+
+2020062990
+
+业务
+
+医疗类型：
+
+NO.91024540
+
+姓名：
+
+性别：
+
+医保类型：
+
+社会保障号码：
+
+<table><tr><td>项目规格</td><td>数量</td><td>金额</td><td>个人支付金额</td></tr><tr><td>各类病原体(DNA、RNA)测定</td><td>1.人次</td><td></td><td>60.00</td></tr><tr><td>核酸检测试剂</td><td>1.人份</td><td></td><td>14.08</td></tr></table>
+
+56313.160 共2条：应收74.08；实收74.08
+
+合计(大写) 柒拾肆元零角捌分
+
+￥ 74.08
+
+支付方式微信支付
+
+医保统筹支付：0.00
+
+个人账户支付： ￥0.00
+
+其他医保支付： 0.00
+
+个人支付金额：74.08
+
+山西省财政厅监制 银威特印业印制
+
+收据清单 盖章有效 遗失不补
+
+收款单位（章）：山西省人民医院检验科
+
+收款人(签章)： 90
+
+2020年06月29日
+
+2020-06-29 16:16

track2_finixphoto_300/mds/0170086d-957e-4ec2-b505-92cece37d302.md

@@ -0,0 +1,52 @@
+# 中国人民解放军医疗门诊收费票据
+
+ID: 70001729
+
+70001729
+
+票控盘号: 0010003698
+
+票控码：00100036986
+
+(2019): 1901088636
+
+业务流水号: B403449
+
+医疗机构类型：大型综合医院
+
+机打票号: 1901088636
+
+姓名:
+
+性别：女
+
+医保类型：
+
+社会保障号码：
+
+<table><tr><td>项目/规格</td><td>数量</td><td>金额</td><td>个人支付金额</td><td>项目/规格</td><td>数量</td><td>金额</td><td>个人支付金额</td></tr><tr><td>下腹部X体层(CT)增强扫描(乙)</td><td>1</td><td>每个部位 354.2</td><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+合计(大写)： 叁佰伍拾肆元贰角整
+
+￥ ：354.20
+
+医保统筹支付：
+
+个人账户支付：
+
+其他医保支付：
+
+个人支付金额：
+
+第一联 收据联 盖章有效 遗失不补 手写无效 
+二零二零年六月底前有效
+
+收款单位（盖章）：
+
+收款人(签章)：9490
+
+2020/03/06 缴费日期：2020-03-06
+
+年 月 日
+
+现金:354.20

track2_finixphoto_300/mds/0428c7d7-8d44-403a-8f16-c244fd488f86.md

@@ -0,0 +1,98 @@
+# 山 西 省 医 疗 住 院 收 费 票 据
+
+业务流水号：
+
+医疗机构类型：综合三甲
+
+病历号 003536
+
+住院号：003536
+
+住院时间： 2021 年 2 月 28 日到 2021 年 3 月 12 日
+
+住院天数：:12
+
+N  90014827
+
+山西省财政厅监制 山西卫生报印刷厂印制
+
+<table>
+<tr>
+  <td>姓名</td>
+  <td></td>
+  <td>性别</td>
+  <td>男</td>
+  <td>医保类型</td>
+  <td>其他人员</td>
+  <td colspan="3">社会保障号码</td>
+  <td></td>
+  <td></td>
+  <td></td></tr>
+<tr>
+  <td>项目</td>
+  <td>金额(元)</td>
+  <td>项目</td>
+  <td>金额(元)</td>
+  <td>项目</td>
+  <td>金额(元)</td>
+  <td>项目</td>
+  <td>金额(元)</td>
+  <td>项目</td>
+  <td>金额(元)</td></tr>
+<tr>
+  <td>床位费</td>
+  <td>444.00</td>
+  <td>诊察费</td>
+  <td>240.00</td>
+  <td>检查费</td>
+  <td>2102.00</td>
+  <td>化验费</td>
+  <td>1709.00</td>
+  <td>治疗费</td>
+  <td>4091.00</td></tr>
+<tr>
+  <td>手术费</td>
+  <td></td>
+  <td>护理费</td>
+  <td>519.00</td>
+  <td>卫生材料费</td>
+  <td>2119.53</td>
+  <td>西药费</td>
+  <td>8511.38</td>
+  <td>中草药费</td>
+  <td></td></tr>
+<tr>
+  <td>中成药费</td>
+  <td>744.98</td>
+  <td>药事服务费</td>
+  <td></td>
+  <td>一般诊疗费</td>
+  <td></td>
+  <td></td>
+  <td></td>
+  <td></td>
+  <td></td></tr>
+<tr>
+  <td colspan="5">合计（大写）贰万零肆佰捌拾元捌角玖分</td>
+  <td>¥</td>
+  <td colspan="2">20480.89</td>
+  <td>付款方式</td>
+  <td></td></tr>
+<tr>
+  <td colspan="4">预缴金额：11506.70 起付线 0</td>
+  <td colspan="3">补缴金额：</td>
+  <td colspan="3">退费金额：</td></tr>
+<tr>
+  <td colspan="2">医保统筹支付：8973.29</td>
+  <td colspan="2">个人账户支付： 0.90</td>
+  <td colspan="2">其他医保支付： 0.00</td>
+  <td colspan="4">个人支付金额： 11506.70</td></tr>
+</table>
+
+第一联 收据联 盖章有效 遗失不补
+
+收款单位（章）：山西白求恩医院
+
+收款人（签章）：5102
+
+2021年3月12日

track2_finixphoto_300/mds/0704a982-8416-4d2f-a2b1-f10506301d50.md

@@ -0,0 +1,25 @@
+# 华北理工大学附属医院
+
+# 出院记录
+
+姓名：-
+
+性別：男
+
+年龄：35岁
+
+病案号：
+
+入院日期：2019-10-
+
+出院日期： 2019-12-
+
+共住院71天
+
+入院当时情况：患者主因诊断骨髓增生异常综合征6月余入院，查体：T 36.9℃，P98112次/分，R19次/分，Bp132/63mmHg，贫血貌，周身皮肤粘膜无出血点，浅表淋巴结不大，巩膜无黄染，咽部无红肿，胸骨无压痛，双肺呼吸音清，未闻及干湿性啰音，心律齐，各瓣膜听诊区未闻及病理性杂音，腹平软，全腹无压痛，无反跳痛及肌紧张，肝、脾肋下未及。双下肢无水肿，病理征阴性。既往2型糖尿病病史6月，不规律口服"二甲双胍 格列齐特"治疗。
+
+入院诊断：骨髓增生异常综合征-RAEB-1（IPSS中危-1；IPSS-R 高危） 2型糖尿病。
+
+住院诊治经过：完善各项检查：1.依据：①患者中青年男性，急性病程。②诊断骨髓增生异常综合征5月。③临床上主要表现为乏力、出血、感染。患者2019年4月因头晕就诊于唐山市工人医院，初诊血常规WBC3.69×10^9/L，PLT61×10^9/L，HGB87g/l。骨髓常规、骨髓活检考虑MDS，未见PNH克隆；免疫分型：染色体：46，XY【4】，JAK2/V617F阴性。诊断为骨髓增生异常综合征-EB-1（IPSS中危-1），口服"司坦唑醇、升血宝、环孢素"治疗，后自行停药。2.依据既往病史诊断为2型糖尿病。患者血钾高，补充诊断：高钾血症。患者血钠低，补充诊断：低钠血症。依据凝血系列，补充诊断：低纤维蛋白原血症。患者HSCT术后早期，造血细胞植入不良，长期粒细胞减低，机体免疫力极度低下，近日持续低热，昨晚体温最高38.3℃，胸部CT未见明显炎性病变，故考虑为感染性发热，补充诊断。入院后查血常规(血细胞分析)(住院)：白细胞[WBC] 1.6x10⁹/L↓；血红蛋白[HGB] 58g/L↓；血小板[PLT] 28x10⁹/L↓；乙肝两对半(5项)：乙型肝炎病毒表面抗原 0IU /mL；肝肾功能、电解质：乳酸脱氢酶 340U /L↑，羟丁酸脱氢酶 283U /L↑，肌红蛋白 5ug /L↓，肌酐(氧化酶法) 55umol/L↓，葡萄糖 7.91mmol/L↑，铁 60.2umol/L↑；免疫系列(非医保)：补体C3 72.3mg /dl↓，补体C4 40.8mg /dl↑，免疫球蛋白A 85.4mg /dl↓，免疫球蛋白G 1000.0mg /dl↓，免疫球蛋白M 67.9mg /dl↓；凝血系列检查结果正常；甲功六项(电化学发光法)检查结果正常；梅毒螺旋体特异抗体测定ELA法 阴性(-)；请内分泌科会诊建议：普通胰岛素6u、6u、6u；三餐前半小时皮下注射；监测血糖4/日。头颅核磁：1.右侧额部大脑镰旁异常强化，不除外脑膜瘤，建议复查。2.脑实质MR平扫及增强扫描未见异常。腹部增强CT：1.肝左叶低密度影显示不清。2.胆囊密度欠均匀较前缓解。3.肝大，脾大，较前未见明显变化，请结合相关检查。4.胰腺CT增强未见异常。胸部CT：1.右肺上叶结节影，建议定期复查。2.两侧胸膜粘连，较前未见明显变化。3.心腔密度减低，较前未见明显变化，请结合临床。骨髓细胞学检查：骨髓增生重度低下，原粒细胞比例增高，红系比例增高，巨核细胞少伴部分巨核细胞形态异常。HSCT术后1月复查骨髓常规（髂后）：此部位骨
+
+第 1 页

track2_finixphoto_300/mds/0809dc84-f135-411e-9459-8d69bda2c15e.md

@@ -0,0 +1,43 @@
+# 哈尔滨医科大学附属肿瘤医院
+
+# （黑龙江省肿瘤医院）
+
+# 出 院 记 录
+
+姓名：
+
+性别：男
+
+年龄：53岁
+
+科别：
+
+住院号：
+
+入院科室：
+
+出院科室：
+
+入院日期：2019年12月
+
+出院日期：2019年12月
+
+入院诊断： 直肠癌
+
+出院诊断： 直肠癌
+
+入院情况：中年男患，既往体健，患者于2019年10月初无明显诱因出现排便习惯改变，肛门口可触及肿物，无便中带血，无黑便，无便稀，无便细，无里急后重，无肛门坠胀感，有排便不尽感，无腹泻，无腹痛，无贫血，无乏力，排便频率增加，2-3次/日。遂于当地医院行肛门检查示：肛门口见一肿物，质脆易出血。病理回报：直肠（腺癌）（大庆市第四医院）。2019年10月16日就诊于我院明确诊断：直肠癌，根据患者病情给予患者行直肠癌新辅助化疗XELOX方案化疗二周期，化疗后患者偶有上腹部不适，查体：一般状态良好，步入病房，神清语明，皮肤黏膜未见黄染，无出血点，双肺呼吸音清，心律齐，各瓣膜区未闻及病理性杂音，腹平软，未见肠型及蠕动波，无压痛、反跳痛及肌紧张，叩诊移动性浊音（-），肝脾肋下未及，双下肢无水肿。
+
+诊疗经过：患者按结直肠常规入院，入院后行相关检查检验，于住院期间行保肝对症治疗，治疗期间给予Xelox化疗方案一周期，化疗后患者无明显不适主诉，今日准予患者出院，嘱出院后行抗肿瘤综合治疗，并定期复查，不适随诊。
+
+出院时情况：患者一般状况良好，神清语明，心肺未见明显异常，腹部平软，全腹无压痛反跳痛及肌紧张，活动自如。今日出院，嘱定期复查。
+
+出院医嘱：1、定期复查2、不适随诊3、注意化疗期间饮食
+
+主治医师：
+
+2019年12月22日
+
+哈尔滨医科大学附属第三医院
+
+医疗表格统一编号1-02

track2_finixphoto_300/mds/08605a96-3a7d-4fad-9f0a-bfb3e5105d39.md

@@ -0,0 +1,35 @@
+# 郑州大学第五附属医院
+
+姓名
+
+性别 男
+
+年龄 45岁
+
+床号
+
+住院号
+
+2019.12
+
+# 出院记录
+
+姓名：
+
+性别:男
+
+年龄:45岁
+
+入院日期：2019.10
+
+出院日期：2019.12.
+
+共住院: 59天
+
+入院情况:患者中年男性,急性起病,以“(代)突起意识丧失6月余”为代主诉来院。既往“高血压”2年余,最高达160/100mmHg,未服用降压药物治疗。20年前行“阑尾切除术”;2年前行“喉息肉切除术”。无药物过敏史。入院查体:体温37.2℃,脉搏70次/分,呼吸18次/分,血压120/78mmHg。浅昏迷,高级智能不能查。双侧瞳孔等大等圆,直径约3mm,直接及间接对光反射存在;张口下颌不配合,双侧掌颏反射阴性;双侧额纹对称,双侧鼻唇沟对称,示齿口角不配合,味觉、听力不配合;双侧转颈耸肩查体不合作;伸舌不配合。四肢肌张力高,四肢腱反射活跃,四肢肌力查体不配合,双侧巴氏征阳性,双侧指鼻试验及跟-膝-胫试验不合作,闭目难立征不合作,无不自主运动。感觉系统检查查体不合作。自主神经系统检查阴性。脑膜刺激征阳性。双肺呼吸音粗,可闻及较多湿性啰音,心率70次/分,律齐,心音可,腹平软,无压痛及反跳痛,肝脾肋缘下未触及,双下肢无水肿。辅助检查:CT示(本院2019-9-17):1、脑干软化灶形成,结合病史考虑出血吸收后改变,对比2019.08.26片变化不明显。2、左侧基底节区腔梗、脑白质脱髓鞘;3、两肺炎症,对比2019.08.26片无明显变化。双侧胸膜增厚。
+
+入院诊断：1.脑出血；2.高血压病2级，极高危；3.肺炎；4、气管切开术后；5.亚甲状腺功能减退症；6.前列腺增生；7.肩关节半脱位；8.尿路感染；9.便秘；10.脂溢性皮炎。
+
+诊疗经过：入院后完善相关检查；给予吸氧、心电监护，密切观察病情变化；给予胞磷胆碱营养脑细胞、醒脑静促醒、鼠神经生长因子营养神经、痰热清祛痰、雾化祛痰、康复理疗等治疗。2019-10-16 尿常规：白细胞241.60/ul，上皮细胞0.60/ul，细菌5197.80/ul。血脂7项：甘油三酯2.00mmol/L，高密度脂蛋白胆固醇0.61mmol/L，载脂蛋白A10.90g/L。甲状腺功能五项：超敏促甲状腺激素0.424mIU/l，甲状腺球蛋白抗体>500.00U/ml，甲状腺过氧化物酶抗体1190.50U/ml。血沉：魏氏血沉40毫米/小时。痰培养及鉴定：培养出革兰氏阳性杆菌。患者脑出血，给予营养脑细胞、醒脑静促醒、鼠神经生长因子营养神经及康复治疗，给予美金刚改善认知，查脑电图明确病情变化；患者肺炎，给予依替米星抗炎抗感染、雾化祛痰等治疗。患者尿中白细胞数、细菌数明显增高，诊断为尿路感染，行尿培养查找敏感抗生素。患者发热、咳嗽咳痰，诊断为肺炎，根据药敏结果给予哌拉西林抗感染治疗，给予雾化祛痰、加强翻身拍背。患者尿中白细胞数、细菌数明显升高，诊断为尿路感染，给予诺氟沙星抗感染治疗，嘱患者多饮水。患者脑出血后浅昏迷，继续给予营养脑细胞、抗感染等治疗，行针灸、高压氧、免疫三氧血、康复理疗等治疗。患者脑出血后仍浅昏迷，给予吡拉西坦营养脑细胞、纳美芬促醒等治疗。经上述治疗，患者病情好转，要求出院，请示上级医师后同意其今日出院。
+
+第 1 页

track2_finixphoto_300/mds/09c2592b-a278-4bf9-99ba-4c7fbc91bb5d.md

@@ -0,0 +1,76 @@
+# 广西壮族自治区医疗住院收费票据
+
+1450602
+
+No 0002
+
+票据代码：
+
+专科医院
+
+票据号码：
+
+电子票据代码：
+
+中区直基本医疗保险
+
+电子票据号码:20731
+
+交款人统一社会信用代码
+
+校验码
+
+交款人：
+
+2021年03月15日-2021年04月25日
+
+普通居民
+
+开票日期：2021年04月25日
+
+<table><tr><td>项目名称</td><td>金额（元）</td><td>备注</td><td>项目名称</td><td>金额（元）</td><td>备注</td><td>项目名称</td><td>金额（元）</td><td>备注</td></tr><tr><td>西药</td><td>18,627.65</td><td></td><td>中成药</td><td>1,273.15</td><td></td><td>中草药</td><td></td><td></td></tr><tr><td>检查费</td><td>9,633.30</td><td></td><td>化验费</td><td>5,176.60</td><td></td><td>治疗费</td><td>77,516.10</td><td></td></tr><tr><td>手术费</td><td>292.00</td><td></td><td>输氧费</td><td></td><td></td><td>输血费</td><td></td><td></td></tr><tr><td>护理费</td><td>2,301.40</td><td></td><td>麻醉费</td><td>16.90</td><td></td><td>注射费</td><td></td><td></td></tr><tr><td>病理费</td><td>687.60</td><td></td><td>床位费</td><td>571.00</td><td></td><td>材料费</td><td>2,350.96</td><td></td></tr><tr><td>特殊检查费</td><td></td><td></td><td>特殊治疗费</td><td></td><td></td><td>其他费用</td><td>174.60</td><td></td></tr>
+   </table>
+
+金额合计（大写）壹拾壹万捌仟陆佰贰拾壹元贰角柒分
+
+（小写）118,621.27
+
+其他信息
+
+预交金额：70000.00
+
+补交金额：27211.88
+
+退款金额：0.00
+
+社保账号：
+
+公务员补助：0.00
+
+大额医疗支付：
+
+统筹支付累计：0.00
+
+大额医疗支付累计: 0.00
+
+账户余额： 0.00
+
+医保统筹支付: 21409.39
+
+个人账户支付：0.00
+
+其他医保支付：
+
+个人支付金额：97211.88
+
+异地结算
+
+广西瑞熙特种票证印务有限公司承印 0771-3899843
+
+第一联 收据
+
+收款单位（章）：广西医科大学附属肿瘤医院
+
+复核人：
+
+收款人：

track2_finixphoto_300/mds/0b270427-6cba-48f7-93cc-aab09ab25784.md

@@ -0,0 +1,55 @@
+# 福建省医疗机构住院收费票据
+
+№：00
+
+00217070
+
+姓名：唐仙
+
+科别： 神内科②组
+
+00FE009246E209F760
+
+住院号：595470
+
+流水号：4519476
+
+2014年12月01日
+
+<table><thead><tr><td>项目</td><td>金额</td><td>项目</td><td>金额</td><td>项目</td><td>金额</td></tr></thead><tbody><tr><td>西药费</td><td>973.61</td><td>检查费</td><td>565.30</td><td>输氧费</td><td>162.00</td></tr><tr><td>床位费</td><td>402.00</td><td>化验费</td><td>1,360.35</td><td></td><td></td></tr><tr><td>诊察费</td><td>44.00</td><td>治疗费</td><td>107.10</td><td></td><td></td></tr><tr><td>护理费</td><td>105.00</td><td>其他费</td><td>106.40</td><td></td><td></td></tr></tbody></table>
+
+合计人民币(大写)：叁仟捌佰贰拾伍元柒角陆分
+
+¥：3,825.76
+
+付款方式：
+
+现金： ¥
+
+转账：￥
+
+预收款：4200.00
+
+应补交：0.00
+
+应退还：374.24
+
+个人医疗账户支付：0.00
+
+莆田小鱼网
+
+www.phish.com
+
+统筹基金支付：0.00
+
+自付：3,825.76
+
+电脑打印，手写无效
+
+第一联 收据
+
+医疗单位收费章 结算日期：20141122 -20141201
+
+经办人：潘美华
+
+（未经收费单位盖章无效）

track2_finixphoto_300/mds/0b6a9275-725c-4f4b-873c-a20af0ed0ec8.md

@@ -0,0 +1,53 @@
+# 湖北增值税普通发票
+
+042001900104
+
+№ 46751023
+
+机器编号：
+
+开票日期: 2020年03月01日
+
+购买方
+
+名 称：
+纳税人识别号：
+地址、电话：
+开户行及账号：
+
+密码区
+
+03<023>68**>3<8<+700**838857
+464/7<6003<023>68**>3<8<9627
++7>8
+
+<table><tr><td>货物或应税劳务、服务名称</td><td>规格型号</td><td>单位</td><td>数量</td><td>单价</td><td>金额</td><td>税率</td><td>税额</td></tr><tr><td>*餐饮服务*餐饮费</td><td></td><td></td><td></td><td></td><td>1.00</td><td>免税</td><td>***</td></tr><tr><td>合计</td><td></td><td></td><td></td><td></td><td>￥1.00</td><td></td><td>***</td></tr></table>
+
+价税合计（大写）
+
+⊗壹圆整
+
+(小写)¥1.00
+
+销售方
+
+名　称：
+纳税人识别号：
+地 址、电 话：
+开户行及账号：
+
+备注
+
+校验码 00718
+
+税总函〔2019〕119号 上海东港安全印刷有限公司
+
+第一联：记账联 销售方记账凭证
+
+收款人：陈锦华
+
+复核：林会
+
+开票人：刘程
+
+销售方：（章）

track2_finixphoto_300/mds/0c84a961-ddfe-4c95-84c6-2cee1f9d7bff.md

@@ -0,0 +1,46 @@
+# 哈尔滨医科大学附属肿瘤医院
+
+# （黑龙江省肿瘤医院）
+
+# 出 院 记 录
+
+姓名:
+
+性别：女
+
+年龄：55岁
+
+科别：
+
+住院号：
+
+入院科室：
+
+出院科室：
+
+入院日期：2019年12月
+
+出院日期：2019年12月
+
+入院诊断：左肺上叶癌可能，右肺结节
+
+出院诊断：左肺上叶癌，右肺结节
+
+入院情况：患者一般状态良好，头面部无水肿，颈静脉无怒张，气管居中，未触及明显肿大浅表淋巴结，胸廓无畸形，胸式呼吸对称，胸腹壁无静脉曲张。双肺语颤对等无减弱。未触及胸膜摩擦感，双肺叩诊呈清音，双肺听诊未闻及干湿啰音及其他异常呼吸音。无副癌综合症。腹部无压痛，四肢活动自如，神经反射存在，病理反射未引出。
+
+诊疗经过：患者于2019年12月入院，行术前检查，是手术适应症，未见手术禁忌症，于2019年12月13日行单孔胸腔镜下左肺上叶癌根治术（左肺上叶切除淋巴结清扫术），术后行抗感染治疗、祛痰治疗、雾化吸入、维护心功、维护肝功、抑酸治疗、增强机体免疫力等治疗。术后病理未见回报。治疗过程顺利，无并发症或不良反应发生。
+
+出院时情况:一般状态良好，神清语明，查体配合。切口愈合良好，无红肿及渗出。已拔除胸引流管。
+
+出院医嘱：
+
+1. 继续对症治疗
+2. 随诊
+3. 定期复查
+4. 一个月后门诊复查
+
+主治医师：
+
+2019年12月
+
+哈尔滨医科大学附属第三医院　　　　　　　　　　　　　　　　　　医疗表格统一编号1-02

track2_finixphoto_300/mds/0d3c3350-3db0-5dc3-8c69-03a8c4a10185.md

@@ -0,0 +1,32 @@
+# 哈尔滨医科大学附属肿瘤医院
+
+## （黑龙江省肿瘤医院）
+
+# 出院诊断证明书
+
+<table><tr><td>姓名：</td><td></td><td>性别：女</td><td>年龄：56岁</td><td>科别：</td><td></td><td>住院号：</td><td></td></tr></table>
+
+住  所：
+
+诊  断： 右肺癌    右肺门淋巴结转移
+
+治疗经过：该患复查胸CT：病灶略缩小；给予版白蛋白结合型紫杉醇联合卡铂方案全身化疗一周期，化后升白对症处置。
+
+<table><tr><td>入院日期：</td><td>自</td><td>2019年12月</td><td>起</td></tr><tr><td colspan=4 style="text-align:center">共住院 6 天</td></tr><tr><td>出院日期：</td><td>至</td><td>2019年12月</td><td>止</td></tr></table>
+
+治疗结果： 未愈
+
+## 出院后注意事项：
+
+1. 注意休息，加强营养，预防感染；2. 继续保肝、升白等对症治疗；3. 每3-5天复查血常规、肝肾功，病情变化随诊（白细胞<4.0*10^9/L, 中性粒细胞：<2.0*10^9/L, 血小板<100*10^9/L联系主管医生）；4. 定期返院检查及治疗。
+
+主任医生：
+2019年12月
+
+注：如出院患者需要病历复印件，请到病案室申请办理：
+1. 申请人为患者本人的需提供本人有效身份证明。
+2. 申请人为患者代理人的应提供患者及代理人的有效身份证明。
+
+哈尔滨医科大学附属第三医院
+
+医疗表格统一编号1-17

track2_finixphoto_300/mds/0f1638f7-bfc1-4d10-847a-c335659af13a.md

@@ -0,0 +1,54 @@
+# 内蒙古自治区医疗住院收费票据
+
+业务流水号：
+
+医疗机构：包头市肿瘤医院
+
+医保类型：城镇职工
+
+住院时间：2021-01-19至2021-02-05
+年 月 日到
+
+年 月 日
+
+住院天数：7 天
+
+住院/病历号：2021011
+
+NO. 20021868
+
+姓名：
+
+性别：男
+
+年龄：57
+
+社会保障号码：150200D15600
+
+<table><tr><td>收费项目</td><td>金额</td><td>收费项目</td><td>金额</td><td>收费项目</td><td>金额</td></tr><tr><td>化验费：</td><td>5,726.00</td><td>药费</td><td>7,198.42</td><td>检查费</td><td>4,541.00</td></tr><tr><td>治疗费</td><td>18,691.27</td><td>手术费</td><td>2,800.00</td><td>输氧费</td><td>451.00</td></tr><tr><td>CT费</td><td>1,880.00</td><td>床位费</td><td>1,060.00</td><td>取暖费</td><td>160.00</td></tr><tr><td>其他费</td><td>120.00</td><td></td><td></td><td></td><td></td></tr></table>
+
+合计（大写）：肆万贰仟陆佰贰拾柒圆陆角玖分
+
+￥：42,627.69
+
+预缴金额：37,000.00
+
+补缴金额:0.00
+
+退费金额:26,994. 52
+
+起付钱支付:600.00
+
+基金支付:32,622. 21
+
+个人账号支付：0.00
+
+个人支付金额：10,005.48
+
+第一联
+
+收款单位（章）：
+
+收款人：张慧娟
+
+日期：2021-2-5 10:45:49

track2_finixphoto_300/mds/0ff98c5a-5d36-4bb7-bfa8-aa408d548f21.md

@@ -0,0 +1,27 @@
+# 浙江省医疗机构住院收费收据(351)
+
+医疗卡号：
+
+十六病区
+
+№ 1200271258
+
+人员类别：
+
+自费医保
+
+结算日期： 2013年02月23日
+
+<table><tr><td colspan="2">姓名:何梓诺</td><td colspan="4">工作单位:无</td></tr><tr><td colspan="2">住院号:00666484</td><td colspan="4">住院日期:2013.02.18-2013.02.23 共5天</td></tr><tr><td>收费项目</td><td>金额</td><td>其中自理自费</td><td colspan="3">结算信息</td></tr><tr><td>西药费</td><td>977.38</td><td>24.94</td><td colspan="2">项目</td><td>金额</td></tr><tr><td>中成药</td><td>24.90</td><td>0.75</td><td colspan="2">现金(支票)</td><td></td></tr><tr><td>中草药</td><td></td><td></td><td colspan="2">本年账户</td><td></td></tr><tr><td>床位费</td><td>200.00</td><td></td><td colspan="2">历年账户</td><td></td></tr><tr><td>诊查费</td><td>30.00</td><td></td><td colspan="2">医保账户</td><td></td></tr><tr><td>检查费</td><td>118.00</td><td>8.00</td><td colspan="2"></td><td></td></tr><tr><td></td><td></td><td></td><td colspan="2"></td><td></td></tr><tr><td></td><td></td><td></td><td colspan="2"></td><td></td></tr><tr><td>检验费</td><td>2,228.00</td><td>309.00</td><td colspan="2">合计</td><td></td></tr><tr><td>治疗费</td><td>629.00</td><td></td><td colspan="3">现金(支票)结算明细</td></tr><tr><td></td><td></td><td></td><td colspan="2">预缴款</td><td>5,000.00</td></tr><tr><td>手术费</td><td></td><td></td><td colspan="2">补缴</td><td></td></tr><tr><td>输血费</td><td></td><td></td><td colspan="2">其中:现金</td><td></td></tr><tr><td>护理费</td><td>52.00</td><td></td><td colspan="2">支票</td><td></td></tr><tr><td>材料费</td><td>82.45</td><td></td><td colspan="2"></td><td></td></tr><tr><td>其他</td><td>3.00</td><td>3.00</td><td colspan="2">退款</td><td>584.67</td></tr><tr><td>输氧费</td><td>4.00</td><td></td><td colspan="2">其中:现金</td><td>584.67</td></tr><tr><td>注射费</td><td>66.60</td><td></td><td colspan="2">支票</td><td></td></tr><tr><td>合计</td><td>4,415.33</td><td>345.69</td><td colspan="2"></td><td></td></tr><tr><td colspan="6">合计金额(大写)肆仟肆佰壹拾伍元叁角叁分</td></tr><tr><td colspan="6">备注：预缴款：373740</td></tr></table>
+
+第二联 收据联
+
+浙江致用印务中心承印 2012.06*2万份×2联
+
+盖章有效 遗失不补
+
+领款人(签章)：83
+
+收银员：83
+
+注：本票据限于2014年12月31日前填开使用方为有效。

track2_finixphoto_300/mds/1290989e-ba23-46e9-adab-802a00fb3472.md

@@ -0,0 +1,75 @@
+141436767
+
+# 河南省医疗住院收费票据
+
+出院全结
+
+业务流水号
+
+医疗机构类型：
+
+住院科室 儿科病区
+
+病历号：201744286
+
+票据代码：豫财
+
+票据标次：MB [2615]
+
+住院号：
+
+住院时间：2017.10.29 年 月 日到 2017.11.6 年 月 日
+
+住院天数：8天
+
+NO.1436767
+
+姓名：景品之子[新农合]
+
+性别：
+
+医保类型：
+
+社会保障号码：
+
+<table><tr><td>收费项目</td><td>金额</td><td>个人支付金额</td><td>收费项目</td><td>金额</td><td>个人支付金额</td><td>收费项目</td><td>金额</td><td>个人支付金额</td><td></td><td></td><td></td></tr><tr><td>西药费</td><td>567.60</td><td></td><td>中成药</td><td></td><td></td><td>中草药</td><td></td><td></td><td>化验费</td><td>665.00</td><td></td></tr><tr><td>检查费</td><td></td><td></td><td>治疗费</td><td>629.72</td><td></td><td>手术费</td><td></td><td></td><td>接生费</td><td></td><td></td></tr><tr><td>材料费</td><td>121.80</td><td></td><td>床位费</td><td>192.00</td><td></td><td>护理费</td><td></td><td></td><td>血费</td><td></td><td></td></tr><tr><td>放射费</td><td>60.00</td><td></td><td>CT费</td><td></td><td></td><td>输氧费</td><td></td><td></td><td>其他费</td><td>16.00</td><td></td></tr></table>
+
+2252.21
+
+0.00
+
+0.00
+
+合计(大写) ：贰仟贰佰伍拾贰元贰角壹分
+
+￥：2252.21
+
+预缴金额：3000.00
+
+补缴金额：
+
+退费金额：747.79
+
+起付标准：
+
+医保统筹支付：
+
+个人账户支付：
+
+其他医保支付：
+
+个人支付金额：2252.21
+
+第一联 收据联 盖章有效 遗失不补
+
+收款单位（章）：00362350
+
+0137
+
+收款人（签章）：0137
+
+2017-11-06 10:29
+
+年 月 日
+
+结账人签字：

track2_finixphoto_300/mds/12adc3bc-a164-4791-94ce-7ecc9845d407.md

@@ -0,0 +1,39 @@
+# 福建省肿瘤医院病历记录
+
+姓名：
+
+病区:
+
+床号：
+
+住院号：
+
+# 出 院 记 录
+
+姓名：
+
+性别：女
+
+年龄：52岁
+
+婚姻：离婚
+
+职业：个体户
+
+入院日期：2019-11
+
+出院日期：2019-11
+
+共住院: 9 天
+
+手术日期：2019-11
+
+入院诊断：1. 左乳浸润性癌伴左腋窝左锁骨上淋巴结转移化疗后（cT4N3M0 Ⅲc期）；2. 高胆固醇血症；3. PICC置管术后
+
+出院诊断：1. 左乳浸润性癌伴左腋窝左锁骨上淋巴结转移化疗后（cT4N3M0 Ⅲc期）；2. 高胆固醇血症；3. PICC置管术后
+
+住院经过：以"确诊 "左乳癌"6月余，化疗后18天"为主诉入院。入院查体：ECOG1分，神志清楚，营养一般。双锁骨上、腋窝等处浅表淋巴结未触及肿大。双乳发育正常，乳房皮肤未见红、肿及橘皮样改变；右乳头无内陷或朝向改变，挤压无溢液。左乳头内陷，双乳未触及明显肿物。右侧贵要静脉PICC置管通畅，周围皮肤未见红肿及分泌物。心肺查体无异常。腹平软，无压痛、反跳痛，未触及包块，肝、脾肋下未触及。入院前查肺部CT：1、右肺上叶微小结节，建议随访；2、左乳癌伴左侧腋窝淋巴结肿大较前大致相仿，建议结合乳腺相关检查。骨ECT：考虑右肩关节良性病变可能，较2019-5-16旧片81102相仿。入院后查三大常规、生化全套、APTT、PT、乙肝二对半、抗HCV、TP、抗HIV无明显异常；心电图：1、窦性心律；2、大致正常心电图。心超示：1、心脏结构未见明显异常；2、左室舒张功能降低。彩超：1、左乳4点处低回声区（结合临床：倾向乳腺癌治疗中），BI-RADS 6类；2、左腋下组多发淋巴结肿大（结合临床：倾向转移治疗中）；3、倾向右乳腺体退化不全，BI-RADS 2类；4、倾向右肝局灶性钙化灶；脂肪肝；5、门脉未见明显占位；6、右腋窝、腹主动脉、下腔静脉及双侧髂血管周围未见明显肿大淋巴结。完善相关检查，未发现明显手术禁忌症，于2019-11-08在全麻下行"左乳腺单纯切除术及左腋窝淋巴结清扫术"。术后予输液、预防性止血、改善皮瓣血运及止痛等治疗。术后恢复好。现患者无明显不适，左胸壁皮瓣紧贴，血运正常，切口愈合好。现予带管出院。
+
+出院医嘱：1、门诊定期随访、复查；
+
+第 1 页

track2_finixphoto_300/mds/12e1b36e-6f63-52e0-9d2c-fb5660dca9a4.md

@@ -0,0 +1,45 @@
+# 广东省医疗收费票据
+# Medical Invoice of Guangdong Province
+
+1001574156
+
+JV07366118
+
+业务流水号：
+
+社会保障号：
+
+病历号：
+
+住院（科室）：儿童血液肿
+
+院号：P519491
+
+医院类型：综合医院
+
+2016年7月18日
+
+<table><tr><td>姓名</td><td colspan="2">陈俊楠</td><td>?门诊 ?急诊 √住院</td><td>住院日期</td><td>2016.7.09</td><td>出院日期</td><td>26.07.18</td></tr><tr><td>性别</td><td>?男 ?女</td><td></td><td>?5238.59</td><td>个人缴费</td><td>?6151.07</td><td>结算方式</td><td>现金</td></tr><tr><td>医药费</td><td>金额</td><td>诊查费</td><td>金额</td><td>治疗费</td><td>金额</td><td>其他</td><td>金额</td></tr><tr><td>西药费</td><td>6203.39</td><td>诊查费</td><td>45.00</td><td>治疗费</td><td>1380.29</td><td>床位费</td><td>892.00</td></tr><tr><td></td><td></td><td>检查费</td><td>100.00</td><td>手术费</td><td>25.00</td><td>护理费</td><td>421.98</td></tr><tr><td></td><td></td><td>检验费</td><td>2175.00</td><td></td><td></td><td>其他</td><td>147.00</td></tr><tr><td>预交款</td><td>6839.12</td><td>补收</td><td>0.00</td><td>退款</td><td>688.05</td><td>欠费</td><td>0.00</td></tr><tr><td colspan="2">合计人民币（大写）</td><td colspan="4">零拾壹万壹仟叁佰捌拾玖元陆角陆分</td><td colspan="2">￥：1389.66</td></tr></table>
+
+备注
+
+1、药品费包括：西药、中成药及中草药等
+2、诊查费包括：诊金、化验及体检等检查项目
+3、治疗费包括：正骨、敷贴、针灸、推拿、放疗、化疗、手术及材料等
+4、其它费用：床位、护理、药事服务、医学鉴证、司法鉴定等费用
+
+市异地医保
+
+梅州医保(新异地)
+
+第一联 交缴款人（收据联）
+
+收费单位(盖章)：
+
+复核：
+
+收款人： HX009 
+
+广东省财政厅印制
+
+（手写无效，限2017年6月30日前使用）

track2_finixphoto_300/mds/130a7f45-b7f6-4304-b276-5ebe82f3a1de.md

@@ -0,0 +1,83 @@
+# 山东省医疗住院收费票据
+
+No. A 4030830035
+
+业务流水号：S1009
+
+医疗机构类型：
+
+病历号：
+
+校验码：
+
+住院时间：2020年04月02日到2020年05月08日
+
+住院天数：36
+
+住院号：05842
+
+姓名：
+
+性别：男
+
+医保类型：
+
+跨省居民医
+
+社会保障号码：
+
+<table><tr><td>收费项目</td><td>金额</td><td>个人支付金额</td><td>收费项目</td><td>金额</td><td>个人支付金额</td><td>收费项目</td><td>金额</td><td>个人支付金额</td></tr><tr><td>床位费</td><td>2520.00</td><td>2520.00</td><td>放射费</td><td>1730.00</td><td>1730.00</td><td></td><td></td><td></td></tr><tr><td>西药费</td><td>23637.66</td><td>23637.66</td><td>诊查费</td><td>1008.00</td><td>1008.00</td><td></td><td></td><td></td></tr><tr><td>材料费</td><td>2382.48</td><td>2382.48</td><td>治疗费</td><td>18117.50</td><td>18117.50</td><td></td><td></td><td></td></tr><tr><td>其他费</td><td>956.00</td><td>956.00</td><td>检查费</td><td>4159.50</td><td>4159.50</td><td></td><td></td><td></td></tr><tr><td>化验费</td><td>4652.00</td><td>4652.00</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>护理费</td><td>3362.00</td><td>3362.00</td><td></td><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+本次结算总费用：62525.14
+
+病人负担：25703.53
+
+医保负担：36821.61
+
+医疗补助：0
+
+医院负担：0
+
+个人账户：0
+
+统筹支付：32546.54
+
+其他统筹支付：4275.07
+
+二次报销金额：0
+
+大病补助金额：
+
+4275.07
+
+本次起付线：800
+
+省医保账户(亲属)：0
+
+合计(大写)： 陆万贰仟伍佰贰拾伍元壹角肆分
+
+￥ 62525.14
+
+预缴金额：61000.00
+
+补缴金额：0.00
+
+退费金额：35296.47
+
+医保统筹支付：
+
+个人账户支付：
+
+其他医保支付：
+
+个人支付金额：
+
+202印制 2010-11-Y-0034（机打票据 手写无效）
+
+第三联 收据 盖章有效 遗失不补
+
+收款单位（章）：山东大学第二医院
+
+收款人（签章）：5629
+
+2020年05月13日

track2_finixphoto_300/mds/13eedc25-e64d-4110-9bd5-e39a8a7508c7.md

@@ -0,0 +1,65 @@
+# 重庆市医疗住院收费票据（电子）
+
+票据代码：500602
+
+票据号码：00127225
+
+交款人统一社会信用代码: 51022119600402****
+
+校验码:0f9b
+
+交款人
+
+开票日期：2021-06-01
+
+<table><tr><td>项目名称</td><td>金额（元）</td><td>备注</td><td>项目名称</td><td>金额（元）</td><td>备注</td><td>项目名称</td><td>金额（元）</td><td>备注</td></tr><tr><td>床位费</td><td>560.00</td><td></td><td>诊察费</td><td>187.50</td><td></td><td>检查费</td><td>4159.75</td><td></td></tr><tr><td>化验费</td><td>4347.40</td><td></td><td>治疗费</td><td>1746.05</td><td></td><td>手术费</td><td>7112.10</td><td></td></tr><tr><td>护理费</td><td>402.80</td><td></td><td>卫生材料费</td><td>35082.96</td><td></td><td>西药费</td><td>4273.46</td><td></td></tr><tr><td>一般诊疗费</td><td>47.90</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+金额合计（大写）伍万柒仟玖佰壹拾玖元玖角贰分
+
+（小写）57919.92
+
+其他信息
+
+业务流水号：
+
+病历号：
+
+住院号：
+
+住院科别
+
+住院时间：20210525
+
+预缴金额：55000.00
+
+补缴金额:0.00
+
+退费金额:4335.17
+
+医疗机构类型：三级甲等综合医院
+
+医保类型：居民医保
+
+医保编号：
+
+性别:男
+
+医保统筹基金支付
+
+其他支付：0.10
+
+个人账户支付:0.00
+
+个人现金支付：50664.83
+
+个人自付:0.00
+
+个人自费：50664.83
+
+医院垫付:0.10元
+
+收款单位（章）：重庆医科大学附属第一医院
+
+复核人：王琼
+
+收款人：王琼

track2_finixphoto_300/mds/15fbe32f-5851-45ee-9247-9932d9cda3e2.md

@@ -0,0 +1,55 @@
+# 海南省医疗门诊收费票据（电子）
+
+票据代码: 460601
+
+票据号码：00219142
+
+交款人统一社会信用代码: 90080041
+
+校验码: 9833
+
+交款人：
+
+开票日期：2021-05-12
+
+<table><tr><td>项目名称</td><td>数量/单位</td><td>金额（元）</td><td>备注</td><td>项目名称</td><td>数量/单位</td><td>金额（元）</td><td>备注</td></tr><tr><td>病理费</td><td>1 元</td><td>418.00</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>病理体视学检查与图象分析(</td><td>1 次</td><td>88.00</td><td></td><td>局部切除组织活检检查与诊</td><td>5 每个</td><td>330.00</td><td></td></tr></table>
+
+金额合计(大写)肆佰壹拾捌元整
+
+(小写)418.00
+
+其他信息
+
+业务流水号：0502104
+
+门诊号：900800
+
+就诊日期：20210512
+
+医疗机构类型：综合性医院
+
+医保类型：自费
+
+医保编号：
+
+性别：女
+
+医保统筹基金支付：0.00
+
+其他支付：0.00
+
+个人账户支付：0.00
+
+个人现金支付：418.00
+
+个人自付：
+
+个人自费：
+
+050210416174
+
+收款单位（章）：海南医学院第一附属医院
+
+复核人：郑丹丹
+
+收款人：郑丹丹

track2_finixphoto_300/mds/16cd5c50-5086-5fbe-a1a6-7e7be304140a.md

@@ -0,0 +1,15 @@
+# 四川增值税专用发票
+
+5100191160
+
+NO 22222222
+
+5100191160
+
+22222222
+
+开票日期：2019年2月21日
+
+<table><tr><td>购买方</td><td><b>名称：</b>小艾财税咨询有限公司<br><b>纳税人识别号：</b>2222222222222222<br><b>地址、电话：</b><br><b>开户行及账号：</b></td><td>销售方</td><td><b>名称：</b>***<br><b>纳税人识别号：</b>222-40+0/034x0*200+855+353*5+<-5414/813025*+<5-23-4259-51-9/621222/3946/6130/21085062*+016921198+6534/222<br><b>地址、电话：</b><br><b>开户行及账号：</b></td></tr><tr><td colspan=2>货物或应税劳务、服务名称</td><td>规格型号</td><td>单位</td><td>数量</td><td>单价</td><td>金额</td><td>税率</td><td>税额</td></tr><tr><td colspan=2>*运输服务*公路运输服务</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td colspan=5>合计</td><td></td><td></td><td></td></tr><tr><td colspan=5>价税合计(大写)</td><td colspan=4>（小写）</td></tr></table>
+
+<table><tr><td>销售方</td><td><b>名称：</b>***有限公司<br><b>纳税人识别号：</b>915000000000000000<br><b>地址、电话：</b>四川省成都市***028-22222222<br><b>开户行及账号：</b>工行***支行 222222222222222</td><td>备注</td><td><b>起运地：</b>成都，到达地：西安<br><b>货物：</b>实木桌椅<br><b>车种：</b>东风一吨轻型厢式货车<br><b>车号：</b>川A 8G222</td></tr><tr><td colspan=2>收款人：小李</td><td colspan=2>复核：小艾</td><td colspan=2>开票人：小王</td><td colspan=2>销售方：（章）</td></tr></table>

track2_finixphoto_300/mds/1721a339-a34a-4f54-bc61-3c4ec1dcf09d.md

@@ -0,0 +1,40 @@
+# 明市儿童医院出院记录
+
+姓名：
+
+号：902180
+
+性别：女
+
+床号：08
+
+转归：治
+
+天
+
+入院科室：烧（创）伤整形外科病区
+
+入院时间：2020年10月25日18时56分
+
+出院科室：烧（创）伤整形外科病区
+
+出院时间：2020年11月11日10时12分
+
+入院诊断：
+1. 猴咬伤致面部皮肤裂伤, 2. 面部皮肤裂伤清创缝合术后伤口感染, 3. 面部皮肤瘢痕形成
+
+出院诊断：
+1. 右面部创伤后皮肤感染性窦道。2. 猴咬伤右面部清创缝合术后伴感染。3. 皮肤和皮下组织的局部感染。
+
+患者入院情况：患儿因“不慎被野生猴子咬伤面部清创缝合术后8日余”于2020-10-25 18:56入院。查体：体温36.5℃，心率104次/分，呼吸22次/分，体重20.5kg，疼痛评分2分，营养评估风险评分2分，压疮风险评分23分，跌倒风险评分10分。神志清楚，未见三凹征，全身皮肤黏膜无黄染点；头颅外形正常，巩膜无黄染，双侧瞳孔等大等圆，对光反射存在；双肺呼吸音清，未闻及干湿性啰音；心音有力，律齐，各瓣膜听诊区未闻及病理性杂音；腹平软，无压痛及反跳痛肌紧张，肝脾肋下未触及，肠鸣音正常，4次/分；脊柱四肢外形正常，肌力肌张力正常，各关节活动正常，生理反射存在，病理反射未引出，肢端暖，未见花斑；
+
+患者住院经过（治疗方案、患者病情变化、并发症）：患儿因“不慎被野生猴子咬伤面部"于2020-10-25 18:56入院，入院后予完善相关检查，静脉予甲硝唑抗炎、破伤风抗毒素肌注，止血药物静滴抑制出血，急诊送手术室颜面清创、面部引流术，面部外伤扩创清缝合术，脓腔隧道去除，创面负压封闭引流术”，皮下空腔予三明治贯浇，负压封闭缩小皮下空腔，定期换药治疗，后创面基底空腔缩窄，并于2020-11-09因在麻醉下行“面部残余创面扩创清创缝合术+任意皮瓣形成覆盖术”，术后第2天，伤口换药见术区愈合固定，对合良好，未见明显异常渗出。患儿术后病情平稳，予以拆线、换药、今日患儿一般情况好，嘱出院后继续门诊换药，术后5-7天返院拆线。愈合后早期瘢痕防治及防晒。
+
+重要检查检验及结果：2020-10-27，分泌物培养（用无菌干棉签取样）（样本：分泌物），嗜血杆菌培养 未分离到嗜血杆菌属细菌，一般细菌培养 2天培养无生长；
+
+患者出院时情况：缝合术后第2天，今日换药见术区缝合固定，对合良好，未见明显渗出，原创口延期缝合处轻度瘢痕形成。今日出院，嘱出院后继续门诊换药，术后5-7天拆线，愈合后早期瘢痕防治及防晒。
+
+出院医嘱（包括出院带药、植入物、交通工具等）：
+1、门诊随诊，如有不适，随时就诊。出院后继续门诊换药，术后5-7天返院拆线。愈合后早期瘢痕防治及防晒。
+2、出院带药：无，无植入物。
+3、交通工具：自行。

track2_finixphoto_300/mds/17431f4c-4db9-4ced-bee1-e8c24d8df3e1.md

@@ -0,0 +1,53 @@
+ID:80012336
+
+# 中国人民解放军医疗门诊收费票据
+
+80012336
+
+票控盘号：0010003693
+
+票控码：001000369339-1698893
+
+(2019)：1901135782
+
+业务流水号 B403700
+
+医疗机构类型：大型综合医院
+
+机打票号：1901135782
+
+姓名：
+
+性别：女
+
+医保类型：
+
+社会保障号码：
+
+<table><tr><td>项目/规格</td><td>数量</td><td>金额</td><td>个人支付金额</td><td>项目/规格</td><td>数量</td><td>金额</td><td>个人支付金额</td></tr><tr><td>APTT活化部分凝血活酶时间(8.8)</td><td>1项</td><td>18.8</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>乙型肝炎表面抗体测定(定量)</td><td>1项</td><td>24.4</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>血浆凝血酶原时间(PT)测定(全自动仪)</td><td>1项</td><td>18.8</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>凝血酶时间TT测定(全自动仪)8.8</td><td>1项</td><td>18.8</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>乙型肝炎e抗原测定(定量)</td><td>1项</td><td>24.4</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>血浆纤维蛋白原测定(仪器法)11</td><td>1项</td><td>19</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>乙型肝炎e抗体测定(定量)</td><td>1项</td><td>24.4</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>乙型肝炎核心抗体测定(定量)</td><td>1项</td><td>24.4</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>乙型肝炎表面抗原测定(定量)</td><td>1项</td><td>24.4</td><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+合计(大写)：壹佰玖拾柒元肆角整
+
+￥：197.40
+
+医保统筹支付：
+
+个人账户支付：
+
+其他医保支付：现金：197.40
+
+个人支付金额：
+
+2020/05/06
+
+缴费日期：2020-05-06
+
+第一联 收据联 盖章有效 遗失不补 手写无效
+
+二零二零年六月底前有效
+
+收款单位(盖章)：
+
+收款人(签章)：2964（132）
+
+年 月 日

track2_finixphoto_300/mds/1833ad18-dc1d-486b-8c59-7e9b89eb56f1.md

@@ -0,0 +1,35 @@
+# 福建省肿瘤医院病历记录
+
+姓名：
+
+病区：
+
+床号:
+
+住院号：
+
+# 出院记录
+
+姓名：
+
+性别：女
+
+年龄：52岁
+
+婚姻：离婚
+
+职业：个体户
+
+入院日期：2019-09
+
+出院日期：2019-09
+
+共住院： 11 天
+
+入院诊断：1.左乳浸润性癌伴左腋窝左锁骨上淋巴结转移化疗后（cT4N3Mc0 Ⅲc期）；2.高胆固醇血症；3.PICC置管术后
+
+出院诊断：1.左乳浸润性癌伴左腋窝左锁骨上淋巴结转移化疗后（cT4N3M0 Ⅲc期）；2.高胆固醇血症；3.PICC置管术后
+
+住院经过：患者　　，女，52岁，汉族，离婚，以确诊"左乳癌"5个月，化疗后7天为主诉入院。患者于2019.4月中旬无意中发现左乳中央区可扪及一肿物，大小约8.0*7.0cm，质地硬，边界欠清，活动度尚可，表面欠光滑，无触痛，表面皮肤呈橘皮样，左乳头内陷。就诊我院，门诊行乳腺钼靶：左乳团块影并左腋窝淋巴结肿大，考虑恶性可能，建议穿刺活检　BI-RADS：4B类。彩超：1、左乳多发实性占位（倾向乳腺癌），BI-RADS 5类；2、左腋中、腋下组多发淋巴结肿大（倾向转移）。肺部CT：1、左乳占位、左乳皮肤增厚伴左侧腋窝淋巴结肿大，建议结合乳腺相关检查；3、左侧胸壁皮下小结节。彩超引导下行左乳肿物+左腋窝及左锁骨上淋巴结穿刺活检术，2019.4.10穿刺病理回报（19-07275）：（左乳房，穿刺）浸润性癌，（左腋窝淋巴结，穿刺）转移性癌。（左锁骨上淋巴结，穿刺）转移性癌。IHC：ER（+）（60%，中等-强），PR（+）（5%，弱-中等），HER2（1+），Ki-67（+，约20%），P63示肌上皮缺失。MRI：1、符合左乳腺癌累及皮肤伴左侧腋窝多发淋巴结肿大　BI-RADS：6类 2、右乳　BI-RADS：1类。ECT：考虑右肩关节良性病变可能。排除治疗禁忌症，于2019.4.30-8.20以"紫杉醇126m qw*14+表柔比星120mg*5"化疗，过程顺利，化疗间歇期给予粒细胞因子预防升白。2、4疗程后门诊查CT、MR提示疗效好转。入院查体：神志清楚，营养一般。左腋窝可扪及一肿大淋巴结，大小约0.5*0.5cm，质地硬，边界欠清，活动度尚可，表面欠光滑，无触痛。双锁骨上、右腋窝等处浅表淋巴结未触及肿大。双乳发育正常，左乳头内陷，无溢液。左乳中央区可扪及一肿物，大小约2.5*1.5cm，质地硬，边界欠清，活动度尚可，表面欠光滑，无触痛，表面皮肤呈橘皮
+
+第 1 页

track2_finixphoto_300/mds/19b3a90a-8cb6-40c6-b30e-40860f27c8b8.md

@@ -0,0 +1,58 @@
+# 中国人民解放军医疗住院收费票据
+
+票控盘号： 001010005002
+
+票控码：001010005002-08007330260337782454
+
+(2020)：201100673748
+
+业务流水号：87096819
+
+医疗机构类型： 综台医院
+
+病历号：07055179
+
+机打票号：201100673748
+
+住院时间： 2021年05月13日至 2021年05月26日
+
+住院天数： 13
+
+住院号 ：220194
+
+姓名： 林作岭
+
+性别：男
+
+社会保障号码：
+
+<table><tr><td>收费项目</td><td>金额</td><td>个人支付金额</td><td>收费项目</td><td></td><td>金额</td></tr><tr><td>西药费</td><td>9062.80</td><td>\</td><td>检查费</td><td>1743.00</td><td>\</td></tr><tr><td>手术费</td><td>60.00</td><td>\</td><td>化验费</td><td>1529.00</td><td>\</td></tr><tr><td>放射费</td><td>645.00</td><td>\</td><td>护理费</td><td>1329.82</td><td>\</td></tr><tr><td>诊察费</td><td>337.00</td><td>\</td><td>治疗费</td><td>5436.42</td><td>\</td></tr><tr><td>床位费</td><td>455.00</td><td>\</td><td>其他</td><td>2421.20</td><td>\</td></tr></table>
+
+合计(大写)： 贰万叁仟零壹拾玖元贰角肆分
+
+￥：23019.24
+
+预缴金额： 22000.00
+
+补缴金额：0
+
+退费金额： 12614.39
+
+医保统筹支付： 13633.63
+
+个人账户支付：0
+
+其他医保支付：0
+
+个人支付金额：9385.61
+
+第一联 收据联 盖章有效 遗失不补 手写无效
+二零二一年六月底前有效
+
+收款单位(盖章)：
+
+收款人(签章)：1261
+
+2021年5月26日
+
+医保住院号：YD002864836，医保单据号：YD004921560，医保个人帐户余额：0

track2_finixphoto_300/mds/19bccfb7-9af9-48f7-b0c6-a559afcf80d8.md

@@ -0,0 +1,73 @@
+# 河北省医疗住院收费票据
+
+医疗机构：廊坊市中医医院
+
+类型：
+
+科室：
+
+流水号：
+
+005208181
+
+住院号：
+
+住院时间：2020 年 06 月 30 日到 2020 年 07 月 16 日
+
+住院天数:16
+
+姓名：
+
+性别：男
+
+医保类型： 居民医保
+
+社会保障号码：
+
+<table><tr><td>收费项目</td><td>金额</td><td>支付类型</td><td>收费项目</td><td>金额</td><td>支付类型</td></tr><tr><td>床位费</td><td>720.00</td><td></td><td>护理费</td><td>288.00</td><td></td></tr><tr><td>检查费</td><td>3144.00</td><td></td><td>卫生材料费</td><td>51562.21</td><td></td></tr><tr><td>化验费</td><td>1952.70</td><td></td><td>药品费</td><td>13206.70</td><td></td></tr><tr><td>治疗费</td><td>1858.40</td><td></td><td>诊察费</td><td>320.00</td><td></td></tr><tr><td>手术费</td><td>5516.00</td><td></td><td>其他</td><td>12.00</td><td></td></tr><tr><td>输血费</td><td>500.00</td><td></td><td></td><td></td><td></td></tr></table>
+
+合计（大写）：柒万玖仟零捌拾元零壹分
+
+¥：79080.01
+
+预缴金额：80000.00
+
+补缴金额：0
+
+退费金额： 31143.15
+
+医院垫支：  30223.16
+
+医保统筹支付：25948.48
+
+个人账户支付： 0.00
+
+个人自付：  13724.31
+
+个人自费： 34822.54
+
+个人账户余额：80.00
+
+统筹累计支付：4623.71
+
+大病统筹4274.68
+
+贫困救助:0.00
+
+个人现金支付:48856.85
+
+起付标准:700.00
+
+纳入报销费用:43247.47
+
+符合医疗保险费用:43947.47
+
+结算前余额80.00
+
+第一联 收据联 盖章有效 遗失不补
+
+收款单位(章)：
+
+收款人：072019
+
+2020 年 07 月 23 日

track2_finixphoto_300/mds/1a8ba629-13ba-4b18-bcc7-4eeb2b0866f3.md

@@ -0,0 +1,47 @@
+莲湖区
+
+0003391295
+
+住院号：0871058
+
+NO.2100
+
+2100729077
+
+住院时间 2021年08月17日到2021年08月21日
+
+共计4天
+
+性别 女
+
+医保类型：市居民
+
+社会保障号码：
+
+<table><tr><td>收费项目</td><td>金额</td><td>个人支付金额</td><td></td><td></td><td></td></tr><tr><td>床位费</td><td>620</td><td></td><td>护理费</td><td>80</td><td></td></tr><tr><td>化验费</td><td>930</td><td></td><td>检查费</td><td>1555</td><td></td></tr><tr><td>其他</td><td></td><td></td><td>手术费</td><td></td><td></td></tr><tr><td>特殊材料</td><td></td><td></td><td>西药费</td><td>550177.2</td><td></td></tr><tr><td>血费</td><td></td><td></td><td>诊查费</td><td>120</td><td></td></tr><tr><td>治疗费</td><td>157</td><td></td><td>中草药</td><td></td><td></td></tr><tr><td>中成药</td><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+2021-08-24 09:54:59
+
+合计（大写）：伍拾伍万叁仟陆佰叁拾玖元贰角
+
+553639.2
+
+555000.00
+
+银行卡(建行)：
+
+医保统筹支付 570.25
+
+个人账户支付 0
+
+其他医保支付
+
+个人支付金额 553068.95
+
+第一联 收据联 盖章有效 遗失不补
+
+收款单位(章)
+
+收款人(签章) 陈建鹏
+
+2021年08月24日

track2_finixphoto_300/mds/1a9f3b5a-8234-430a-a723-ea082ecb77ee.md

@@ -0,0 +1,56 @@
+# 齐齐哈尔医学院附属第一医院
+
+# 出院记录
+
+姓名：
+
+性别：男
+
+科别:
+
+床号：
+
+病案号：
+
+姓名：
+
+性别：男
+
+年龄：47岁
+
+入院时间:2019-11
+
+出院时间; 2019-12
+
+住院天数：56天
+
+入院科别：
+
+出院科别：
+
+第1次住院
+
+门诊收治诊断：脑血栓形成
+
+临床初步诊断：脑血栓形成
+
+临床确定诊断：急性呼吸衰竭（中枢性），脑血栓形成，坠积性肺炎，心肌损害，泌尿系统感染
+入院时情况：患者，男，47岁，退（离）休人员。因“头痛、恶心吐，左侧肢体活动不灵2小时”于2019-11入院。该患于入院前2小时无明显诱因突然出现头痛，恶心呕吐，左侧肢体活动不灵症状，左上肢抬举差，左手抓握力弱，左下肢抬举尚可，但不能行走。在明珠医院行头CT检查未见明显异常，为求系统诊治在家属陪同下来我院急诊检查，急诊以“脑梗死”收入院。病程中无肢体抽搐，无视物旋转，无二便失禁，精神状态欠佳，饮食、睡眠一般。查体：体温：36.7℃，脉搏：72次／分，呼吸：20次／分，血压：140/90mmHg。发育正常，营养中等，推入病房，自主体位，查体合作，心肺腹检查未及明显异常。专科检查：意识清晰，言语流利，反应灵敏，计算力正常，定向力正常，近记忆正常，眼球各方向，活动良好，双侧瞳孔等大同圆，直径3.0mm，对光反射灵敏，无面舌瘫，左上肢肌力4级、下肢肌力4+级，右侧肢体肌力5级，四肢肌张力、腱反射正常，感觉系统未及异常，共济运动不能完成，双侧病理征阴性，颈强阴性，克氏征阴性。辅助检查：头MRI（2019.11.05）：双侧小脑急性期脑梗死。
+
+治疗经过：入院后明确诊断后给予介入取栓治疗，病人基底动脉供血区域脑组织缺血坏死，脑组织肿胀明显，给予脑室钻孔引流+后颅窝去骨瓣减压手术，病情稳定后返回病房继续脱水、降颅压、醒脑，控制并发症治疗。
+
+出院时情况：患者处于昏迷状态，痰减少，仍然比较粘稠，发热。年底医保资金结算，要求办理出院，重新办理住院，继续治疗。
+
+治疗效果（转归）： 好转
+
+出院医嘱：重新办理住院，继续治疗。
+
+主治医师签名：
+
+住院医师签名：
+
+注：医师签字前添加职称，右侧由经治医师签名，左侧由上级医师签名。
+
+医疗表格统一编号1-2
+
+第 页

track2_finixphoto_300/mds/1b6fdf72-97d5-4435-a9f3-1152d426aad0.md

@@ -0,0 +1,55 @@
+哈爾濱醫科大學附属第二医院
+
+The 2nd Affiliated Hospital of Harbin Medical University
+
+# 出院记录
+
+姓名：
+
+科室：
+
+病案号：
+
+姓名:
+
+性别：女
+
+年龄：36岁
+
+入院次数：1
+
+入院科别:
+
+出院科别：
+
+入院日期: 2019年12月
+
+出院日期：2019年12月
+
+住院天数：7天
+
+门诊诊断：子宫平滑肌瘤
+
+初步诊断：子宫平滑肌瘤
+
+确定诊断：子宫平滑肌瘤  盆腔粘连
+
+入院时情况：因“经期延长伴经量减少半年余。”入院。
+
+治疗经过：完善相关检查，于2019年12月11日行子宫肌瘤核除术+子宫整形术+盆腔粘连松解术+腹腔引流术+瘢痕剔除术，术后抗炎对症治疗。
+
+出院情况: 患者一般状态良好, 无发热, 无呕心呕吐, 生命体征平稳, 查体: T:36.8℃, P:76次/分, R:18次/分, Bp:122/78mmHg,一般情况可, 神清语明, 颈软, 心肺无著征, 腹平软, 无压痛, 肝脾肋下未触及,双下肢无浮肿, 神经系统未见异常, 病理反射未引出, 腹部切口愈合良好, 二便未见明显异常。
+
+治疗效果（转归）：治愈
+
+出院医嘱：1、加强营养，注意休息1个月；
+2、禁盆浴及性生活1个月；
+3、建议避孕至少1年；
+4、出院3周后电话咨询病理结果；
+5、定期复查，不适随诊。
+
+2
+
+第1页
+
+医疗表格统一编号 1-02

track2_finixphoto_300/mds/1f61fb07-32c0-4a57-a725-458ef0d0d3f9.md

@@ -0,0 +1,64 @@
+# 湖南省医疗住院收费票据
+
+№ 0130707478
+
+湘财
+通字
+
+(2016)
+
+013070747
+
+业务流水号： LJ030342
+
+医疗机构类型： 综合医院
+
+病历号：1261465
+
+住院号： 0004567727
+
+住院时间： 2016年12月27日到2017年01月10日
+
+住院天数：14
+
+25病区(肾内科)
+
+姓名： 卢微
+
+性别： 女
+
+医保类型： 宁乡县居民
+
+社会保障号码： 124350712002806
+
+<table><tr><td>收费项目</td><td>金额</td><td>个人支付金额</td><td>收费项目</td><td>金额</td><td>个人支付金额</td><td>收费项目</td><td>金额</td><td>个人支付金额</td></tr><tr><td>床位费</td><td>850.00</td><td></td><td>手术费</td><td>800.10</td><td></td><td>输血费</td><td>540.00</td><td></td></tr><tr><td>诊查费</td><td>390.00</td><td></td><td>护理费</td><td>469.00</td><td></td><td>其它</td><td>165.28</td><td></td></tr><tr><td>检查费</td><td>3282.00</td><td></td><td>材料费</td><td>6763.52</td><td></td><td></td><td></td><td></td></tr><tr><td>化验费</td><td>4396.50</td><td></td><td>西药费</td><td>7032.25</td><td></td><td></td><td></td><td></td></tr><tr><td>治疗费</td><td>11752.07</td><td></td><td>中成药费</td><td>640.55</td><td></td><td></td><td></td><td></td></tr></table>
+
+合计（大写）叁万柒仟零捌拾壹元贰角柒分
+
+￥ 37081.27
+
+预缴金额：85561.67
+
+补缴金额：
+
+退费金额：34000.00/29243.60
+
+医保统筹支付：14763.20
+
+个人账户支付：
+
+其他医保支付：
+
+个人支付金额：22318.07
+
+第一联 收据联 盖章有效 遗失不补
+
+本票据使用至2018年底，过期作废
+
+湘非税 1538号 湖南人民印务印
+
+收款单位(章)：
+
+收款人(签章)： 4995
+
+2017年1月12日

track2_finixphoto_300/mds/208198de-2044-50ca-8f1b-d3a7b588b352.md

@@ -0,0 +1,65 @@
+知乎@ZHDD
+
+# 广东省医疗收费票据
+# Medical Invoice of Guangdong Province
+
+LB1 
+
+业务流水号：
+Serial number
+
+社会保障号：
+Social security number
+
+病历号：
+ID
+
+住院(科室)：
+Ward
+
+眼耳鼻
+
+住院号：
+Hospitalization number
+
+医院类型：
+Hospital type
+
+19:11:16
+
+2021年01月24日
+Y M D 
+
+<table><tr><td>姓名<br/>Name</td><td colspan=2></td><td>口门诊□急诊□住院<br/>Ortpatient A＆E Inpaticnt</td><td>住院日期<br/>Date of hospitalization</td><td>2021-01-22</td><td>出院日期<br/>Date of departure</td><td>2021-01-24</td></tr><tr><td>性别<br/>Gender</td><td>□男□女<br/>Male Female</td><td>统筹/公医记帐<br/>Medical insurance/Public health service accounts</td><td></td><td>个人缴费<br/>Individual payment</td><td>3563.49</td><td>结算方式<br/>Method of payment</td><td>微信支付,银行卡</td></tr><tr><td>医药费<br/>Medicine fee</td><td>金额<br/>Amount</td><td>诊查费<br/>Physical examination</td><td>金额<br/>Amount</td><td>治疗费<br/>Treatment</td><td>金额<br/>Amount</td><td>其他<br/>Others</td><td>金额<br/>Amount</td></tr><tr><td>西药费：</td><td>529.19</td><td>检查费：</td><td>1469.50</td><td>治疗费：</td><td>119.00</td><td>床位费：</td><td>50.00</td></tr><tr><td rowspan="2">中成药：</td><td rowspan="2"></td><td rowspan="2">诊查费：</td><td rowspan="2">36.00</td><td>输氧费：</td><td></td><td>护理费</td><td>26.00</td></tr><tr><td>输血费：</td><td></td><td>特殊服务费：</td><td></td></tr><tr><td>中草药：</td><td>237.50</td><td>检验费：</td><td>1090.30</td><td>手术费：</td><td>6.00</td><td>其他费：</td><td>0.00</td></tr><tr><td>预交款<br/>Pre-charge</td><td>3563.49</td><td>补收<br/>Re-charge</td><td></td><td>退款<br/>Refund</td><td></td><td>欠费<br/>Overdue</td><td></td></tr><tr><td colspan="2">合计人民币(大写)<br/>TOTAL (RMB,In words)</td><td colspan="4">零拾零万叁仟伍佰陆拾叁元肆角玖分</td><td colspan="2">￥：3563.49</td></tr></table>
+
+备注 
+
+1.医药费包括：西药、中成药及中草药等
+2.诊查费包括：检查 、化验及体检等医技项目
+3、治疗费包括：正畸、镶牙、输血、输氧、放疗、化疗、手术及材料等 
+4、其他包括：床位、护理、药事服务、医学签证、法医鉴定等费用
+
+个人自付包括： 
+
+个人现金：3563.40
+
+个人账户：0.00 
+
+医疗救助：0.00 
+
+第三联 存 根
+Countertfoil
+
+收费单位(盖章):吴川市人民医院
+Payee(seal)
+
+复核：
+Assessor
+
+收款人：5312
+Cashier
+
+广东省财政厅印制
+Printed by Guangdong Provincial Finance Bureau
+
+（手写无效，限2021年12月31日前使用）

track2_finixphoto_300/mds/2090cf59-a30e-47b0-81a9-489e8e6a6063.md

@@ -0,0 +1,47 @@
+# 河北省沧州中西医结合医院
+
+# 出院记录
+
+姓名：
+
+性别:男
+
+年龄：33 岁
+
+科别：
+
+床号：
+
+病案号：
+
+入院时间：2019-10-
+
+出院时间：2019-11-
+
+入院情况:患者            男，33岁。主因腰部疼痛2个月余，加重5天于2019-10-30 10:06入院。查体：T:36.7℃ P:67次/分 R呼吸:17次/分 BP血压:126/80mmHg 腰部生理曲度存在，未见明显侧弯畸形，腰4-5正中压痛明显，叩击痛阳性，无明显双下肢放射，双下肢未见明显肿胀，未见肌肉萎缩，双下肢各区针刺觉未见明显减退，双下肢直腿抬高试验：右侧70°（-），加强试验（+），左侧70°（+），双下肢各肌肌力、肌张力正常。
+
+入院诊断：
+
+中医：腰痛病【气滞血瘀证】
+
+西医：1、腰椎滑脱 L4椎体2、腰椎峡部裂 L4椎体 3、腰椎间盘膨出 L4-5
+
+诊疗经过：患者入院后完善术前相关检查，于2019-11-01在全麻下行腰椎(L4-5)后路椎弓根内固定+腰4峡部及椎板间植骨术，手术顺利，术后病人安返病房，给予抗炎等治疗，病情平稳，今日出院。
+
+出院诊断
+
+中医：腰痛病【气滞血瘀证】
+
+西医：1、腰椎滑脱 L4椎体2、腰椎峡部裂 L4椎体 3、腰椎间盘膨出 L4-5
+
+出院情况：患者病情平稳，未诉不适，体温不高，查体：生命体征平稳，心肺未见明显异常，腰部伤口敷料包扎良好，无明显渗出，伤口无红肿，双下肢肌力、肌张力正常。
+
+出院医嘱：1、伤口定期换药，保持伤口清洁。2、继续多卧床静养，佩戴腰围保护。3、一个月后门诊复查，以后每四周周二上午门诊复查。4、不适随诊。
+
+主治医师签字：
+
+住院医师签字：
+
+（一式两份，一份交患者或监护人、被授权人收执、一份入病案）
+
+第1页

track2_finixphoto_300/mds/20a85e8b-2f46-595f-b3e7-01d34f606fac.md

@@ -0,0 +1,65 @@
+# 北京增值税普通发票
+
+# 发票联
+
+011001900104
+
+№ 07694593
+
+011001900104
+
+07694593 
+
+校验码 49117 30532 23680 31871
+
+开票日期：2020年06月24日
+
+购 买 方 
+
+名 称： 中国农业发展银行伊犁哈萨克自治州分行 
+
+纳税人识别号： 916540009304796015 
+
+地址、 电话： 伊宁市解放西路399号0999-8129032 
+
+开户行及账号： 中国农业发展银行伊犁哈萨克自治州分行营业部2036540990010000005537 
+
+密 码 区 
+
+2/75-03<1-702<15*6<92<-4>3- 3>1007341825860>+190+/14624 /1+439/-/1*2>/7/2<11*6<96<+ 5<->+/300-+41921>02>+5863<0 
+
+<table>
+<tr><td>货物或应税劳务、服务名称</td><td>规格型号</td><td>单位</td><td>数量</td><td>单价</td><td>金额</td><td>税率</td><td>税额</td></tr>
+<tr><td>*印刷品*银行业消防安全管理</td><td>169mm*239mm</td><td>册</td><td>1</td><td>55.87</td><td>55.87</td><td>9%</td><td>5.03</td></tr>
+<tr><td>合计</td><td></td><td></td><td></td><td></td><td>?55.87</td><td></td><td>?5.03</td></tr>
+</table>
+
+价税合计(大写) 
+
+?陆拾圆玖角整
+
+（小写）￥60.90 
+
+销 售 方 
+
+名 称： 中国金融出版社有限公司 
+
+纳税人识别号： 91110000400005169P 
+
+地址、电话： 北京市丰台区丰台北路12号 63267697 
+
+开户行及账号： 中国光大银行北京长安支行083518120100304006660 
+
+备 注 
+
+税总函〔2018〕670号 北京东港安全印刷有限公司
+
+第二联：发票联 购买方记账凭证
+
+收款人：田宇
+
+复核：王维
+
+开票人：杨峥
+
+销售方：（章）

track2_finixphoto_300/mds/213b444f-95ca-41a3-92df-2bd8a0374f83.md

@@ -0,0 +1,77 @@
+# 深圳增值税专用发票
+
+# 发票联
+
+4403162130
+
+№ 46021580
+
+4403162130
+
+46021580
+
+销项负数
+
+开票日期： 2017年06月01日
+
+购买方
+
+名称：
+
+深圳市中兴新地技术股份有限公司
+
+纳税人识别号：
+
+91440301750499138T
+
+地址、电话：
+
+深圳市龙岗区坂田街道岗头社区新地路1号A厂房、B厂房、C厂房 28801996
+
+开户行及账号：
+
+中国民生银行深圳高新区支行1820014210000923
+
+密码区
+
+1>/<>66>941393211603362203->12/*841>6+>>/5>+41+34286>/ +*11>369808*671<9321141>3322233630/8*31<7+-6*7>609*+>5
+
+<table><tr><td>货物或应税劳务、服务名称</td><td>规格型号</td><td>单位</td><td>数量</td><td>单价</td><td>金额</td><td>税率</td><td>税额</td></tr><tr><td>光纤尾胶</td><td>20g/支</td><td>g</td><td>-2000</td><td>2.0512820513</td><td>-4102.56</td><td>17%</td><td>-697.44</td></tr><tr><td>合 计</td><td></td><td></td><td></td><td></td><td></td><td>￥-4102.56</td><td>￥-697.44</td></tr></table>
+
+价税合计(大写)
+
+⊗(负数)肆仟捌佰圆整
+
+(小写) ￥-4800.00
+
+销售方
+
+名称：
+
+深圳市浩力新材料技术有限公司
+
+纳税人识别号：
+
+91440300080750089U
+
+地址、电话：
+
+深圳市龙岗区龙城街道龙西社区五联路21号宝康工业园C栋5楼 0755-28992254
+
+开户行及账号：
+
+深圳农村商业银行龙西支行000157523896
+
+备注
+
+税总函〔2016〕117号中钞光华印制有限公司
+
+第三联：发票联 购买方记账凭证
+
+收款人：刘晓玲
+
+复核：隆妹萍
+
+开票人： 魏伟琴
+
+销售方：（章）

track2_finixphoto_300/mds/23c733e1-ca08-41a9-a080-cb680f396da9.md

@@ -0,0 +1,41 @@
+# 郑州大学洛阳中心医院 洛阳市中心医院
+
+# 出院记录
+
+姓名：
+
+性别：女
+
+年龄：54 岁
+
+住院号：
+
+科室：
+
+床号：
+
+入院日期：2019-12
+
+出院日期：2019-12
+
+住院天数：6
+
+入院诊断：宫颈鳞癌 Ⅲb 期术后第 2 次化疗后
+
+入院情况及诊疗经过：患者以“宫颈鳞癌ⅢB期术后第2次化疗后3周”为主诉入院，完善检查，无明显化疗禁忌症，于2019年12月22日给予多西他赛针+洛铂针方案静脉化疗，化疗过程顺利，出现恶心、呕吐、骨髓抑制等反应，给予补液、补钾、升白对症治疗后好转。
+
+出院诊断：1.宫颈鳞癌ⅢB期术后第3次化疗后；2.化疗后骨髓抑制
+
+出院情况：患者病情稳定，一般情况可，诉无恶心、呕吐，无腹痛、无腹泻，口腔无溃疡。查体：生命体征平稳，神志清楚，精神可，睡眠可，饮食可，大小便无异常，口腔黏膜完整，心肺听诊无明显异常，腹平软，无压痛、无反跳痛，肝脾未触及肿大，肠鸣音正常，双下肢无压痛。今日复查血常规无明显异常，请示上级医师后准予出院。
+
+出院医嘱：
+
+1、复诊时间：3周后返院治疗。
+
+复诊次数：多次
+
+2、出院带药用法用量：无
+
+3、出院注意事项: 1.合理膳食, 健康生活方式宣教, 注意休息, 少量多餐, 加强营养。2.每3日定期复查血常规, 如白细胞<3.0×10⁹/l 或血小板<30×10⁹/l返院治疗。3.1月12日返院继续治疗, 返院前1-2日电话联系管床医生。4.若恶心、呕吐、发热等不适随诊。
+
+医师签名：

track2_finixphoto_300/mds/24605939-36d9-49ba-89f5-111934063fb1.md

@@ -0,0 +1,34 @@
+0401
+
+# 重庆市
+# 门诊医药费专用收据
+
+0559817
+
+<table>
+<tr>
+  <td style="text-align:center;">项目</td>
+  <td style="text-align:center;">金额（元）</td></tr>
+<tr>
+  <td>2020-05-16</td>
+<td>发票号:0559817</td></tr>
+<tr>
+  <td>会诊费</td>
+  <td>5.00</td></tr>
+</table>
+
+急诊医学
+
+第一联 收据
+
+合计小写：
+
+合计大写：5.00
+
+备注：伍圆整
+
+合计：5.00，自助：5.00
+
+收款单位（盖章）：
+
+收款人：龙邱渝

track2_finixphoto_300/mds/27c01a18-e2eb-4735-852d-c367d44fdc82.md

@@ -0,0 +1,61 @@
+# 吉林增值税普通发票
+
+# 发票联
+
+2200162320
+
+№ 18352069
+
+2200162320
+
+18352069
+
+开票日期:2019年3月24日
+
+校验码 37278 91098 57448 84153
+
+购买方
+
+名 称：胡亚茜
+
+纳税人识别号：
+
+地址、电话：
+
+开户行及账号：
+
+密码区
+
+>>21/<40120<<6072--71-*7*0*-2-209-9582-8/1/7/3219/0/+1*--043+>/*>+7479<508+2-*8<58/8511282+1019*3-2808-18950
+
+<table><tr><td>货物或应税劳务、服务名称</td><td>规格型号</td><td>单位</td><td>数量</td><td>单价</td><td>金额</td><td>税率</td><td>税额</td></tr><tr><td>苹果数据线</td><td></td><td>条</td><td>200</td><td>36.893204</td><td>7378.64</td><td>3%</td><td>221.36</td></tr><tr><td>苹果充电器</td><td></td><td>个</td><td>150</td><td>43.689320</td><td>6553.40</td><td>3%</td><td>196.60</td></tr><tr><td>苹果国行耳机</td><td></td><td>条</td><td>150</td><td>58.252427</td><td>8737.86</td><td>3%</td><td>262.14</td></tr><tr><td>苹果港版耳机</td><td></td><td>条</td><td>150</td><td>58.252427</td><td>8737.86</td><td>3%</td><td>262.14</td></tr><tr><td>苹果PD充电器+数据线</td><td></td><td>条</td><td>100</td><td>87.378641</td><td>8737.86</td><td>3%</td><td>262.14</td></tr><tr><td>合计</td><td></td><td></td><td></td><td></td><td>¥ 40145.62</td><td></td><td>¥ 1204.38</td></tr></table>
+
+价税合计(大写）
+
+⊗肆万壹仟叁佰伍拾圆整
+
+（小写）￥41350.00
+
+销 售 方
+
+名 称：吉林省巴黎春天百货有限公司
+
+纳税人识别号： 220104795211855
+
+地址、电 话： 长春市朝阳区工农大路1055号
+
+开户行及账号：中国银行(长春支行)220485003747
+
+备 注
+
+税总函〔2016〕116号山东承安发票印刷有限公司
+
+第二联：发票联 购买方记账凭证
+
+收款人：刘思琴
+
+复核：肖镇国
+
+开票人：金伟光
+
+销售方：（章）