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

Entity B:
| title                                                | manufacturer        |   price |
|:-----------------------------------------------------|:--------------------|--------:|
| individual software jce-th6 total 3d home deluxe j/c | individual software |    9.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1196
rtable_id: 2508
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 edition 2007 5 user multi-pack | intuit         | 1499.95 |

Entity B:
| title                              | manufacturer   |   price |
|:-----------------------------------|:---------------|--------:|
| intuit quickbooks pro 2007 for mac |                |  185.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 580
rtable_id: 922
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 |
|:-------------------------------|:---------------|--------:|
| production prem cs3 mac upgrad | adobe software |  805.99 |



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

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

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

Entity A:
| title                            | manufacturer   |   price |
|:---------------------------------|:---------------|--------:|
| scrabble complete ( jewel case ) | encore         |    9.99 |

Entity B:
| title                                                | manufacturer   |   price |
|:-----------------------------------------------------|:---------------|--------:|
| encore software 11290 scrabble complete win 98 me xp |                |    7.69 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1303
rtable_id: 743
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 indesign cs3 upgrade from pagemaker [ mac ] | adobe          |     199 |

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: 1174
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   |
|:---------------------|:---------------|:--------|
| emedia guitar basics | emedia music   |         |

Entity B:
| title                                               | manufacturer   |   price |
|:----------------------------------------------------|:---------------|--------:|
| emedia music corp emedia intermediate guitar method |                |   49.21 |



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

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

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

Entity A:
| title                      | manufacturer     |   price |
|:---------------------------|:-----------------|--------:|
| punch ! 5 in 1 home design | punch ! software |   39.99 |

Entity B:
| title                                                             | manufacturer   |   price |
|:------------------------------------------------------------------|:---------------|--------:|
| punch software master landscape professional & home design v 10.0 |                |   69.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1287
rtable_id: 792
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 | adobe          |     999 |

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



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

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

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

Entity A:
| title                                      | manufacturer              |   price |
|:-------------------------------------------|:--------------------------|--------:|
| easy video editor 2.0 by honest technology | global-marketing-partners |   50.88 |

Entity B:
| title                                                           | manufacturer   |   price |
|:----------------------------------------------------------------|:---------------|--------:|
| global marketing partners backpack journalist honest technology |                |   83.27 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1278
rtable_id: 447
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 |
|:----------------------------|:---------------|--------:|
| pop-up stopper professional | panicware      |   29.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 618
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 |
|:------------------------|:---------------------|--------:|
| reader rabbit preschool | the-learning-company |   29.99 |

Entity B:
| title                                           | manufacturer   |   price |
|:------------------------------------------------|:---------------|--------:|
| reader rabbit kindergarten special 2-cd edition |                |   12.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 324
rtable_id: 2982
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 |
|:---------------------------------------------|:---------------|--------:|
| adventure workshop 1st-3rd grade 8th edition | encore         |   19.99 |

Entity B:
| title                                       | manufacturer   |   price |
|:--------------------------------------------|:---------------|--------:|
| cluefinders 3rd grade adventures with adapt |                |    9.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 359
rtable_id: 2894
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 |
|:--------------------------------------|:----------------------|--------:|
| diskeeper 2007 pro premier 5-lic pack | diskeeper corporation |  736.66 |

Entity B:
| title                                                                                             | manufacturer   |   price |
|:--------------------------------------------------------------------------------------------------|:---------------|--------:|
| diskeeper corporation diskeeper 2007 professional edition complete package 1 workstation academic |                |   29.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 255
rtable_id: 1161
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 german 2.0 |                |   17.55 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 971
rtable_id: 260
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 |
|:-------------------------------------------|:----------------|--------:|
| printmaster 17 platinum by encore software | encore software |   39.99 |

Entity B:
| title                                                                  | manufacturer   |   price |
|:-----------------------------------------------------------------------|:---------------|--------:|
| encore software 10741 the print shop 22 deluxe sb cs by the print shop |                |   42.97 |



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

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

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

