MMTU-benchmark/MMTU huggingface dataset:
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                             | authors                                                     | venue         |   year |
|:--------------------------------------------------|:------------------------------------------------------------|:--------------|-------:|
| implementation aspects of an object-oriented dbms | ilker durusoy , cetin ozkan , mehmet altinel , asuman dogac | sigmod record |   1995 |

Entity B:
| title                                                           | authors       | venue                                          |   year |
|:----------------------------------------------------------------|:--------------|:-----------------------------------------------|-------:|
| static detection of security flaws in object-oriented databases | keishi tajima | international conference on management of data |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1016
rtable_id: 1983
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                                  | authors                      | venue         |   year |
|:-----------------------------------------------------------------------|:-----------------------------|:--------------|-------:|
| unisql 's next-generation object-relational database management system | phil janus , albert d'andrea | sigmod record |   1996 |

Entity B:
| title                                                       | authors          | venue                                                                  |   year |
|:------------------------------------------------------------|:-----------------|:-----------------------------------------------------------------------|-------:|
| enhanced abstract data types in object-relational databases | praveen seshadri | the vldb journal -- the international journal on very large data bases |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 9
rtable_id: 1179
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                               | authors   | venue                       |   year |
|:----------------------------------------------------|:----------|:----------------------------|-------:|
| distributed query evaluation on semistructured data | dan suciu | acm trans . database syst . |   2002 |

Entity B:
| title                                               | authors   | venue                                         |   year |
|:----------------------------------------------------|:----------|:----------------------------------------------|-------:|
| distributed query evaluation on semistructured data | dan suciu | acm transactions on database systems ( tods ) |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1480
rtable_id: 340
label: 1
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                   | authors       | venue             |   year |
|:--------------------------------------------------------|:--------------|:------------------|-------:|
| data management issues in electronic commerce ( panel ) | m. tamer özsu | sigmod conference |   1999 |

Entity B:
| title                                         | authors             | venue                                          |   year |
|:----------------------------------------------|:--------------------|:-----------------------------------------------|-------:|
| data management issues in electronic commerce | m. tamer &#214; zsu | international conference on management of data |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1180
rtable_id: 56
label: 1
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                              | authors                          | venue   |   year |
|:---------------------------------------------------|:---------------------------------|:--------|-------:|
| secure bufering in firm real-time database systems | jayant r. haritsa , binto george | vldb j. |   2000 |

Entity B:
| title                                                        | authors                                                         | venue                 |   year |
|:-------------------------------------------------------------|:----------------------------------------------------------------|:----------------------|-------:|
| index concurrency control in firm real-time database systems | brajesh goyal , jayant r. haritsa , s. seshadri , v. srinivasan | very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2151
rtable_id: 1459
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                                                    | authors                                                                                | venue   |   year |
|:-----------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------|:--------|-------:|
| efficient approximation of optimization queries under parametric aggregation constraints | dimitrios gunopulos , nick koudas , divesh srivastava , michail vlachos , sudipto guha | vldb    |   2003 |

Entity B:
| title                                                                                 | authors                                          | venue                                          |   year |
|:--------------------------------------------------------------------------------------|:-------------------------------------------------|:-----------------------------------------------|-------:|
| a robust , optimization-based approach for approximate answering of aggregate queries | surajit chaudhuri , gautam das , vivek narasayya | international conference on management of data |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 228
rtable_id: 306
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                           | authors                                | venue   |   year |
|:------------------------------------------------|:---------------------------------------|:--------|-------:|
| indexing of now-relative spatio-bitemporal data | simonas saltenis , christian s. jensen | vldb j. |   2002 |

Entity B:
| title                                                                     | authors                                                                   | venue                                                                  |   year |
|:--------------------------------------------------------------------------|:--------------------------------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| spatial indexing of high-dimensional data based on relative approximation | yasushi sakurai , masatoshi yoshikawa , shunsuke uemura , haruhiko kojima | the vldb journal -- the international journal on very large data bases |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 37
rtable_id: 1185
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                                         | authors                          | venue   |   year |
|:------------------------------------------------------------------------------|:---------------------------------|:--------|-------:|
| accessing a relational database through an object-oriented database interface | jack a. orenstein , d. n. kamber | vldb    |   1995 |

Entity B:
| title                                                          | authors                                              | venue                 |   year |
|:---------------------------------------------------------------|:-----------------------------------------------------|:----------------------|-------:|
| odefs : a file system interface to an object-oriented database | narain h. gehani , h. v. jagadish , william d. roome | very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1304
rtable_id: 2243
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                               | authors                                  | venue   |   year |
|:--------------------------------------------------------------------|:-----------------------------------------|:--------|-------:|
| nd-sql : a multi-dimensional language for interoperability and olap | laks v. s. lakshmanan , frédéric gingras | vldb    |   1998 |

