MMTU-benchmark/MMTU huggingface dataset:
Task: Entity-Matching (source dataset: Amazon-Google)

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                        | manufacturer   |   price |
|:-----------------------------|:---------------|--------:|
| quickbooks simple start 2007 | intuit         |   99.95 |

Entity B:
| title                                              | manufacturer   |   price |
|:---------------------------------------------------|:---------------|--------:|
| quickbooks ( r ) premier : accountant edition 2007 |                |  399.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 528
rtable_id: 3087
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                                               | manufacturer   |   price |
|:----------------------------------------------------|:---------------|--------:|
| adobe creative suite cs3 production premium upgrade | adobe          |     799 |

Entity B:
| title                 | manufacturer   |   price |
|:----------------------|:---------------|--------:|
| adobe cs3 web premium |                | 1659.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 736
rtable_id: 324
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                      | manufacturer   |   price |
|:---------------------------|:---------------|--------:|
| high school advantage 2008 | encore         |   39.99 |

Entity B:
| title                            | manufacturer   |   price |
|:---------------------------------|:---------------|--------:|
| elementary advantage 2008 encore |                |   39.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1053
rtable_id: 2835
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                            | manufacturer   |   price |
|:---------------------------------|:---------------|--------:|
| microsoft mappoint 2006 with gps | microsoft      |     349 |

Entity B:
| title                                                  | manufacturer   |   price |
|:-------------------------------------------------------|:---------------|--------:|
| microsoft ( r ) windows ( r ) xp home edition with sp2 |                |  199.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 574
rtable_id: 1132
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                                            | manufacturer   |   price |
|:-------------------------------------------------|:---------------|--------:|
| microsoft windows vista ultimate upgrade [ dvd ] | microsoft      |  259.95 |

Entity B:
| title                                               | manufacturer   |   price |
|:----------------------------------------------------|:---------------|--------:|
| microsoft office visio standard 2007 upgrade ( pc ) |                |  129.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 514
rtable_id: 3027
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                           | manufacturer   |   price |
|:--------------------------------|:---------------|--------:|
| adobe after effects cs3 upgrade | adobe          |     299 |

Entity B:
| title                   | manufacturer   |   price |
|:------------------------|:---------------|--------:|
| adobe cs3 after effects |                | 1025.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 592
rtable_id: 355
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                                                                    | manufacturer       |   price |
|:-------------------------------------------------------------------------|:-------------------|--------:|
| microsoft crm professional cal 3.0 product upgrade license pack user cal | microsoft software |    9980 |

Entity B:
| title                                                                                  | manufacturer   |   price |
|:---------------------------------------------------------------------------------------|:---------------|--------:|
| t74-00004 microsoft windows small business server 2003 license 20 additional user cals |                |  1834.4 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 135
rtable_id: 36
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                                            | manufacturer         |   price |
|:-------------------------------------------------|:---------------------|--------:|
| microsoft office & windows training professional | topics entertainment |   49.95 |

Entity B:
| title                                       | manufacturer   |   price |
|:--------------------------------------------|:---------------|--------:|
| microsoft office visio standard 2007 ( pc ) |                |  249.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 753
rtable_id: 2847
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                           | manufacturer   |   price |
|:--------------------------------|:---------------|--------:|
| adobe after effects cs3 upgrade | adobe          |     299 |

Entity B:
| title                                               | manufacturer   |   price |
|:----------------------------------------------------|:---------------|--------:|
| adobe illustrator cs3 upgrade from freehand for mac |                |  206.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 592
rtable_id: 485
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                                          | manufacturer   |   price |
|:-----------------------------------------------|:---------------|--------:|
| microsoft productivity pack for windows mobile | microsoft      |   29.99 |

Entity B:
| title                                                          | manufacturer   |   price |
|:---------------------------------------------------------------|:---------------|--------:|
| microsoft ( r ) windows ( r ) xp professional edition with sp2 |                |  199.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 492
rtable_id: 3160
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                      | manufacturer   |   price |
|:---------------------------|:---------------|--------:|
| microsoft works suite 2006 | microsoft      |      99 |

Entity B:
| title                            | manufacturer   |   price |
|:---------------------------------|:---------------|--------:|
| microsoft ( r ) works suite 2005 |                |   99.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 614
rtable_id: 1170
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                              | manufacturer   |   price |
|:-----------------------------------|:---------------|--------:|
| quickbooks point-of-sale basic 6.0 | intuit         |  799.95 |

