MMTU-benchmark/MMTU huggingface dataset:
Task: Entity-Matching (source dataset: Amazon-Google)

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

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

Entity A:
| title                                                                                                                            | manufacturer      | price   |
|:---------------------------------------------------------------------------------------------------------------------------------|:------------------|:--------|
| adobe 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 photoshop cs3 extended complete package 1 user academic cd windows |                |     279 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 157
rtable_id: 1151
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 production premium cs3 software suite for mac av production software |                | 1698.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 736
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 |
|:---------------------------------------------------------|:---------------|--------:|
| adobe creative suite cs3 design standard upgrade [ mac ] | adobe          |     399 |

Entity B:
| title                                                                           | manufacturer   |   price |
|:--------------------------------------------------------------------------------|:---------------|--------:|
| 29270055 adobe creative suite 3 web standard complete package 1 user cd win uni |                | 1056.98 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 602
rtable_id: 71
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 |
|:-------------------------------|:--------------------|--------:|
| professor teaches excel & word | individual software |   19.99 |

Entity B:
| title                                                     | manufacturer        |   price |
|:----------------------------------------------------------|:--------------------|--------:|
| individual software jce-wn5 professor teaches windows j/c | individual software |    9.99 |



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

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

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

Entity A:
| title                     | manufacturer   |   price |
|:--------------------------|:---------------|--------:|
| steinberg cubase studio 4 | steinberg      |  499.99 |

Entity B:
| title                                                                        | manufacturer   |   price |
|:-----------------------------------------------------------------------------|:---------------|--------:|
| steinberg cubase 4 software competitive crossgrade music production software |                |  399.99 |



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

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

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

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

Entity B:
| title                                                                 | manufacturer   |   price |
|:----------------------------------------------------------------------|:---------------|--------:|
| adobe production studio premium software suite video software bundles |                | 1698.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 565
rtable_id: 2193
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 |
|:-----------------------------------|:---------------|--------:|
| acrobat professional 8 ( windows ) | adobe          |     273 |

Entity B:
| title                                    | manufacturer   |   price |
|:-----------------------------------------|:---------------|--------:|
| adobe acrobat v8 .0 professional for mac |                |  405.99 |



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

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

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

Entity A:
| title                           | manufacturer            |   price |
|:--------------------------------|:------------------------|--------:|
| sibelius 4 professional edition | sibelius-software-ltd . |  599.99 |

Entity B:
| title                                       | manufacturer   |   price |
|:--------------------------------------------|:---------------|--------:|
| sibelius sibelius photoscore professional 4 |                |   145.7 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1148
rtable_id: 312
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 |
|:-------------------|:---------------|--------:|
| the sims 2 ( mac ) | aspyr media    |   49.99 |

Entity B:
| title            | manufacturer   |   price |
|:-----------------|:---------------|--------:|
| aspyr the sims 2 |                |   45.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1090
rtable_id: 973
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 |
|:------------------------------------------------------|:---------------|--------:|
| quickbooks premier professional services edition 2007 | intuit         |  399.95 |

Entity B:
| title                                                                           | manufacturer   |   price |
|:--------------------------------------------------------------------------------|:---------------|--------:|
| 299530 quickbooks premier nonprofit edition 2007 complete package 1 user cd win |                |  344.58 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 586
rtable_id: 1823
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 after effects professional 7.0 software effects software |                |  998.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 270
rtable_id: 2177
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 |
|:---------------------------|:-----------------|--------:|
| photo explosion deluxe 3.0 | nova development |   49.99 |

Entity B:
| title                            | manufacturer   |   price |
|:---------------------------------|:---------------|--------:|
| print explosion deluxe 3.0 : mac |                |   49.99 |



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

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

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

Entity A:
| title                           | manufacturer            |   price |
|:--------------------------------|:------------------------|--------:|
| sibelius 5 professional edition | sibelius-software-ltd . |     599 |

