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 |
|:-------------------------------------------|:---------------|--------:|
| tlc dr. seuss reading learning system 2008 | encore         |   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: 124
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 |
|:--------------------|:---------------|--------:|
| microspot interiors | microspot ltd. |   99.95 |

Entity B:
| title                                  | manufacturer   |   price |
|:---------------------------------------|:---------------|--------:|
| microspot macdraft pe personal edition |                |   85.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 131
rtable_id: 330
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 office 2004 std upgrade |                |  219.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 511
rtable_id: 915
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 ! home design architectura series 18 | punch ! software |  129.99 |

Entity B:
| title                                                            | manufacturer   |   price |
|:-----------------------------------------------------------------|:---------------|--------:|
| punch software 41100 punch ! home design architectural series 18 | punch software |  118.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1258
rtable_id: 2402
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 |
|:-----------------------------|:---------------|--------:|
| quicken 2007 home & business | intuit         |   89.95 |

Entity B:
| title                      | manufacturer   |   price |
|:---------------------------|:---------------|--------:|
| quicken ( r ) premier 2007 |                |   79.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 577
rtable_id: 3134
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 |
|:-----------------------------|:---------------|--------:|
| quicken 2007 home & business | intuit         |   89.95 |

Entity B:
| title                      | manufacturer   |   price |
|:---------------------------|:---------------|--------:|
| quicken ( r ) for mac 2007 |                |   69.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 577
rtable_id: 1136
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 upgrade | adobe          |     299 |

Entity B:
| title                        | manufacturer   |   price |
|:-----------------------------|:---------------|--------:|
| adobe contribute cs3 upgrade |                |   82.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 26
rtable_id: 897
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 |
|:---------------------|:---------------|--------:|
| panda antivirus 2007 | panda software |   29.95 |

Entity B:
| title             | manufacturer   |   price |
|:------------------|:---------------|--------:|
| ca antivirus 2007 |                |   32.28 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 934
rtable_id: 663
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 nightlife expansion pack | aspyr media    |   34.99 |

Entity B:
| title                        | manufacturer   |   price |
|:-----------------------------|:---------------|--------:|
| sims 2 season expansion pack |                |   37.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 641
rtable_id: 147
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 frontpage 2003 academic version windows ) | microsoft      |  159.98 |

Entity B:
| title                                                   | manufacturer   |   price |
|:--------------------------------------------------------|:---------------|--------:|
| microsoft office 2004 for students and teachers ( mac ) |                |  134.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 93
rtable_id: 2850
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 |
|:--------------------------------------------------------|:-----------------|--------:|
| webroot spy sweeper with antivirus family edition 3 pcs | webroot software |   49.95 |

Entity B:
| title                                                      | manufacturer   |   price |
|:-----------------------------------------------------------|:---------------|--------:|
| webroot software inc 31250 spy sweeper spanish win 2000 xp |                |   25.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 941
rtable_id: 2264
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 ( r ) works suite 2006 |                |   99.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 518
rtable_id: 1207
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 office 2004 student/teacher |                |  145.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 490
rtable_id: 945
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 sql server standard edition 2005 64 bit cd/dvd 5 client | microsoft      |    1849 |

Entity B:
| title                                                                | manufacturer   |   price |
|:---------------------------------------------------------------------|:---------------|--------:|
| microsoft ( r ) office 2004 for mac standard edition upgrade version |                |  234.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 12
rtable_id: 1159
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 full version with sp2 | microsoft      |  299.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 632
rtable_id: 3126
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 |
|:---------------------------|:---------------|--------:|
| mcafee virusscan plus 2007 | mcafee         |   39.99 |

Entity B:
| title                             | manufacturer   |   price |
|:----------------------------------|:---------------|--------:|
| mcafee virusscan plus 2007 ( pc ) |                |   39.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 374
rtable_id: 2815
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 |
|:----------------------|:---------------|--------:|
| data protection suite | stomp inc      |   69.99 |

Entity B:
| title                                                    | manufacturer   |   price |
|:---------------------------------------------------------|:---------------|--------:|
| internet security suite 2007 home protection pack xl box |                |   61.06 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 24
rtable_id: 1583
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 office and windows training ( win 98 me nt 2000 xp ) |                |   29.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1177
rtable_id: 1585
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 hawaiian audio |                |   12.05 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 274
rtable_id: 647
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   |
|:-----------------------------------------------|:----------------|:--------|
| amazing animals with zoofari games ( win/mac ) | global software |         |

Entity B:
| title                                                                                                               | manufacturer   |   price |
|:--------------------------------------------------------------------------------------------------------------------|:---------------|--------:|
| global software a2663m2h amazing animals w/zoofari games win 95 98 me xp/mac 8.6-9.x ( classic ) x v10 .1 or higher |                |    8.79 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 697
rtable_id: 2780
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 |
|:----------------------------------------------------|:---------------|--------:|
| adobe illustrator cs3 upgrade from freehand [ mac ] | adobe          |     199 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 216
rtable_id: 430
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 premium upgrade [ mac ] | adobe          |     499 |

Entity B:
| title                             | manufacturer   |   price |
|:----------------------------------|:---------------|--------:|
| adobe cs3 design premium academic |                |  575.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 608
rtable_id: 939
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 creative suite 3 ( cs3 ) design premium upgrade mac |                |  569.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 736
rtable_id: 1213
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 5 professional edition | sibelius-software-ltd . |     599 |

Entity B:
| title                       | manufacturer   |   price |
|:----------------------------|:---------------|--------:|
| diskeeper 2007 professional |                |   46.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 287
rtable_id: 1485
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 pro 2007 for mac ( mac ) | intuit         |  199.95 |