Entity B:
| title            | manufacturer   |   price |
|:-----------------|:---------------|--------:|
| quickbooks ( r ) |                |  103.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1198
rtable_id: 1367
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                                                    | manufacturer   |   price |
|:---------------------------------------------------------|:---------------|--------:|
| peachtree by sage premium accounting for nonprofits 2007 | sage software  |  599.99 |

Entity B:
| title                                                                                   | manufacturer   |   price |
|:----------------------------------------------------------------------------------------|:---------------|--------:|
| sage software peachtree pro accounting 2007 software for windows tax & finance software |                |  159.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 3
rtable_id: 1068
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                              | manufacturer   |   price |
|:-----------------------------------|:---------------|--------:|
| adobe premiere elements 3.0 [ lb ] | adobe          |   99.99 |

Entity B:
| title                                                                           | manufacturer   |   price |
|:--------------------------------------------------------------------------------|:---------------|--------:|
| adobe systems inc 29180248 adobe photoshop elements 5.0 / premiere elements 3.0 |                |  139.51 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 364
rtable_id: 1696
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                     | manufacturer        |   price |
|:--------------------------|:--------------------|--------:|
| jumpstart world 2nd grade | knowledge adventure |   19.99 |

Entity B:
| title                                                       | manufacturer   |   price |
|:------------------------------------------------------------|:---------------|--------:|
| knowledge adventure inc. jumpstart world 2nd grade mini box |                |   16.93 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1326
rtable_id: 678
label: 1
Task: Entity-Matching (source dataset: Amazon-Google)

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                    | manufacturer    |   price |
|:-------------------------|:----------------|--------:|
| mavis beacon 17 standard | encore software |   19.95 |

Entity B:
| title                     | manufacturer   |   price |
|:--------------------------|:---------------|--------:|
| adobe cs3 design standard |                | 1243.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 819
rtable_id: 558
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                                   | manufacturer    |   price |
|:----------------------------------------|:----------------|--------:|
| brainfood games cranium collection 2006 | encore software |   19.99 |

Entity B:
| title                             | manufacturer   |   price |
|:----------------------------------|:---------------|--------:|
| hoyle game collection 4 game pack |                |   14.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 455
rtable_id: 3036
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                                                                                                                            | manufacturer      | price   |
|:---------------------------------------------------------------------------------------------------------------------------------|:------------------|:--------|
| adobe photoshop elements 4.0 plus adobe premiere elements 2.0 complete package 1 user cd mini-box win canadian french 29180162 ) | adobe systems inc |         |

Entity B:
| title                                                             | manufacturer   |   price |
|:------------------------------------------------------------------|:---------------|--------:|
| adobe dreamweaver cs3 complete package 1 user academic cd windows |                |     189 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 157
rtable_id: 3077
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                                                 | manufacturer   |   price |
|:------------------------------------------------------|:---------------|--------:|
| adobe creative suite cs3 web standard upgrade [ mac ] | adobe          |     399 |

Entity B:
| title                                               | manufacturer   |   price |
|:----------------------------------------------------|:---------------|--------:|
| adobe illustrator cs3 upgrade from freehand for mac |                |  206.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 465
rtable_id: 485
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                     | manufacturer   |   price |
|:--------------------------|:---------------|--------:|
| elementary advantage 2008 | encore         |   39.99 |

Entity B:
| title                                 | manufacturer   |   price |
|:--------------------------------------|:---------------|--------:|
| elementary school success deluxe 2006 |                |   12.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1014
rtable_id: 2987
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                                                       | manufacturer   |   price |
|:------------------------------------------------------------|:---------------|--------:|
| microsoft office student and teacher edition 2004 macintosh | microsoft      |  149.99 |

Entity B:
| title                                         | manufacturer   |   price |
|:----------------------------------------------|:---------------|--------:|
| microsoft powerpoint mac 2004 version upgrade |                |   89.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1177
rtable_id: 2518
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                  | manufacturer   |   price |
|:-----------------------|:---------------|--------:|
| microsoft onenote 2007 | microsoft      |   99.95 |

Entity B:
| title                               | manufacturer   |   price |
|:------------------------------------|:---------------|--------:|
| microsoft ( r ) mappoint ( r ) 2006 |                |  249.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 541
rtable_id: 3190
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                               | manufacturer         |   price |
|:------------------------------------|:---------------------|--------:|
| instant immersion german deluxe 2.0 | topics entertainment |   39.99 |

