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 |
|:-------------------------------|:---------------|--------:|
| adobe premiere pro cs3 upgrade | adobe          |     299 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 26
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 office small business 2007 full version | microsoft      |  449.95 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 604
rtable_id: 2165
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 r39-00292 open win svr 2003 ext conn |                | 1863.78 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 781
rtable_id: 1687
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 professional services 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: 586
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 |
|:---------------|:----------------|--------:|
| super granny 3 | encore software |   19.99 |

Entity B:
| title              | manufacturer   |   price |
|:-------------------|:---------------|--------:|
| super collapse ! 3 |                |   22.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 880
rtable_id: 297
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 data analyzer 2002 | microsoft      |     179 |

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: 497
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 |
|:--------------------------------------|:---------------|--------:|
| norton internet security 2008 10 user | symantec       |  199.99 |

Entity B:
| title                                                                          | manufacturer   |   price |
|:-------------------------------------------------------------------------------|:---------------|--------:|
| pcnf0040 pc-cillin internet security 2007 complete package 3 users federal win |                |   29.02 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1008
rtable_id: 1907
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 |
|:------------------------------------------------------------------|:---------------|--------:|
| total training for adobe creative suite 3 : design premium bundle | total training |  299.99 |

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: 88
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 |
|:-------------------------------------|:-----------------|--------:|
| intellimover transfer your pc deluxe | nova development |   69.99 |

Entity B:
| title                                                      | manufacturer   |   price |
|:-----------------------------------------------------------|:---------------|--------:|
| nova development corp intellimover transfer your pc deluxe |                |   65.17 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 702
rtable_id: 410
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 |
|:--------------------------------|:------------------------|--------:|
| sibelius 4 professional edition | sibelius-software-ltd . |  599.99 |

Entity B:
| title                      | manufacturer   |   price |
|:---------------------------|:---------------|--------:|
| system care ? professional |                |   49.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1148
rtable_id: 1188
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   |
|:-------------------------------------------------------|:-----------------|:--------|
| century software tinyterm plus v. 4.0 complete product | century software |         |

Entity B:
| title                                  | manufacturer   |   price |
|:---------------------------------------|:---------------|--------:|
| passwords plus v. 1.0 complete package |                |    28.5 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 875
rtable_id: 1592
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 ingles audio deluxe | topics entertainment |         |

Entity B:
| title                                              | manufacturer   |   price |
|:---------------------------------------------------|:---------------|--------:|
| topics entertainment instant immersion italian 2.0 |                |   17.55 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 971
rtable_id: 845
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 |
|:--------------------------|:------------------------|--------:|
| oxford spanish dictionary | oxford-university-press |   19.95 |

Entity B:
| title              | manufacturer   |   price |
|:-------------------|:---------------|--------:|
| student dictionary |                |    8.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 126
rtable_id: 2958
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 word 2004 upgrade ( mac ) | microsoft      |  109.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 823
rtable_id: 2206
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 small business 2007 full version | microsoft      |  449.95 |

Entity B:
| title                                                     | manufacturer   |   price |
|:----------------------------------------------------------|:---------------|--------:|
| microsoft academic microsoft office project 2003 standard |                |   69.95 |



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

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

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

Entity A:
| title                          | manufacturer   |   price |
|:-------------------------------|:---------------|--------:|
| microsoft onenote 2007 upgrade | microsoft      |   79.95 |

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: 858
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 |
|:-----------------------------------------------------|:---------------|--------:|
| adobe creative suite cs3 web premium upgrade [ mac ] | adobe          |     499 |

Entity B:
| title                                                                                  | manufacturer   |   price |
|:---------------------------------------------------------------------------------------|:---------------|--------:|
| adobe creative suite 3 ( cs3 ) web standard 3 windows upsell from dreamweaver or flash |                |     799 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 608
rtable_id: 1017
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 upgrade [ mac ] | adobe          |     599 |

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



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

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

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

Entity A:
| title                                               | manufacturer   |   price |
|:----------------------------------------------------|:---------------|--------:|
| 3d home architect landscape design deluxe version 9 | encore         |   29.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: 0
original: ltable_id: 1185
rtable_id: 2926
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 |
|:-----------------------------------------|:---------------|--------:|
| mindjet mindmanager 7 mac single license | mindjet        |     129 |

Entity B:
| title                                                            | manufacturer   |   price |
|:-----------------------------------------------------------------|:---------------|--------:|
| mindjet inc. mm7m mindjet mindmanager 7 mac single user w/wmedia |                |  112.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 477
rtable_id: 2466
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 |
|:---------------------------|:---------------|--------:|
| emedia guitarpro 5 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: 1306
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 |
|:--------------------------------------------|:---------------|--------:|
| adobe creative suite cs3 production premium | adobe          |    1699 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 883
rtable_id: 531
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 and windows training professional |                |   29.99 |



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

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

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

Entity A:
| title                                                                | manufacturer   |   price |
|:---------------------------------------------------------------------|:---------------|--------:|
| steinberg sequel ( pc or mac ) music creation & performance software | steinberg      |     129 |

Entity B:
| title                                                         | manufacturer   |   price |
|:--------------------------------------------------------------|:---------------|--------:|
| motu digital performer dp5 software music production software |                |  319.95 |



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

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

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

Entity A:
| title                      | manufacturer   |   price |
|:---------------------------|:---------------|--------:|
| microsoft works suite 2006 | microsoft      |      99 |

