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 |
|:-------------------------------|:---------------|--------:|
| hoyle solitaire ( jewel case ) | encore         |    9.99 |

Entity B:
| title                                           | manufacturer   |   price |
|:------------------------------------------------|:---------------|--------:|
| total 3d home deluxe ( jewel case ) ( jce-th6 ) |                |    9.59 |



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

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

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

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

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 597
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 |
|:---------------------|:---------------|--------:|
| nero 8 ultra edition | nero inc.      |   99.95 |

Entity B:
| title                                                                                     | manufacturer   |   price |
|:------------------------------------------------------------------------------------------|:---------------|--------:|
| nero nero 7 ultra edition enhanced cd/dvd burning software for windows authoring software |                |   79.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1337
rtable_id: 2117
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   |
|:----------------------------------------------|:---------------|:--------|
| internet security barrier x4 antispam edition | intego inc     |         |

Entity B:
| title                                                                                    | manufacturer   |   price |
|:-----------------------------------------------------------------------------------------|:---------------|--------:|
| f89-00346 microsoft internet security and acceleration server enterprise edition license |                |  537.72 |



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

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

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

Entity A:
| title               | manufacturer   |   price |
|:--------------------|:---------------|--------:|
| quicken 2007 deluxe | intuit         |   59.95 |

Entity B:
| title                      | manufacturer   |   price |
|:---------------------------|:---------------|--------:|
| quickbooks pro 2007 3 user | intuit         |  398.99 |



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

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

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

Entity A:
| title                            | manufacturer         |   price |
|:---------------------------------|:---------------------|--------:|
| middle school success essentials | topics entertainment |   29.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 734
rtable_id: 2060
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 playtime for baby & toddler |                |     9.9 |



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

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

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

Entity A:
| title         | manufacturer   |   price |
|:--------------|:---------------|--------:|
| sims complete | aspyr media    |   49.99 |

Entity B:
| title                              | manufacturer   |   price |
|:-----------------------------------|:---------------|--------:|
| aspyr the sims complete collection |                |   47.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 700
rtable_id: 412
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 |   59.99 |

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



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

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

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

Entity A:
| title          | manufacturer                     |   price |
|:---------------|:---------------------------------|--------:|
| vegas 6 for pc | sony-pictures-home-entertainment |  599.99 |

Entity B:
| title                  | manufacturer   |   price |
|:-----------------------|:---------------|--------:|
| shrek the third for pc |                |   19.99 |



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

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

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

Entity A:
| title                                             | manufacturer   |   price |
|:--------------------------------------------------|:---------------|--------:|
| adobe creative suite cs3 master collection upsell | adobe          |    1999 |

Entity B:
| title                                                                      | manufacturer   |   price |
|:---------------------------------------------------------------------------|:---------------|--------:|
| adobe production premium cs3 software suite for mac av production software |                | 1698.95 |



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

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

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

Entity A:
| title                                                | manufacturer      |   price |
|:-----------------------------------------------------|:------------------|--------:|
| computrace lojack for laptops 1 year license ( mac ) | absolute software |   49.95 |

Entity B:
| title                                           | manufacturer   |   price |
|:------------------------------------------------|:---------------|--------:|
| computrace lojack for laptops 3 yr subscription |                |   89.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 975
rtable_id: 461
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 software pxl smartscale windows and macintosh ) | onone software |         |

Entity B:
| title                                                                               | manufacturer   |   price |
|:------------------------------------------------------------------------------------|:---------------|--------:|
| phase one capture-one pro dslr raw image editing software for macintosh & windows . |                |  399.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1182
rtable_id: 2608
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 |
|:---------------------------|:-------------------|--------:|
| space ( dvd ) ( pc & mac ) | fogware publishing |   29.99 |

Entity B:
| title                                                    | manufacturer   |   price |
|:---------------------------------------------------------|:---------------|--------:|
| starry night galaxy explorer ( pc & mac ) ( snge-5-c1u ) |                |    9.59 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1204
rtable_id: 3127
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 contribute cs3 [ mac ] | adobe          |     149 |

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



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

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

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

Entity A:
| title                                     | manufacturer   |   price |
|:------------------------------------------|:---------------|--------:|
| peachtree by sage premium accounting 2007 | sage software  |  499.99 |

Entity B:
| title                                                                                                         | manufacturer   |   price |
|:--------------------------------------------------------------------------------------------------------------|:---------------|--------:|
| peachtree software vernfp2008rt sage peachtree premium accounting 2008 for nonprofits financial management pc |                |  540.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1242
rtable_id: 787
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 ( r ) excel 2007 |                |  109.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 497
rtable_id: 1075
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 ( r ) frontpage 2002 |                |  169.56 |



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

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

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

Entity A:
| title                                | manufacturer    |   price |
|:-------------------------------------|:----------------|--------:|
| registry mechanic by encore software | encore software |   46.52 |

Entity B:
| title                                                   | manufacturer   |   price |
|:--------------------------------------------------------|:---------------|--------:|
| encore software 10463 clickart fonts ( 2006 ) by encore |                |   17.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 944
rtable_id: 2550
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 indesign cs3 for mac upgrade |                |  205.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 588
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   |
|:-------------------------------|:---------------------|:--------|
| instant immersion german audio | topics entertainment |         |

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



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

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

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

Entity A:
| title                      | manufacturer        |   price |
|:---------------------------|:--------------------|--------:|
| systemsuite 8 professional | individual software |   49.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1293
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 |
|:----------------------------------------------------|:---------------|--------:|
| adobe creative suite cs3 production premium upgrade | adobe          |     799 |

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



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

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



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

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

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

