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 |
|:--------------------------------------------|:-----------------|--------:|
| punch ! home design architectural series 18 | punch ! software |  129.99 |

Entity B:
| title                                                                                            | manufacturer   |   price |
|:-------------------------------------------------------------------------------------------------|:---------------|--------:|
| punch software 83100 punch ! home design architectural series 3000 v 10 ( win 98 me nt 2000 xp ) |                |  124.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1272
rtable_id: 1028
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 |
|:-----------------------------------------------------------------------------|:---------------|--------:|
| symantec client security 3.1 with groupware protection business pack 50 user | symantec       |    3732 |

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



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

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

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

Entity A:
| title                                        | manufacturer   |   price |
|:---------------------------------------------|:---------------|--------:|
| adobe after effects 7.0 professional ( mac ) | adobe          |     999 |

Entity B:
| title                           | manufacturer   |   price |
|:--------------------------------|:---------------|--------:|
| adobe cs3 after effects upgrade |                |  306.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 333
rtable_id: 257
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 oem 3pk xp home edition sp2 n09-01624 ) | microsoft corporation |         |

Entity B:
| title                               | manufacturer   |   price |
|:------------------------------------|:---------------|--------:|
| microsoft windows xp pro sp2 retail |                |  299.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 888
rtable_id: 273
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 |
|:-----------------------------------------------------|:---------------|--------:|
| digidesign music production toolkit ( pro tools le ) | digidesign     |     495 |

Entity B:
| title                                             | manufacturer   |   price |
|:--------------------------------------------------|:---------------|--------:|
| bias peak le 5 software music production software |                |      99 |



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

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

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

Entity A:
| title                                        | manufacturer   |   price |
|:---------------------------------------------|:---------------|--------:|
| adobe photoshop cs3 extended upgrade [ mac ] | adobe          |     349 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 837
rtable_id: 368
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 nuendo 3 digital audio software | steinberg      |    2499 |

Entity B:
| title                                                                       | manufacturer                 |   price |
|:----------------------------------------------------------------------------|:-----------------------------|--------:|
| steinberg wavelab studio 6 audio editing software music production software | steinberg-media-technologies |  299.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 722
rtable_id: 2198
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 |
|:-------------------------------|:---------------|--------:|
| adobe cs3 web standard upgrade |                |  413.99 |



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

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

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

Entity A:
| title                                              | manufacturer   |   price |
|:---------------------------------------------------|:---------------|--------:|
| logic pro 6 upgrade from logic platinum/gold 5 & 6 | apple          |  199.99 |

Entity B:
| title                                     | manufacturer                |   price |
|:------------------------------------------|:----------------------------|--------:|
| apple logic express 7.2 upgrade from v. 6 | apple-computer - ( direct ) |   99.99 |



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

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

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

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

Entity B:
| title                                                                   | manufacturer   |   price |
|:------------------------------------------------------------------------|:---------------|--------:|
| punch software 14100 punch ! professional home design suite for windows | punch software |   62.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1269
rtable_id: 1083
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 |
|:---------------------------------------------------|:---------------|--------:|
| logic pro 6 upgrade from logic platinum/gold 5 & 6 | apple          |  199.99 |

Entity B:
| title                                                                                     | manufacturer                        |   price |
|:------------------------------------------------------------------------------------------|:------------------------------------|--------:|
| sony media software acid pro 6 software upgrade from acid pro 5 music production software | sony-pictures-digital-entertainment |  129.95 |



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

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

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

Entity A:
| title                                        | manufacturer         |   price |
|:---------------------------------------------|:---------------------|--------:|
| i spy fantasy v. 2 with i spy book & mini cd | topics entertainment |   29.99 |

Entity B:
| title                                           | manufacturer   |   price |
|:------------------------------------------------|:---------------|--------:|
| i spy treasure hunt with i spy book and mini-cd |                |    17.9 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 989
rtable_id: 2151
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 : world music | apple          |      99 |

Entity B:
| title                                   | manufacturer   |   price |
|:----------------------------------------|:---------------|--------:|
| apple garageband jam pack : remix tools |                |   95.99 |



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

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

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

Entity A:
| title                                                                    | manufacturer       |   price |
|:-------------------------------------------------------------------------|:-------------------|--------:|
| microsoft crm professional cal 3.0 product upgrade license pack user cal | microsoft software |    9980 |

