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 |
|:----------------------------------------|:----------------|--------:|
| professor fuji 's sudoku ( jewel case ) | encore software |    9.99 |

Entity B:
| title                                         | manufacturer   |   price |
|:----------------------------------------------|:---------------|--------:|
| geometry ( win/mac ) ( jewel case ) ( 10158 ) |                |    9.59 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 916
rtable_id: 3106
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 design premium upsell [ mac ] | adobe          |    1599 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 139
rtable_id: 960
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 |
|:-------------------|:----------------|--------:|
| gorilla 4 standard | jungle software |     299 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 670
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 |
|:-----------------------------------------------------------|:---------------|--------:|
| adobe creative suite cs3 master collection upgrade [ mac ] | adobe          |    1399 |

Entity B:
| title                                                                           | manufacturer   |   price |
|:--------------------------------------------------------------------------------|:---------------|--------:|
| 19700045 adobe creative suite 3 web premium complete package 1 user cd mac univ |                | 1691.87 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 910
rtable_id: 1865
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 5.0 / premier elements 3.0 [ lb ] | adobe          |  149.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 267
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 outlook 2007 | microsoft      |  109.95 |

Entity B:
| title                          | manufacturer   |   price |
|:-------------------------------|:---------------|--------:|
| microsoft ( r ) frontpage 2002 |                |  169.56 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 547
rtable_id: 1095
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 |
|:----------------------------------------------------------|:------------------------------------|--------:|
| digital video and audio production book for vegas 7 + dvd | sony-pictures-digital-entertainment |   49.35 |

Entity B:
| title                                                                                      | manufacturer        |   price |
|:-------------------------------------------------------------------------------------------|:--------------------|--------:|
| adobe audition 2.0 audio production software educational discount audio software for video | adobe-education-box |  148.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 840
rtable_id: 2292
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 cubase 4 digital audio software | steinberg      |  999.99 |

Entity B:
| title                                                                             | manufacturer   |   price |
|:----------------------------------------------------------------------------------|:---------------|--------:|
| steinberg cubase studio 4 software educational discount music production software |                |  179.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1170
rtable_id: 2250
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 |
|:------------------------------------------------------|:----------------|--------:|
| tlc clue finders math learning system sb by riverdeep | encore software |   19.99 |

Entity B:
| title                                                               | manufacturer   |   price |
|:--------------------------------------------------------------------|:---------------|--------:|
| encore software 13861 tlc arthurs kindergarten learning system 2008 |                |   17.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1051
rtable_id: 1442
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 cs2 ( mac ) [ old version ] | adobe          |     649 |

Entity B:
| title                               | manufacturer   |   price |
|:------------------------------------|:---------------|--------:|
| adobe photoshop cs3 for mac upgrade |                |  189.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 737
rtable_id: 371
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 |
|:---------------------------------------------|:-----------------------|--------:|
| cosmic blobs : lab rat edition ( win & mac ) | solidworks corporation |   39.99 |

Entity B:
| title                                            | manufacturer   |   price |
|:-------------------------------------------------|:---------------|--------:|
| cosmic blobs : the lab rat edition by solidworks |                |   33.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 639
rtable_id: 322
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 |
|:-----------------------------------------------------------|:---------------|--------:|
| microsoft office frontpage 2003 academic version windows ) | microsoft      |  159.98 |

Entity B:
| title                                                                            | manufacturer   |   price |
|:---------------------------------------------------------------------------------|:---------------|--------:|
| 164-04052 microsoft office publisher 2007 version upgrade package 1 pc cd win en |                |    88.8 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 93
rtable_id: 1805
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 excel 2007 | microsoft      |  229.95 |

Entity B:
| title                                                       | manufacturer   |   price |
|:------------------------------------------------------------|:---------------|--------:|
| individual software professor teaches microsoft office 2007 |                |   29.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 578
rtable_id: 831
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 premiere pro cs3 upgrade |                |  308.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 592
rtable_id: 372
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 cs3 [ mac ] | adobe          |     649 |

Entity B:
| title                                | manufacturer   |   price |
|:-------------------------------------|:---------------|--------:|
| adobe flash cs3 professional ( mac ) |                |     699 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 517
rtable_id: 2839
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 cs3 web standard |                | 1035.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 876
rtable_id: 566
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 |
|:---------------------------------|:---------------|--------:|
| sony sound forge 9 boxed upgrade | sony media     |  232.05 |