Entity B:
| title                                                               | authors                                                | venue                 |   year |
|:--------------------------------------------------------------------|:-------------------------------------------------------|:----------------------|-------:|
| nd-sql : a multi-dimensional language for interoperability and olap | fr &#233; d &#233; ric gingras , laks v. s. lakshmanan | very large data bases |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2156
rtable_id: 961
label: 1
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                    | authors           | venue         |   year |
|:-------------------------|:------------------|:--------------|-------:|
| progress on hpcc and nii | marianne winslett | sigmod record |   1994 |

Entity B:
| title                    | authors           | venue             |   year |
|:-------------------------|:------------------|:------------------|-------:|
| progress on hpcc and nii | marianne winslett | acm sigmod record |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 722
rtable_id: 1710
label: 1
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title     | authors              | venue                       |   year |
|:----------|:---------------------|:----------------------------|-------:|
| editorial | richard t. snodgrass | acm trans . database syst . |   2001 |

Entity B:
| title           | authors                                    | venue                                                                  |   year |
|:----------------|:-------------------------------------------|:-----------------------------------------------------------------------|-------:|
| guest editorial | vijay atluri , anupam joshi , yelena yesha | the vldb journal -- the international journal on very large data bases |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2371
rtable_id: 2184
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                               | authors                                              | venue   |   year |
|:----------------------------------------------------|:-----------------------------------------------------|:--------|-------:|
| answering xml queries on heterogeneous data sources | ioana manolescu , donald kossmann , daniela florescu | vldb    |   2001 |

Entity B:
| title                                             | authors                             | venue                 |   year |
|:--------------------------------------------------|:------------------------------------|:----------------------|-------:|
| merging ranks from heterogeneous internet sources | luis gravano , hector garcia-molina | very large data bases |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1228
rtable_id: 943
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                                     | authors                   | venue             |   year |
|:--------------------------------------------------------------------------|:--------------------------|:------------------|-------:|
| an online video placement policy based on bandwith to space ratio ( bsr ) | dinkar sitaram , asit dan | sigmod conference |   1995 |

Entity B:
| title                                                                      | authors                   | venue                                          |   year |
|:---------------------------------------------------------------------------|:--------------------------|:-----------------------------------------------|-------:|
| an online video placement policy based on bandwidth to space ratio ( bsr ) | asit dan , dinkar sitaram | international conference on management of data |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1898
rtable_id: 1503
label: 1
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                 | authors                                                                                                                   | venue   |   year |
|:------------------------------------------------------|:--------------------------------------------------------------------------------------------------------------------------|:--------|-------:|
| sideway value algebra for object-relational databases | z. meral özsoyoglu , gultekin özsoyoglu , abdullah al-hamdani , özgür ulusoy , selma ayse özel , ismail sengör altingövde | vldb    |   2002 |

Entity B:
| title                                                        | authors                          | venue                 |   year |
|:-------------------------------------------------------------|:---------------------------------|:----------------------|-------:|
| storage and retrieval of xml data using relational databases | surajit chaudhuri , kyuseok shim | very large data bases |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 476
rtable_id: 1413
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                          | authors                                        | venue             |   year |
|:-----------------------------------------------|:-----------------------------------------------|:------------------|-------:|
| a system for watermarking relational databases | peter j. haas , rakesh agrawal , jerry kiernan | sigmod conference |   2003 |

Entity B:
| title                                                         | authors                                                | venue                 |   year |
|:--------------------------------------------------------------|:-------------------------------------------------------|:----------------------|-------:|
| managing intervals efficiently in object-relational databases | hans-peter kriegel , marco p &#246; tke , thomas seidl | very large data bases |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1400
rtable_id: 894
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                    | authors          | venue             |   year |
|:-----------------------------------------|:-----------------|:------------------|-------:|
| parallel database systems in the 1990 's | michael j. carey | sigmod conference |   1994 |

Entity B:
| title                                                            | authors                                             | venue                 |   year |
|:-----------------------------------------------------------------|:----------------------------------------------------|:----------------------|-------:|
| dynamic load balancing in hierarchical parallel database systems | luc bouganim , daniela florescu , patrick valduriez | very large data bases |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1689
rtable_id: 1100
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                           | authors                                               | venue             |   year |
|:------------------------------------------------|:------------------------------------------------------|:------------------|-------:|
| using the calanda time series management system | werner dreyer , angelika kotz dittrich , duri schmidt | sigmod conference |   1995 |