Entity B:
| title                                                                                | manufacturer   |   price |
|:-------------------------------------------------------------------------------------|:---------------|--------:|
| fl37-p-k2 = cisco ios ipsec 3des product upgrade license upgrade from cisco ios plus |                |  1488.8 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 135
rtable_id: 1922
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 |
|:----------------|:---------------|--------:|
| transfer my dvd | avanquest      |   29.95 |

Entity B:
| title                         | manufacturer   |   price |
|:------------------------------|:---------------|--------:|
| transfer my dvd avanquest usa |                |   29.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 334
rtable_id: 3031
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 2004 std upgrade |                |  219.99 |



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

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

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

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

Entity B:
| title                 | manufacturer   |   price |
|:----------------------|:---------------|--------:|
| adobe dreamweaver cs3 |                |  415.99 |



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

Entity B:
| title                                                                                                          | manufacturer   |   price |
|:---------------------------------------------------------------------------------------------------------------|:---------------|--------:|
| adobe premiere pro cs3 software with encore cs3 and onlocation cs3 ( windows only ) full version for macintosh |                |  723.95 |



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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 930
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 |
|:------------------------------------------------------|:----------------------------------|--------:|
| hp dss software v. 4.0 complete package t1936aa ua0 ) | hewlett-packard - ( consumables ) |  630.36 |

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



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

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

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

Entity A:
| title                           | manufacturer   |   price |
|:--------------------------------|:---------------|--------:|
| adobe after effects cs3 upgrade | adobe          |     299 |

Entity B:
| title                                       | manufacturer   |   price |
|:--------------------------------------------|:---------------|--------:|
| adobe cs3 master collection upsell from cs1 |                | 2054.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 592
rtable_id: 950
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 & windows training | topics entertainment |   29.99 |

Entity B:
| title                                     | manufacturer   |   price |
|:------------------------------------------|:---------------|--------:|
| microsoft windows xp home edition sp2 oem |                |   95.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 348
rtable_id: 375
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 |
|:--------------------------------------|:--------------------------|--------:|
| video patrol 5.0 by honest technology | global-marketing-partners |   50.86 |

Entity B:
| title                                                             | manufacturer              |   price |
|:------------------------------------------------------------------|:--------------------------|--------:|
| global marketing partners easy video editor 2.0 honest technology | global-marketing-partners |   25.21 |



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

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

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

Entity A:
| title                  | manufacturer   |   price |
|:-----------------------|:---------------|--------:|
| microsoft onenote 2007 | microsoft      |   99.95 |

Entity B:
| title                                | manufacturer   |   price |
|:-------------------------------------|:---------------|--------:|
| microsoft ( r ) office standard 2007 |                |  399.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 541
rtable_id: 1010
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 basic | intuit         |   29.95 |

Entity B:
| title                   | manufacturer   |   price |
|:------------------------|:---------------|--------:|
| quickbooks pro 2007 win |                |  192.26 |



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

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

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

Entity A:
| title                                                  | manufacturer       |   price |
|:-------------------------------------------------------|:-------------------|--------:|
| microsoft licenses word mac 10.0 eng govt ( d4800369 ) | microsoft licenses |  349.83 |

Entity B:
| title                                                 | manufacturer   |   price |
|:------------------------------------------------------|:---------------|--------:|
| microsoft ( r ) office word 2004 for mac full version |                |  231.29 |



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

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

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

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

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



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

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

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

Entity A:
| title                          | manufacturer   | price   |
|:-------------------------------|:---------------|:--------|
| cubase se3 educational edition | steinberg      |         |

Entity B:
| title                                                                      | manufacturer   |   price |
|:---------------------------------------------------------------------------|:---------------|--------:|
| steinberg cubase 4 software educational discount music production software |                |  349.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 863
rtable_id: 2392
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 |
|:----------------------------------------------|:---------------|--------:|
| zero-g pro pack for garageband ( appleloops ) | zero-g         |  169.95 |

Entity B:
| title                                   | manufacturer   |   price |
|:----------------------------------------|:---------------|--------:|
| apple garageband jam pack : remix tools |                |   95.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 797
rtable_id: 457
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   |
|:-----------------------------------------|:---------------|:--------|
| autodesk discreet combustion 4 windows ) | autodesk       |         |

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



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

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

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