Entity B:
| title                          | manufacturer         |   price |
|:-------------------------------|:---------------------|--------:|
| instant immersion 33 languages | topics entertainment |   43.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 554
rtable_id: 2996
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                                                             | manufacturer        | price   |
|:------------------------------------------------------------------|:--------------------|:--------|
| ca arcserve bkup r11 .1 / nw stor area netw ( san ) opt prod only | computer associates |         |

Entity B:
| title                                                      | manufacturer   |   price |
|:-----------------------------------------------------------|:---------------|--------:|
| arcserve bkup protection suite exch r11 .5 upg-v prod only |                | 2249.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 148
rtable_id: 2334
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                                              | manufacturer   |   price |
|:---------------------------------------------------|:---------------|--------:|
| symantec gateway security 300 series 10 10224341 ) | symantec       |     349 |

Entity B:
| title                                                                          | manufacturer   |   price |
|:-------------------------------------------------------------------------------|:---------------|--------:|
| sonicwall comprehensive gateway security for tz 150 series 25 node sonicwall - |                |  107.01 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 650
rtable_id: 2450
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                        | manufacturer   |   price |
|:-----------------------------|:---------------|--------:|
| adobe soundbooth cs3 [ mac ] | adobe          |     199 |

Entity B:
| title                              | manufacturer   |   price |
|:-----------------------------------|:---------------|--------:|
| adobe indesign cs3 for mac upgrade |                |  205.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 876
rtable_id: 151
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                           | manufacturer            |   price |
|:--------------------------------|:------------------------|--------:|
| sibelius 4 professional edition | sibelius-software-ltd . |  599.99 |

Entity B:
| title                                                                       | manufacturer            |   price |
|:----------------------------------------------------------------------------|:------------------------|--------:|
| sibelius sibelius 4 software educational discount music production software | sibelius-software-ltd . |  249.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1148
rtable_id: 2363
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                             | manufacturer         |   price |
|:----------------------------------|:---------------------|--------:|
| middle school success deluxe 2008 | topics entertainment |   49.99 |

Entity B:
| title                                                 | manufacturer   |   price |
|:------------------------------------------------------|:---------------|--------:|
| topics entertainment middle school success essentials |                |   17.55 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 349
rtable_id: 435
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                       | manufacturer   |   price |
|:----------------------------|:---------------|--------:|
| adobe premiere elements 3.0 | adobe          |   99.99 |

Entity B:
| title                  | manufacturer   |   price |
|:-----------------------|:---------------|--------:|
| adobe premiere pro cs3 |                |  825.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 527
rtable_id: 190
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                                             | manufacturer       |   price |
|:--------------------------------------------------|:-------------------|--------:|
| microsoft visual studio professional 2005 upgrade | microsoft software |     549 |

Entity B:
| title                                                                                    | manufacturer   |   price |
|:-----------------------------------------------------------------------------------------|:---------------|--------:|
| 130-00360 microsoft visual studio team edition 2005 for software architects complete pac |                | 5121.98 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 490
rtable_id: 1767
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                                      | manufacturer   |   price |
|:-------------------------------------------|:---------------|--------:|
| microsoft office 2004 professional ( mac ) | microsoft      |  499.99 |

Entity B:
| title                         | manufacturer   |   price |
|:------------------------------|:---------------|--------:|
| microsoft onenote 2007 ( pc ) |                |   99.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 606
rtable_id: 2867
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                            | manufacturer   |   price |
|:---------------------------------|:---------------|--------:|
| microsoft mappoint 2006 with gps | microsoft      |     349 |

Entity B:
| title                                | manufacturer   |   price |
|:-------------------------------------|:---------------|--------:|
| microsoft ( r ) office standard 2007 |                |  399.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 574
rtable_id: 1010
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                  | manufacturer   |   price |
|:-----------------------|:---------------|--------:|
| adobe premiere pro cs3 | adobe          |     799 |

Entity B:
| title                        | manufacturer   |   price |
|:-----------------------------|:---------------|--------:|
| adobe cs3 web premium upsell |                | 1434.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 620
rtable_id: 182
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                                                       | manufacturer   |   price |
|:------------------------------------------------------------|:---------------|--------:|
| microsoft windows vista business 32-bit for system builders | microsoft      |  179.99 |