Entity B:
| title                                               | authors     | venue             |   year |
|:----------------------------------------------------|:------------|:------------------|-------:|
| the mariposa distributed database management system | jeff sidell | acm sigmod record |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1870
rtable_id: 1898
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                               | authors                                                                                    | venue         |   year |
|:------------------------------------|:-------------------------------------------------------------------------------------------|:--------------|-------:|
| reminiscences on influential papers | per-åke larson , luis gravano , stefano ceri , leonid libkin , tova milo , kenneth a. ross | sigmod record |   2001 |

Entity B:
| title              | authors   | venue             |   year |
|:-------------------|:----------|:------------------|-------:|
| influential papers | ken ross  | acm sigmod record |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 304
rtable_id: 546
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                            | authors                                                                    | venue   |   year |
|:-------------------------------------------------|:---------------------------------------------------------------------------|:--------|-------:|
| optimizing the secure evaluation of twig queries | sihem amer-yahia , divesh srivastava , sungran cho , laks v. s. lakshmanan | vldb    |   2002 |

Entity B:
| title                              | authors                          | venue                 |   year |
|:-----------------------------------|:---------------------------------|:----------------------|-------:|
| evaluating top-k selection queries | surajit chaudhuri , luis gravano | very large data bases |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1531
rtable_id: 793
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                      | authors                            | venue             |   year |
|:-----------------------------------------------------------|:-----------------------------------|:------------------|-------:|
| distance-based indexing for high-dimensional metric spaces | z. meral özsoyoglu , tolga bozkaya | sigmod conference |   1997 |

Entity B:
| title                                                             | authors               | venue                                         |   year |
|:------------------------------------------------------------------|:----------------------|:----------------------------------------------|-------:|
| a cost model for query processing in high dimensional data spaces | christian b &#246; hm | acm transactions on database systems ( tods ) |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 661
rtable_id: 510
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                           | authors   | venue             |   year |
|:----------------------------------------------------------------|:----------|:------------------|-------:|
| unisql/x unified relational and object-oriented database system | won kim   | sigmod conference |   1994 |

Entity B:
| title                                                          | authors                                              | venue                 |   year |
|:---------------------------------------------------------------|:-----------------------------------------------------|:----------------------|-------:|
| odefs : a file system interface to an object-oriented database | narain h. gehani , h. v. jagadish , william d. roome | very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2497
rtable_id: 2243
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                | authors                                            | venue   |   year |
|:-----------------------------------------------------|:---------------------------------------------------|:--------|-------:|
| optimizing multi-feature queries for image databases | ulrich güntzer , werner kießling , wolf-tilo balke | vldb    |   2000 |

Entity B:
| title                                                        | authors                                   | venue                 |   year |
|:-------------------------------------------------------------|:------------------------------------------|:----------------------|-------:|
| querying multiple features of groups in relational databases | damianos chatziantoniou , kenneth a. ross | very large data bases |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1034
rtable_id: 1046
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                 | authors                             | venue         |   year |
|:------------------------------------------------------|:------------------------------------|:--------------|-------:|
| constructing the next 100 database management systems | andreas geppert , klaus r. dittrich | sigmod record |   1994 |

Entity B:
| title                                                       | authors                                                                      | venue             |   year |
|:------------------------------------------------------------|:-----------------------------------------------------------------------------|:------------------|-------:|
| lore : a database management system for semistructured data | jason mchugh , serge abiteboul , roy goldman , dallas quass , jennifer widom | acm sigmod record |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 289
rtable_id: 1758
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                                            | authors                                                       | venue   |   year |
|:---------------------------------------------------------------------------------|:--------------------------------------------------------------|:--------|-------:|
| schemasql - a language for interoperability in relational multi-database systems | fereidoon sadri , laks v. s. lakshmanan , iyer n. subramanian | vldb    |   1996 |

Entity B:
| title                                         | authors                                                                                                             | venue                                          |   year |
|:----------------------------------------------|:--------------------------------------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| languages for multi-database interoperability | fr &#233; d &#233; ric gingras , laks v. s. lakshmanan , iyer n. subramanian , despina papoulis , nematollaah shiri | international conference on management of data |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 766
rtable_id: 1847
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                       | authors                                                                    | venue   |   year |
|:--------------------------------------------|:---------------------------------------------------------------------------|:--------|-------:|
| approximate query processing using wavelets | kyuseok shim , kaushik chakrabarti , minos n. garofalakis , rajeev rastogi | vldb    |   2000 |

Entity B:
| title                                                                   | authors                                                                          | venue                 |   year |
|:------------------------------------------------------------------------|:---------------------------------------------------------------------------------|:----------------------|-------:|
| improving adaptable similarity query processing by using approximations | mihael ankerst , bernhard braunm &#252; ller , hans-peter kriegel , thomas seidl | very large data bases |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2308
rtable_id: 1023
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                                 | authors                        | venue         |   year |
|:----------------------------------------------------------------------|:-------------------------------|:--------------|-------:|
| quasi-cubes : exploiting approximations in multidimensional databases | daniel barbará , mark sullivan | sigmod record |   1997 |