Entity A:
| title                                 | manufacturer   |   price |
|:--------------------------------------|:---------------|--------:|
| mavis beacon teaches typing deluxe 16 | broderbund     |   39.99 |

Entity B:
| title                                           | manufacturer   |   price |
|:------------------------------------------------|:---------------|--------:|
| broderbund mavis beacon teaches typing deluxe17 |                |   36.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 610
rtable_id: 277
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 word 2004 |                |  209.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 823
rtable_id: 998
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 |
|:------------------------------|:---------------|--------:|
| atari arcade classics ( mac ) | macsoft        |   19.99 |

Entity B:
| title                                                                    | manufacturer   |   price |
|:-------------------------------------------------------------------------|:---------------|--------:|
| destineer inc 10316 destineer atari arcade classics action/adventure mac |                |   17.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 101
rtable_id: 1670
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   |
|:----------------------------------------------|:---------------------|:--------|
| instant immersion language lab deluxe edition | topics entertainment |         |

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



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

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

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

Entity A:
| title                                     | manufacturer         |   price |
|:------------------------------------------|:---------------------|--------:|
| cross stitch design studio ( jewel case ) | m-and-r-technologies |    9.99 |

Entity B:
| title                                          | manufacturer   |   price |
|:-----------------------------------------------|:---------------|--------:|
| stationery design studio ( win 98 me 2000 xp ) |                |   19.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 325
rtable_id: 2619
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 |
|:--------------------------|:----------------|--------:|
| avid liquid vs 7 software | avid technology |  888.75 |

Entity B:
| title                     | manufacturer   |   price |
|:--------------------------|:---------------|--------:|
| nikon capture nx software |                |  149.99 |



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

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

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

Entity A:
| title                                                 | manufacturer   |   price |
|:------------------------------------------------------|:---------------|--------:|
| adobe creative suite cs3 web standard upgrade [ mac ] | adobe          |     399 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 465
rtable_id: 954
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 2.0 | adobe          |     849 |

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



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

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

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

Entity A:
| title                        | manufacturer   |   price |
|:-----------------------------|:---------------|--------:|
| microsoft data analyzer 2002 | microsoft      |     179 |

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



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

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

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

Entity A:
| title                                              | manufacturer   |   price |
|:---------------------------------------------------|:---------------|--------:|
| adobe creative suite cs3 production premium upsell | adobe          |    1199 |

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



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

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

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

Entity A:
| title                       | manufacturer   |   price |
|:----------------------------|:---------------|--------:|
| adobe premiere elements 3.0 | adobe          |  161.73 |

Entity B:
| title                                                       | manufacturer   |   price |
|:------------------------------------------------------------|:---------------|--------:|
| adobe photoshop elements 4.0 photo-editing software for mac |                |   85.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 484
rtable_id: 750
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 word 2004 |                |  209.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 606
rtable_id: 998
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 |
|:------------------------------------|:---------------------|--------:|
| snap ! 1 001 letters ( jewel case ) | topics entertainment |   19.95 |

Entity B:
| title                                           | manufacturer   |   price |
|:------------------------------------------------|:---------------|--------:|
| total 3d home deluxe ( jewel case ) ( jce-th6 ) |                |    9.59 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 278
rtable_id: 3108
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 ( r ) project 2002 |                |  329.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 781
rtable_id: 3204
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 server 2003 client additional license for devices 5 pack | microsoft      |     209 |

Entity B:
| title                                                                          | manufacturer   |   price |
|:-------------------------------------------------------------------------------|:---------------|--------:|
| dja-00892 microsoft system center essentials 2007 license 1 server win english |                |   93.25 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 431
rtable_id: 77
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 |
|:---------------------------------------------------------------------------------|:---------------|--------:|
| 4px-00078 microsoft system center essentials 2007 license 20 clients win english |                |  379.43 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 662
rtable_id: 1720
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 entertainment pack ce | microsoft      |    49.5 |

Entity B:
| title                     | manufacturer   |   price |
|:--------------------------|:---------------|--------:|
| microsoft ( r ) word 2007 |                |  109.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 211
rtable_id: 3091
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 |
|:------------------------------------------------------|:----------------|--------:|
| family tree maker version 16 collectors edition sb cs | encore software |   99.99 |

Entity B:
| title                                                                       | manufacturer   |   price |
|:----------------------------------------------------------------------------|:---------------|--------:|
| encore software 10861 family tree maker version 16 collectors edition sb cs |                |   81.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1074
rtable_id: 2095
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   |
|:-------------------------------------------------------|:---------------|:--------|
| riverdeep adventure workshop 4th-6th grade 8th edition | riverdeep      |         |

Entity B:
| title                                                      | manufacturer   |   price |
|:-----------------------------------------------------------|:---------------|--------:|
| knowledge adventure inc. jumpstart 4th-6th grade v 2.0 b43 |                |   16.93 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 820
rtable_id: 703
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 garageband jam pack : symphony orchestra | apple          |      99 |

Entity B:
| title                                           | manufacturer   |   price |
|:------------------------------------------------|:---------------|--------:|
| garageband jampack rhythm section ( mac ) apple |                |   99.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 566
rtable_id: 2799
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 |
|:--------------------------------------|:---------------|--------:|
| project x project management software | marware        |  199.95 |

Entity B:
| title                           | manufacturer   |   price |
|:--------------------------------|:---------------|--------:|
| essential software architecture |                |   53.41 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 751
rtable_id: 2707
label: 0