Entity B:
| title                                                                       | manufacturer   |   price |
|:----------------------------------------------------------------------------|:---------------|--------:|
| sony creative software sf9006 sound forge 9 boxed upgrade sound editing s/w |                |  127.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 879
rtable_id: 2812
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 |
|:-------------------------------------------------------------------------|:---------------|--------:|
| microsoft windows server 2003 client additional license for users-5 pack | microsoft      |     809 |

Entity B:
| title                                                             | manufacturer   |   price |
|:------------------------------------------------------------------|:---------------|--------:|
| windows sbs cal 2003 20-clt addpak device cal microsoft t74-00003 |                | 1413.42 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 531
rtable_id: 1633
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 |
|:--------------------------------------------------|:---------------|--------:|
| microsoft windows vista home basic upgrade ( pc ) |                |   99.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 490
rtable_id: 1514
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 | adobe          |    1699 |

Entity B:
| title                          | manufacturer   |   price |
|:-------------------------------|:---------------|--------:|
| production prem cs3 mac upgrad | adobe software |  805.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 883
rtable_id: 4
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 ( mac ) | adobe          |   89.99 |

Entity B:
| title                                               | manufacturer   |   price |
|:----------------------------------------------------|:---------------|--------:|
| adobe ( r ) photoshop ( r ) cs windows full version |                |  590.92 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 536
rtable_id: 3094
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 |
|:----------------------------|:------------------------|--------:|
| zend studio 5.1 ( win/mac ) | zend-technologies-inc . |     299 |

Entity B:
| title                                         | manufacturer   |   price |
|:----------------------------------------------|:---------------|--------:|
| geometry ( win/mac ) ( jewel case ) ( 10158 ) |                |    9.59 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1106
rtable_id: 3106
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 |
|:-------------|:---------------|--------:|
| halo ( mac ) | macsoft        |   29.99 |

Entity B:
| title               | manufacturer   |   price |
|:--------------------|:---------------|--------:|
| . mac ( mac ) apple |                |   99.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1109
rtable_id: 2852
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 |
|:------------------|:-----------------------|--------:|
| world of warcraft | blizzard entertainment |   19.99 |

Entity B:
| title                             | manufacturer   |   price |
|:----------------------------------|:---------------|--------:|
| world of warcraft burning crusade |                |   39.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 195
rtable_id: 405
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 |
|:---------------------------------|:-----------------|--------:|
| punch ! professional home design | punch ! software |   89.99 |

Entity B:
| title                                                           | manufacturer   |   price |
|:----------------------------------------------------------------|:---------------|--------:|
| 24100 punch ! 5 in 1 home design complete package 1 user cd win |                |   36.28 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1190
rtable_id: 107
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 |
|:-----------------------------------|:----------------|--------:|
| i copy dvds 2 professional edition | me-too-software |   69.99 |

Entity B:
| title                         | manufacturer   |   price |
|:------------------------------|:---------------|--------:|
| web easy ( r ) professional 6 |                |   49.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 27
rtable_id: 1183
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 windows xp pro sp2 retail |                |  299.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 753
rtable_id: 273
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 |
|:---------------------------|:---------------|--------:|
| emedia bass method win/mac | emedia         |   59.99 |

Entity B:
| title                            | manufacturer   |   price |
|:---------------------------------|:---------------|--------:|
| emedia essential bass guitar dvd |                |   16.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 86
rtable_id: 1584
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 audio | topics entertainment |         |

Entity B:
| title                          | manufacturer   |   price |
|:-------------------------------|:---------------|--------:|
| instant immersion 33 languages |                |   47.36 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 646
rtable_id: 3022
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 flash pro cs3 [ mac ] | adobe          |     699 |

Entity B:
| title                                 | manufacturer   |   price |
|:--------------------------------------|:---------------|--------:|
| adobe cs3 flash professional academic |                |  239.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 642
rtable_id: 448
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 design standard upsell [ mac ] | adobe          |     899 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 350
rtable_id: 242
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 publisher 2007 version upgrade | microsoft      |   99.95 |

Entity B:
| title                              | manufacturer   |   price |
|:-----------------------------------|:---------------|--------:|
| microsoft ( r ) expression web 1.0 |                |  299.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 511
rtable_id: 3220
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 |
|:--------------------------------------------------|:------------------|--------:|
| computrace lojack for laptops 4 year subscription | absolute software |  119.99 |