Entity B:
| title                                                                  | manufacturer   |   price |
|:-----------------------------------------------------------------------|:---------------|--------:|
| intuit quickbooks pro 2007 software for windows tax & finance software |                |  179.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 532
rtable_id: 2302
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   |
|:-----------------------------------------|:------------------------------------|:--------|
| acad vegas movie studio + dvd 8 platinum | sony-pictures-digital-entertainment |         |

Entity B:
| title                                                                      | manufacturer                        |   price |
|:---------------------------------------------------------------------------|:------------------------------------|--------:|
| madison media software aspvms8000 acad vegas movie studio + dvd 8 platinum | sony-pictures-digital-entertainment |   81.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1300
rtable_id: 737
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 mac 2004 english 3pk dsp 731-01163 ) | microsoft corporation |         |

Entity B:
| title                                     | manufacturer   |   price |
|:------------------------------------------|:---------------|--------:|
| microsoft w87-02380 office sbe 2007 win32 |                |  400.34 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 773
rtable_id: 1512
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 |
|:-----------------------------------|:-----------------|--------:|
| nova greeting card factory ( mac ) | nova development |   49.99 |

Entity B:
| title                              | manufacturer   |   price |
|:-----------------------------------|:---------------|--------:|
| nova greeting card factory for mac |                |   41.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1083
rtable_id: 983
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 |
|:---------------------------------------|:--------------------|--------:|
| ca internet security suite 2007 3 user | computer associates |   69.95 |

Entity B:
| title                                                               | manufacturer              |   price |
|:--------------------------------------------------------------------|:--------------------------|--------:|
| f-secure internet security 2007 3 pcs ( global marketing partners ) | global-marketing-partners |   63.35 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 79
rtable_id: 3095
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 |
|:---------------|:---------------|--------:|
| net ad creator | laughing bird  |   39.99 |

Entity B:
| title                       | manufacturer   |   price |
|:----------------------------|:---------------|--------:|
| enteractive inc fps creator |                |   44.58 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1138
rtable_id: 547
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 |
|:----------------------------------|:--------------------|--------:|
| prosoft tunetech for ipod ( mac ) | prosoft engineering |   74.99 |

Entity B:
| title                                                   | manufacturer   |   price |
|:--------------------------------------------------------|:---------------|--------:|
| microsoft office 2004 for students and teachers ( mac ) |                |  134.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 167
rtable_id: 2850
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 |
|:----------------------------------|:----------------|--------:|
| battlefield 1942 : deluxe edition | electronic arts |   29.99 |

Entity B:
| title                                                   | manufacturer   |   price |
|:--------------------------------------------------------|:---------------|--------:|
| ea sports battlefield 1942 : deluxe edition ( pc ) game |                |    9.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 768
rtable_id: 382
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 |
|:----------------------------|:---------------|--------:|
| adobe premiere elements 3.0 | adobe          |   99.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 527
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 excel 2004 ( mac ) | microsoft      |  229.99 |

Entity B:
| title                                           | manufacturer   |   price |
|:------------------------------------------------|:---------------|--------:|
| microsoft mappoint 2006 with gps locator ( pc ) |                |  349.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 781
rtable_id: 3029
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 extended [ mac ] | adobe          |     999 |

Entity B:
| title                                          | manufacturer   |   price |
|:-----------------------------------------------|:---------------|--------:|
| adobe ( r ) photoshop ( r ) 7.0 upgrade for pc |                |  679.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 264
rtable_id: 1180
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 premier nonprofit edition 2007 | intuit         |  399.95 |

Entity B:
| title                      | manufacturer   |   price |
|:---------------------------|:---------------|--------:|
| quicken ( r ) premier 2007 |                |   79.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 520
rtable_id: 3134
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 american sign language win/mac | topics entertainment |    9.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1321
rtable_id: 1475
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 powerpoint 2004 ( mac ) | microsoft      |  229.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 225
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 |
|:---------------------------------|:-------------------|--------:|
| palo alto business plan pro 2007 | palo-alto-software |   99.95 |

Entity B:
| title                        | manufacturer   |   price |
|:-----------------------------|:---------------|--------:|
| business plan pro ( r ) 2004 |                |   99.87 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1281
rtable_id: 3162
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 |
|:---------------------------------------------------------|:---------------|--------:|
| valuesoft tune transfer for ipod software for windows xp | valuesoft      |   29.95 |

Entity B:
| title                                                                   | manufacturer           |   price |
|:------------------------------------------------------------------------|:-----------------------|--------:|
| autodesk 3ds max 9 3d animation software for windows animation software | autodesk-m - & - e-box |  3494.5 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1176
rtable_id: 2820
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 |
|:----------------------------------|:---------------|--------:|
| word mac 2004 microsoft d48-00487 |                |  157.18 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 578
rtable_id: 1686
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 |
|:--------------------|:---------------|--------:|
| microsoft 164-04052 | microsoft      |   90.24 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 578
rtable_id: 1636
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 ! master landscape professional & home design v 10.0 | punch ! software |   69.95 |

Entity B:
| title                                                                                       | manufacturer   |   price |
|:--------------------------------------------------------------------------------------------|:---------------|--------:|
| punch software 84100 punch ! home design architectural series 4000 v. 10.0 architectural pc |                |  168.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1115
rtable_id: 1033
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 |
|:----------------------|:---------------------|--------:|
| aquazone bass edition | smith-micro-software |   19.99 |

Entity B:
| title                                     | manufacturer   |   price |
|:------------------------------------------|:---------------|--------:|
| allume aquazone seven seas deluxe edition |                |   24.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1116
rtable_id: 966
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 [ mac ] | adobe          |    1799 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 597
rtable_id: 242
label: 0