Entity B:
| title                                                        | authors                                   | venue                 |   year |
|:-------------------------------------------------------------|:------------------------------------------|:----------------------|-------:|
| querying multiple features of groups in relational databases | damianos chatziantoniou , kenneth a. ross | very large data bases |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 371
rtable_id: 1046
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title           | authors        | venue         |   year |
|:----------------|:---------------|:--------------|-------:|
| editor 's notes | jennifer widom | sigmod record |   1996 |

Entity B:
| title     | authors           | venue                                         |   year |
|:----------|:------------------|:----------------------------------------------|-------:|
| editorial | richard snodgrass | acm transactions on database systems ( tods ) |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1732
rtable_id: 342
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                             | authors                                                | venue   |   year |
|:--------------------------------------------------|:-------------------------------------------------------|:--------|-------:|
| database de-centralization - a practical approach | césar a. galindo-legaria , eirik dahle , tor didriksen | vldb    |   1995 |

Entity B:
| title                                                                      | authors                         | venue                 |   year |
|:---------------------------------------------------------------------------|:--------------------------------|:----------------------|-------:|
| selectivity estimation in extensible databases - a neural network approach | m. seetha lakshmi , shaoyu zhou | very large data bases |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2375
rtable_id: 1021
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                       | authors                                                         | venue             |   year |
|:------------------------------------------------------------|:----------------------------------------------------------------|:------------------|-------:|
| maintenance of data cubes and summary tables in a warehouse | inderpal singh mumick , dallan quass , barinderpal singh mumick | sigmod conference |   1997 |

Entity B:
| title                                                           | authors                                                                                                               | venue                                          |   year |
|:----------------------------------------------------------------|:----------------------------------------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| the whips prototype for data warehouse creation and maintenance | wilburt j. labio , yue zhuge , janet l. wiener , himanshu gupta , h &#233; ctor garc &#237; a-molina , jennifer widom | international conference on management of data |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1318
rtable_id: 1864
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                   | authors      | venue         |   year |
|:--------------------------------------------------------|:-------------|:--------------|-------:|
| an annotated bibliography on real-time database systems | özgür ulusoy | sigmod record |   1995 |

Entity B:
| title                                                     | authors                                             | venue             |   year |
|:----------------------------------------------------------|:----------------------------------------------------|:------------------|-------:|
| improving timeliness in real-time secure database systems | sang h. son , rasikan david , bhavani thuraisingham | acm sigmod record |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1119
rtable_id: 378
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                | authors                                                                   | venue   |   year |
|:-----------------------------------------------------|:--------------------------------------------------------------------------|:--------|-------:|
| alphasort : a cache-sensitive parallel external sort | jim gray , zarka cvetanovic , tom barclay , chris nyberg , david b. lomet | vldb j. |   1995 |

Entity B:
| title                                                | authors                                                               | venue                                                                  |   year |
|:-----------------------------------------------------|:----------------------------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| alphasort : a cache-sensitive parallel external sort | chris nyberg , tom barclay , zarka cvetanovic , jim gray , dave lomet | the vldb journal -- the international journal on very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1057
rtable_id: 613
label: 1
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                                | authors                                                    | venue         |   year |
|:---------------------------------------------------------------------|:-----------------------------------------------------------|:--------------|-------:|
| report on the 4th international conference on mobile data management | panos k. chrysanthis , arkady b. zaslavsky , morris sloman | sigmod record |   2003 |

Entity B:
| title                                                                                       | authors        | venue             |   year |
|:--------------------------------------------------------------------------------------------|:---------------|:------------------|-------:|
| report on the acm fourth international workshop on data warehousing and olap ( dolap 2001 ) | joachim hammer | acm sigmod record |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 734
rtable_id: 742
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                          | authors                                                      | venue             |   year |
|:-----------------------------------------------|:-------------------------------------------------------------|:------------------|-------:|
| infomaster : an information integration system | arthur m. keller , michael r. genesereth , oliver m. duschka | sigmod conference |   1997 |

Entity B:
| title                                                     | authors                                                                                                                                       | venue                 |   year |
|:----------------------------------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------|:----------------------|-------:|
| information integration : the momis project demonstration | domenico beneventano , sonia bergamaschi , silvana castano , alberto corni , r. guidetti , g. malvezzi , michele melchiori , maurizio vincini | very large data bases |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2546
rtable_id: 1393
label: 0