Entity B:
| title                          | manufacturer   |   price |
|:-------------------------------|:---------------|--------:|
| system mechanic 6 professional |                |    36.9 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 287
rtable_id: 2141
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 v2 .0 ( pc & mac ) | topics entertainment |   29.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 678
rtable_id: 260
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 premium upsell | adobe          |    1599 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1322
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 |
|:--------------------------------|:---------------|--------:|
| adobe after effects cs3 upgrade | adobe          |     299 |

Entity B:
| title                                                                  | manufacturer   |   price |
|:-----------------------------------------------------------------------|:---------------|--------:|
| adobe after effects cs3 professional software for mac effects software |                |  998.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 592
rtable_id: 2377
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 |
|:-----------------------------------------------------------------------------------------------------------------------------------|:-------------------|--------:|
| palo alto software mpd9 palo alto marketing plan v. 9.0 pro complete product business planning 1 user complete product standard pc | palo-alto-software |  149.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 875
rtable_id: 1031
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 |
|:-----------------------------------------|:------------------------------------------------|--------:|
| learn2 training for microsoft powerpoint | topics-entertainment-software - ( consignment ) |    9.99 |

Entity B:
| title                                                                | manufacturer                                    |   price |
|:---------------------------------------------------------------------|:------------------------------------------------|--------:|
| learn2 training for microsoft powerpoint ( win 95 98 me nt 2000 xp ) | topics-entertainment-software - ( consignment ) |    9.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 186
rtable_id: 1518
label: 1
Task: Entity-Matching (source dataset: Amazon-Google)

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

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

Entity A:
| title                         | manufacturer   |   price |
|:------------------------------|:---------------|--------:|
| adobe illustrator cs3 [ mac ] | adobe          |     599 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 772
rtable_id: 923
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 |
|:-------------------------------------|:---------------|--------:|
| mia 's math adventure : just in time | kutoka         |   19.99 |

Entity B:
| title                                                           | manufacturer       |   price |
|:----------------------------------------------------------------|:-------------------|--------:|
| kutoka interactive 61208 mia 's math adventure : just in time ! | kutoka interactive |   24.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 8
rtable_id: 1936
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 outlook 2007 | microsoft      |  109.95 |

Entity B:
| title                         | manufacturer   |   price |
|:------------------------------|:---------------|--------:|
| microsoft office outlook 2007 |                |  109.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 547
rtable_id: 2877
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 |
|:------------------------------------------------------|:---------------|--------:|
| quickbooks pro 2007 small business financial software | intuit         |  199.95 |

Entity B:
| title                     | manufacturer   |   price |
|:--------------------------|:---------------|--------:|
| quickbooks ( r ) pro 2003 |                |  299.77 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 548
rtable_id: 3080
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 |
|:-------------------------------------------------------------|:---------------|--------:|
| timbuktu remote control softwre 2 licenses for windows & mac | netopia        |  199.99 |

Entity B:
| title                                                      | manufacturer      |   price |
|:-----------------------------------------------------------|:------------------|--------:|
| now software nuw45e1k now up-to-date & contact for windows | power-on-software |  114.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 624
rtable_id: 2224
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 users-5 pack | microsoft      |     809 |

Entity B:
| title                                                                                 | manufacturer   |   price |
|:--------------------------------------------------------------------------------------|:---------------|--------:|
| microsoft windows server 2003 client additional license for devices 5 pack ( 823930 ) |                |  158.39 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 531
rtable_id: 3109
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 essential bass guitar | emedia         |   19.95 |

Entity B:
| title                       | manufacturer   |   price |
|:----------------------------|:---------------|--------:|
| emedia music corp my guitar |                |   24.81 |



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

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

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

Entity A:
| title                                              | manufacturer       |   price |
|:---------------------------------------------------|:-------------------|--------:|
| microsoft windows xp professional upgrade with sp2 | microsoft software |  199.99 |