Entity A:
| title                                      | manufacturer   |   price |
|:-------------------------------------------|:---------------|--------:|
| microsoft office 2004 professional ( mac ) | microsoft      |  499.99 |

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



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

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

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

Entity A:
| title          | manufacturer   |   price |
|:---------------|:---------------|--------:|
| human body 360 | megasystems    |   29.99 |

Entity B:
| title                      | manufacturer   |   price |
|:---------------------------|:---------------|--------:|
| human body 360 megasystems |                |   29.99 |



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

Entity B:
| title                       | manufacturer   |   price |
|:----------------------------|:---------------|--------:|
| microsoft excel 2007 ( pc ) |                |  229.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 604
rtable_id: 2821
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 contribute cs3 upgrade |                |   82.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 593
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 |
|:-------------------------------------------|:---------------|--------:|
| microsoft office 2004 professional ( mac ) | microsoft      |  499.99 |

Entity B:
| title                                                                           | manufacturer   |   price |
|:--------------------------------------------------------------------------------|:---------------|--------:|
| c8a-00066 microsoft dynamics crm professional v. 3.0 product upgrade license 20 |                | 9676.92 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 606
rtable_id: 1886
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 acrobat 7.0 professional | adobe          |  449.99 |

Entity B:
| title                                | manufacturer   |   price |
|:-------------------------------------|:---------------|--------:|
| adobe cs3 flash professional upgrade |                |  205.99 |



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

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

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

Entity A:
| title                       | manufacturer   |   price |
|:----------------------------|:---------------|--------:|
| adobe photoshop cs3 [ mac ] | adobe          |     649 |

Entity B:
| title                                      | manufacturer   |   price |
|:-------------------------------------------|:---------------|--------:|
| adobe photoshop cs3 ( mac os x v. 10.4.8 ) |                |     649 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 517
rtable_id: 2649
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 ! super home suite | punch ! software |   49.99 |

Entity B:
| title                                           | manufacturer   |   price |
|:------------------------------------------------|:---------------|--------:|
| punch software 20100 punch ! 5 in 1 home design | punch software |   35.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1275
rtable_id: 2400
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 |
|:-------------------------------------------------------------|:---------------|--------:|
| onone essentials for adobe photoshop elements version 2 full | onone software |   59.95 |

Entity B:
| title                                     | manufacturer        |   price |
|:------------------------------------------|:--------------------|--------:|
| adobe photoshop elements 4.0 mac academic | adobe-education-box |   69.99 |



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

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

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

Entity A:
| title                                 | manufacturer   |   price |
|:--------------------------------------|:---------------|--------:|
| adobe dreamweaver cs3 upgrade [ mac ] | adobe          |     199 |

Entity B:
| title                         | manufacturer   |   price |
|:------------------------------|:---------------|--------:|
| adobe dreamweaver cs3 upgrade |                |  205.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 562
rtable_id: 954
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 |
|:--------------------------------------|:-----------------|--------:|
| webroot spysweeper antispyware 3 user | webroot software |   39.99 |

Entity B:
| title                                   | manufacturer     |   price |
|:----------------------------------------|:-----------------|--------:|
| webroot software 65210 spy sweeper 3 pc | webroot software |   31.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1099
rtable_id: 767
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 creative suite cs3 design standard upsell [ mac ] | adobe          |     899 |

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



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

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

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

Entity A:
| title                                         | manufacturer   |   price |
|:----------------------------------------------|:---------------|--------:|
| intuit quicken home inventory manager windows | intuit         |   34.95 |

Entity B:
| title                                        | manufacturer   |   price |
|:---------------------------------------------|:---------------|--------:|
| quicken home and business 2007 ( pc ) intuit |                |   89.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1308
rtable_id: 2773
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 |
|:-------------------------|:---------------|--------:|
| learning quickbooks 2007 | intuit         |   39.95 |