Entity B:
| title                             | manufacturer   |   price |
|:----------------------------------|:---------------|--------:|
| microsoft 059-03871 molpc word sa |                |  111.78 |



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

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

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

Entity A:
| title                                                     | manufacturer   |   price |
|:----------------------------------------------------------|:---------------|--------:|
| apple iwork '06 family pack ( mac dvd ) [ older version ] | apple          |      99 |

Entity B:
| title                                          | manufacturer   |   price |
|:-----------------------------------------------|:---------------|--------:|
| apple . mac 4.0 family pack ( new or renewal ) |                |  145.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 591
rtable_id: 515
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 |
|:-----------------|:---------------|--------:|
| appleworks 6.2.9 | apple          |      79 |

Entity B:
| title                          | manufacturer   |   price |
|:-------------------------------|:---------------|--------:|
| apple appleworks 6.2.9 ( mac ) |                |   79.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1141
rtable_id: 2811
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 premiere pro cs3 upgrade |                |  308.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 216
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 premiere pro cs3 | adobe          |     799 |

Entity B:
| title                                | manufacturer   |   price |
|:-------------------------------------|:---------------|--------:|
| adobe cs3 production premium upgrade |                |  822.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 892
rtable_id: 426
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 illustrator cs3 upgrade [ mac ] | adobe          |     199 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 923
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   |
|:--------------------|:--------------------|:--------|
| jumpstart 1st grade | knowledge adventure |         |

Entity B:
| title                          | manufacturer   |   price |
|:-------------------------------|:---------------|--------:|
| brain play preschool-1st grade |                |    17.9 |



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

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

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

Entity A:
| title                                                 | manufacturer   |   price |
|:------------------------------------------------------|:---------------|--------:|
| microsoft virtual pc for mac 7.0 with windows xp home | microsoft      |  219.99 |

Entity B:
| title                                            | manufacturer   |   price |
|:-------------------------------------------------|:---------------|--------:|
| microsoft windows xp home edition sp2 retail box |                |  199.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 645
rtable_id: 286
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 indesign cs3 upgrade [ mac ] | adobe          |     199 |

Entity B:
| title                            | manufacturer   |   price |
|:---------------------------------|:---------------|--------:|
| adobe cs3 design premium upgrade |                |  619.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 593
rtable_id: 893
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 & home design | punch ! software |   99.99 |

Entity B:
| title                                                         | manufacturer   |   price |
|:--------------------------------------------------------------|:---------------|--------:|
| punch software 25100 punch ! master landscape and home design | punch software |   45.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1284
rtable_id: 1080
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 |
|:---------------------------------------|:-----------------|--------:|
| punch ! master landscape & home design | punch ! software |   99.99 |

Entity B:
| title                          | manufacturer   |   price |
|:-------------------------------|:---------------|--------:|
| home & landscape design center |                |    8.49 |



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

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

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

Entity A:
| title                                                 | manufacturer   |   price |
|:------------------------------------------------------|:---------------|--------:|
| microsoft windows vista ultimate full version [ dvd ] | microsoft      |  399.95 |

Entity B:
| title                                                                                  | manufacturer   |   price |
|:---------------------------------------------------------------------------------------|:---------------|--------:|
| t74-01215 microsoft windows small business server 2003 version upgrade license 5 addit |                |  186.73 |



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

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

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

Entity A:
| title                                                 | manufacturer   |   price |
|:------------------------------------------------------|:---------------|--------:|
| microsoft windows vista business full version [ dvd ] | microsoft      |  299.95 |

Entity B:
| title                                                         | manufacturer   |   price |
|:--------------------------------------------------------------|:---------------|--------:|
| microsoft windows vista business upgrade license 1 pc english |                |  168.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 584
rtable_id: 1137
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 licenses win svr 2003 device cal l/sa ( r1800144 ) | microsoft licenses |   74.59 |

Entity B:
| title                                                                     | manufacturer   |   price |
|:--------------------------------------------------------------------------|:---------------|--------:|
| microsoft windows server 2003 terminal server cals 20-pack ( per device ) |                | 2429.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 228
rtable_id: 1011
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 |
|:--------------------------------------------------------------|:---------------|--------:|
| adobe premiere pro 2.0 software professional editing software |                |  848.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 27
rtable_id: 2199
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 |
|:----------------------------------------------------|:---------------|--------:|
| designing forms with microsoft office infopath 2007 |                |   36.39 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 578
rtable_id: 2332
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 & home design | punch ! software |   59.99 |

Entity B:
| title                                       | manufacturer   |   price |
|:--------------------------------------------|:---------------|--------:|
| punch software 90500 home design studio mac | punch software |  135.99 |



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

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

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

Entity A:
| title                                          | manufacturer   |   price |
|:-----------------------------------------------|:---------------|--------:|
| microsoft productivity pack for windows mobile | microsoft      |   29.99 |

Entity B:
| title                                                                 | manufacturer   |   price |
|:----------------------------------------------------------------------|:---------------|--------:|
| pg music band in a box software for windows music production software | pg-music-inc . |   74.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 492
rtable_id: 2150
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 |
|:-------------------------|:---------------------|--------:|
| math success deluxe 2008 | topics entertainment |   49.99 |

Entity B:
| title                       | manufacturer   |   price |
|:----------------------------|:---------------|--------:|
| phonics success deluxe 2006 |                |    22.9 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1212
rtable_id: 2133
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 upgrade [ mac ] | adobe          |     599 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 516
rtable_id: 331
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 software 22070152 after effects 6.5 pbupgrd |                |     507 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 592
rtable_id: 1923
label: 0