Entity B:
| title                                             | manufacturer   |   price |
|:--------------------------------------------------|:---------------|--------:|
| microsoft ( r ) windows vista ( tm ) home premium |                |  239.99 |



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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 465
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 |
|:---------------------------|:---------------|--------:|
| final draft av 2.5 win/mac | final draft    |  199.99 |

Entity B:
| title                                                                                 | manufacturer   |   price |
|:--------------------------------------------------------------------------------------|:---------------|--------:|
| final-draft final draft av 2.5 screenwriting software mac/win screen writing software |                |  199.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1030
rtable_id: 2320
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 33 languages | topics entertainment |   49.99 |

Entity B:
| title                        | manufacturer   |   price |
|:-----------------------------|:---------------|--------:|
| instant landscape design 3.0 |                |    17.9 |



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

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

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

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

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



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

Entity B:
| title                                                                                   | manufacturer   |   price |
|:----------------------------------------------------------------------------------------|:---------------|--------:|
| intuit quickbooks simple start edition 2007 software for windows tax & finance software |                |   83.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 520
rtable_id: 2301
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 |
|:-----------------------------|:---------------|--------:|
| cell phone software solution | susteen        |   113.1 |

Entity B:
| title                             | manufacturer   |   price |
|:----------------------------------|:---------------|--------:|
| onone software plug-in suite full |                |  393.68 |



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

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

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

Entity A:
| title                                    | manufacturer   |   price |
|:-----------------------------------------|:---------------|--------:|
| microsoft publisher 2007 version upgrade | microsoft      |   99.95 |

Entity B:
| title                               | manufacturer   |   price |
|:------------------------------------|:---------------|--------:|
| microsoft money 2007 premium ( pc ) |                |   79.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 511
rtable_id: 2863
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 cs3 web standard academic |                |  389.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 465
rtable_id: 977
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 deluxe 2.0 | topics entertainment |   39.99 |

Entity B:
| title                                         | manufacturer   |   price |
|:----------------------------------------------|:---------------|--------:|
| instant immersion language lab deluxe edition |                |    14.9 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 554
rtable_id: 2062
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   |
|:-----------------------------------------------------|:---------------|:--------|
| upgrade emc retrospect 7.5 multi server windows only | dantz          |         |

Entity B:
| title                                              | manufacturer   |   price |
|:---------------------------------------------------|:---------------|--------:|
| emc insignia retrospect server 6.0 for mac upgrade |                |  285.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 132
rtable_id: 582
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 cs3 design premium |                | 1865.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 897
rtable_id: 521
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 home massage dvd | selectmedia entertainment |   19.95 |

Entity B:
| title                 | manufacturer   |   price |
|:----------------------|:---------------|--------:|
| easy home massage dvd |                |   10.95 |



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

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

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

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

Entity B:
| title                                                                               | manufacturer   |   price |
|:------------------------------------------------------------------------------------|:---------------|--------:|
| 29270077 adobe creative suite 3 web standard product upgrade package 1 user upgrade |                |  843.15 |



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

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

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

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

Entity B:
| title                                                 | manufacturer   |   price |
|:------------------------------------------------------|:---------------|--------:|
| steinberg cubase 4 software music production software |                |  799.99 |



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

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

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

Entity A:
| title                  | manufacturer                        |   price |
|:-----------------------|:------------------------------------|--------:|
| sony acid music studio | sony-pictures-digital-entertainment |   69.99 |

Entity B:
| title                                                             | manufacturer                        |   price |
|:------------------------------------------------------------------|:------------------------------------|--------:|
| sony media software acid pro 6 software music production software | sony-pictures-digital-entertainment |  299.95 |



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

Entity B:
| title                                                         | manufacturer   |   price |
|:--------------------------------------------------------------|:---------------|--------:|
| encore inc adventure workshop preschool-1st grade 8th edition |                |    17.1 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 820
rtable_id: 185
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 indesign cs3 for mac academic |                |  192.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1262
rtable_id: 984
label: 0