Entity A:
| title                                         | manufacturer   |   price |
|:----------------------------------------------|:---------------|--------:|
| microsoft visio standard 2007 version upgrade | microsoft      |  129.95 |

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



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

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

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

Entity A:
| title                    | manufacturer     |   price |
|:-------------------------|:-----------------|--------:|
| punch ! super home suite | punch ! software |   49.99 |

Entity B:
| title                                                                     | manufacturer   |   price |
|:--------------------------------------------------------------------------|:---------------|--------:|
| punch software 35100 punch ! professional home design suite ( small box ) | punch software |   62.99 |



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

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

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

Entity A:
| title                                                                               | manufacturer   |   price |
|:------------------------------------------------------------------------------------|:---------------|--------:|
| microsoft visual studio team edition for software developers 2005 with msdn premium | microsoft      |    5479 |

Entity B:
| title                                                           | manufacturer   |   price |
|:----------------------------------------------------------------|:---------------|--------:|
| microsoft ( r ) office 2004 for mac student and teacher edition |                |  146.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 244
rtable_id: 1163
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 |
|:-----------------------|:-------------------------|--------:|
| 3 great games for guys | dreamcatcher interactive |   29.99 |

Entity B:
| title                             | manufacturer   |   price |
|:----------------------------------|:---------------|--------:|
| ultimate games for girls 3 for pc |                |   19.99 |



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

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

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

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

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



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

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

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

Entity A:
| title                                        | manufacturer   |   price |
|:---------------------------------------------|:---------------|--------:|
| adobe after effects 7.0 professional ( mac ) | adobe          |     999 |

Entity B:
| title                                                                    | manufacturer   |   price |
|:-------------------------------------------------------------------------|:---------------|--------:|
| adobe after effects professional 7 software for windows effects software |                |     999 |



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

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

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

Entity A:
| title                                        | manufacturer         |   price |
|:---------------------------------------------|:---------------------|--------:|
| i spy fantasy v. 2 with i spy book & mini cd | topics entertainment |   29.99 |

Entity B:
| title                                                     | manufacturer   |   price |
|:----------------------------------------------------------|:---------------|--------:|
| topics entertainment i spy fantasy w / i spy bk & mini cd |                |   17.55 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 989
rtable_id: 822
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 after effects cs3 | adobe          |     999 |

Entity B:
| title                | manufacturer   |   price |
|:---------------------|:---------------|--------:|
| adobe soundbooth cs3 |                |  205.99 |



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

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

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

Entity A:
| title                                 | manufacturer     |   price |
|:--------------------------------------|:-----------------|--------:|
| webroot spysweeper antispyware 3 user | webroot software |   39.99 |

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



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

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

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

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

Entity B:
| title                                                                               | manufacturer   |   price |
|:------------------------------------------------------------------------------------|:---------------|--------:|
| 19500220 adobe creative suite 3 design premium product upgrade package 1 user upgra |                | 1687.48 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 350
rtable_id: 99
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 |
|:-------------------------|:---------------|--------:|
| system care professional | avanquest      |   49.95 |

Entity B:
| title                                                         | manufacturer   |   price |
|:--------------------------------------------------------------|:---------------|--------:|
| individual software inc systemsuite 8 professional ( us pos ) |                |   46.42 |



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

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

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

Entity A:
| title                                | manufacturer         |   price |
|:-------------------------------------|:---------------------|--------:|
| instant immersion italian deluxe 2.0 | topics entertainment |   49.99 |

Entity B:
| title                          | manufacturer   |   price |
|:-------------------------------|:---------------|--------:|
| instant immersion 33 languages |                |   47.36 |



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

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

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

Entity A:
| title                                                        | manufacturer   |   price |
|:-------------------------------------------------------------|:---------------|--------:|
| onone essentials for adobe photoshop elements version 2 full | onone software |   59.95 |

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



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

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

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

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

Entity B:
| title                                                                             | manufacturer   |   price |
|:----------------------------------------------------------------------------------|:---------------|--------:|
| intuit quicken home and business 2007 software for windows tax & finance software |                |   89.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1308
rtable_id: 2146
label: 0