Entity B:
| title                                                                                | manufacturer   |   price |
|:-------------------------------------------------------------------------------------|:---------------|--------:|
| u84-00101 microsoft windows server 2003 for small business license 5 device cals ope |                |   303.9 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 496
rtable_id: 1828
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                         | manufacturer   |   price |
|:------------------------------|:---------------|--------:|
| adobe dreamweaver cs3 upgrade | adobe          |     199 |

Entity B:
| title                                     | manufacturer   |   price |
|:------------------------------------------|:---------------|--------:|
| adobe cs3 design standard upgrade windows |                |  413.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 572
rtable_id: 368
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                             | manufacturer   |   price |
|:----------------------------------|:---------------|--------:|
| clifford reading pack ( dvd box ) | scholastic     |   19.99 |

Entity B:
| title                                          | manufacturer   |   price |
|:-----------------------------------------------|:---------------|--------:|
| clickart 950000 premier image pack ( dvd-rom ) |                |   48.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 392
rtable_id: 1878
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                                              | manufacturer         |   price |
|:---------------------------------------------------|:---------------------|--------:|
| scholastic brain play : pre-kindergarten 1st grade | topics entertainment |   19.99 |

Entity B:
| title                                               | manufacturer   |   price |
|:----------------------------------------------------|:---------------|--------:|
| scholastic brain play preschool to 1st grade topics |                |   19.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 672
rtable_id: 2846
label: 1
Task: Entity-Matching (source dataset: Amazon-Google)

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                                                  | manufacturer     | price   |
|:-------------------------------------------------------|:-----------------|:--------|
| century software tinyterm plus v. 4.0 complete product | century software |         |

Entity B:
| title                                               | manufacturer   |   price |
|:----------------------------------------------------|:---------------|--------:|
| jungle software gorilla student 4.0 film production |                |  179.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 875
rtable_id: 178
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                                              | manufacturer   |   price |
|:---------------------------------------------------|:---------------|--------:|
| microsoft virtual pc for mac 7.0 with windows 2000 | microsoft      |  249.99 |

Entity B:
| title                                       | manufacturer   |   price |
|:--------------------------------------------|:---------------|--------:|
| microsoft windows vista business 32-bit oem |                |  149.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 145
rtable_id: 1643
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                                            | manufacturer   |   price |
|:-------------------------------------------------|:---------------|--------:|
| corel wordperfect office x3 professional edition | corel          |  399.99 |

Entity B:
| title                     | manufacturer   |   price |
|:--------------------------|:---------------|--------:|
| zipmagic personal edition |                |    8.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 594
rtable_id: 3070
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                                                                | manufacturer   |   price |
|:---------------------------------------------------------------------|:---------------|--------:|
| steinberg sequel ( pc or mac ) music creation & performance software | steinberg      |     129 |

Entity B:
| title                                                                               | manufacturer   |   price |
|:------------------------------------------------------------------------------------|:---------------|--------:|
| steinberg cubase studio 4 software competitive crossgrade music production software |                |  199.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1127
rtable_id: 2238
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                                           | manufacturer   |   price |
|:------------------------------------------------|:---------------|--------:|
| individual small business advantage deluxe 2006 | individual     |   49.99 |

Entity B:
| title                                                  | manufacturer   |   price |
|:-------------------------------------------------------|:---------------|--------:|
| individual software business planmaker pro 2008 ( pc ) |                |   39.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1196
rtable_id: 3025
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                                      | manufacturer              |   price |
|:-------------------------------------------|:--------------------------|--------:|
| easy video editor 2.0 by honest technology | global-marketing-partners |   50.88 |

Entity B:
| title                                                      | manufacturer   |   price |
|:-----------------------------------------------------------|:---------------|--------:|
| global marketing partners dvd player 3.0 honest technology |                |   16.92 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1278
rtable_id: 653
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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                                                          | manufacturer   |   price |
|:---------------------------------------------------------------|:---------------|--------:|
| apple final cut studio 2 upgrade from final cut studio ( mac ) | apple          |     499 |

Entity B:
| title                                                 | manufacturer   |   price |
|:------------------------------------------------------|:---------------|--------:|
| apple software m9372z/a final cut express 2.0 upgrade | apple software |   79.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 625
rtable_id: 1409
label: 0