Entity B:
| title                     | manufacturer   |   price |
|:--------------------------|:---------------|--------:|
| math learning system 2007 |                |   15.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 539
rtable_id: 3062
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   |
|:-------------------------------|:---------------|:--------|
| cubase se3 educational edition | steinberg      |         |

Entity B:
| title                                   | manufacturer   |   price |
|:----------------------------------------|:---------------|--------:|
| microspot macdraft professional edition |                |  249.99 |



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

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

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

Entity A:
| title                                                                                                                            | manufacturer      | price   |
|:---------------------------------------------------------------------------------------------------------------------------------|:------------------|:--------|
| adobe photoshop elements 4.0 plus adobe premiere elements 2.0 complete package 1 user cd mini-box win canadian french 29180162 ) | adobe systems inc |         |

Entity B:
| title                                                                    | manufacturer   |   price |
|:-------------------------------------------------------------------------|:---------------|--------:|
| adobe flash cs3 professional complete package 1 user academic cd windows |                |     229 |



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

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

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

Entity A:
| title                                                         | manufacturer       |   price |
|:--------------------------------------------------------------|:-------------------|--------:|
| microsoft crm small business ed cal 3.0 license pack user cal | microsoft software |    9929 |

Entity B:
| title                                   | manufacturer   |   price |
|:----------------------------------------|:---------------|--------:|
| microsoft windows vista business ( pc ) |                |  299.99 |



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



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

Entity B:
| title                                                        | manufacturer   |   price |
|:-------------------------------------------------------------|:---------------|--------:|
| sony creative software vegas43 ; dvd v. 7.0 complete product |                |  420.55 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 875
rtable_id: 2612
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 spanish deluxe 2.0 | topics entertainment |   49.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 515
rtable_id: 260
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 non-profit edition 2005 | intuit inc.    |  499.95 |

Entity B:
| title                                            | manufacturer   |   price |
|:-------------------------------------------------|:---------------|--------:|
| quickbooks ( r ) credit card processing kit 2007 |                |   39.99 |



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

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

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

Entity A:
| title                    | manufacturer     |   price |
|:-------------------------|:-----------------|--------:|
| punch 5 in 1 home design | punch ! software |   39.99 |

Entity B:
| title                                       | manufacturer   |   price |
|:--------------------------------------------|:---------------|--------:|
| punch software 10602 concepts 2d cad design |                |   38.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1269
rtable_id: 2065
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 premiere pro cs3 |                |  825.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 620
rtable_id: 190
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 & windows training | topics entertainment |   29.99 |

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



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

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

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

Entity A:
| title                                                                               | manufacturer   |   price |
|:------------------------------------------------------------------------------------|:---------------|--------:|
| microsoft windows terminal server 2003 client additional license for users - 5 user | microsoft      |     669 |

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: 662
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 visual studio team edition for software architect 2005 with msdn premium | microsoft      |    5479 |

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



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

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

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

Entity A:
| title                                            | manufacturer   |   price |
|:-------------------------------------------------|:---------------|--------:|
| adobe creative suite cs3 design standard [ mac ] | adobe          |    1199 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 588
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 flash pro cs3 upgrade [ mac ] | adobe          |     199 |

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



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

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

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

Entity A:
| title                                     | manufacturer   |   price |
|:------------------------------------------|:---------------|--------:|
| mac os x server v10 .4.7 unlimited client | apple          |     999 |

Entity B:
| title                                                      | manufacturer   |   price |
|:-----------------------------------------------------------|:---------------|--------:|
| apple mac os x server tiger unlimited apple & mac software |                |  998.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 997
rtable_id: 2255
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 |
|:------------------------------|:---------------|--------:|
| real arcade : adventure inlay | activision     |   29.95 |

Entity B:
| title                                                       | manufacturer   |   price |
|:------------------------------------------------------------|:---------------|--------:|
| math missions : the amazing arcade adventure ( grades 3-5 ) |                |   12.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 303
rtable_id: 3
label: 0