Entity B:
| title                                           | manufacturer   |   price |
|:------------------------------------------------|:---------------|--------:|
| computrace lojack for laptops 1 yr subscription |                |   45.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 92
rtable_id: 987
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 |
|:---------------------------|:-----------------|--------:|
| punch ! 5 in 1 home design | punch ! software |   39.99 |

Entity B:
| title                                                                       | manufacturer   |   price |
|:----------------------------------------------------------------------------|:---------------|--------:|
| punch software 26100 punch ! master landscape and home design ( small box ) | punch software |   45.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1287
rtable_id: 2510
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 |
|:------------------------|:---------------|--------:|
| cakewalk sonar 6 studio | cakewalk       |     369 |

Entity B:
| title                                                       | manufacturer   |   price |
|:------------------------------------------------------------|:---------------|--------:|
| cakewalk sonar 5 producer edition music production software |                |  379.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1166
rtable_id: 2205
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 |
|:-----------------------------------------|:-------------------|--------:|
| world history ( win/mac ) ( jewel case ) | fogware publishing |    9.99 |

Entity B:
| title                                        | manufacturer   |   price |
|:---------------------------------------------|:---------------|--------:|
| high school world history ( pc/mac ) fogware |                |    9.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 395
rtable_id: 2906
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 |
|:-----------------------|:---------------|--------:|
| microsoft onenote 2007 | microsoft      |   99.95 |

Entity B:
| title                                 | manufacturer   |   price |
|:--------------------------------------|:---------------|--------:|
| microsoft ( r ) project standard 2007 |                |  349.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 541
rtable_id: 3194
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 |
|:--------------------------------------------------|:---------------------------|--------:|
| scansoft paperport professional 11 5 user license | nuance communications inc. |  949.99 |

Entity B:
| title                                                                                | manufacturer   |   price |
|:-------------------------------------------------------------------------------------|:---------------|--------:|
| eq771av aba microsoft windows xp professional license and media 1 user cto english - |                |  137.09 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 198
rtable_id: 125
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 standard upgrade ( mac ) | microsoft      |  239.99 |

Entity B:
| title                                                                   | manufacturer   |   price |
|:------------------------------------------------------------------------|:---------------|--------:|
| microsoft microsoft office 2004 software suite mac apple & mac software |                |  399.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 518
rtable_id: 2195
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 |
|:------------------------------|:---------------|--------:|
| sims 2 seasons expansion pack | aspyr media    |   34.99 |

Entity B:
| title                                 | manufacturer   |   price |
|:--------------------------------------|:---------------|--------:|
| aspyr sims 2 nightlife expansion pack |                |   35.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 900
rtable_id: 333
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 italian 2.0 | topics entertainment |   29.99 |

Entity B:
| title                                                       | manufacturer   |   price |
|:------------------------------------------------------------|:---------------|--------:|
| topics entertainment instant immersion spanish audio deluxe |                |   17.55 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 274
rtable_id: 832
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   |
|:----------------------------------------------------------------------|:------------------|:--------|
| wasp bar code wasp bar code labeler complete package 3 users std cd - | wasp technologies |         |

Entity B:
| title                                                       | manufacturer   |   price |
|:------------------------------------------------------------|:---------------|--------:|
| pafgpcmv01000p0rtpen pcmover complete package 1 user cd win |                |   39.14 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 208
rtable_id: 1940
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 xp professional upgrade with sp2 | microsoft software |  199.99 |

Entity B:
| title                                           | manufacturer   |   price |
|:------------------------------------------------|:---------------|--------:|
| visual studio pro 2005 upgrade ( pc ) microsoft |                |     549 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 512
rtable_id: 2803
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 translator deluxe 2.0 | topics entertainment |   49.99 |

Entity B:
| title                                          | manufacturer   |   price |
|:-----------------------------------------------|:---------------|--------:|
| instant immersion italian audio ( audio book ) |                |   19.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1329
rtable_id: 1666
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 small business server premium 2003 r2 upgrade cd/dvd 5 client | microsoft      |     709 |

Entity B:
| title                                         | manufacturer   |   price |
|:----------------------------------------------|:---------------|--------:|
| microsoft ( r ) windows vista ( tm ) business |                |  199.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 443
rtable_id: 3126
label: 0