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 |
|:---------------------------------------------|:----------------|--------:|
| adventure workshop 4th-6th grade 7th edition | encore software |   19.99 |

Entity B:
| title                                              | manufacturer   |   price |
|:---------------------------------------------------|:---------------|--------:|
| encore software 12431 adventure workshop 8 4th-6th |                |   17.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1080
rtable_id: 2026
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 |
|:------------------------------------------|:---------------|--------:|
| hoyle texas hold 'em poker ( jewel case ) | encore         |    9.99 |

Entity B:
| title                                                        | manufacturer   |   price |
|:-------------------------------------------------------------|:---------------|--------:|
| eagle games egl 150 tournament poker no limit texas hold 'em | eagle games    |    7.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 805
rtable_id: 1637
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 [ mac ] | adobe          |     999 |

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: 1186
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 |
|:--------------------------------------|:---------------|--------:|
| peachtree by sage pro accounting 2007 | sage software  |  169.99 |

Entity B:
| title                                                              | manufacturer   |   price |
|:-------------------------------------------------------------------|:---------------|--------:|
| sage ( ptree ) vernfp2007rt premium accounting for nonprofits 2007 |                |  590.35 |



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

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

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

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

Entity B:
| title                                                       | manufacturer   |   price |
|:------------------------------------------------------------|:---------------|--------:|
| microsoft windows vista business retail no open box returns |                |  299.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 584
rtable_id: 959
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 photoshop elements 5.0 / premier elements 3.0 [ lb ] | adobe          |  149.99 |

Entity B:
| title                                | manufacturer   |   price |
|:-------------------------------------|:---------------|--------:|
| adobe photoshop cs3 extended for mac |                |  935.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 267
rtable_id: 263
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 logic pro 7.2 upgrade | apple          |     299 |

Entity B:
| title                   | manufacturer   |   price |
|:------------------------|:---------------|--------:|
| apple logic express 7.2 |                |  299.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 950
rtable_id: 994
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 software 10590 adventure workshop preschool 1st grade 7th ed sb cs by riverdeep |                |   17.97 |



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

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

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

Entity A:
| title                                              | manufacturer   |   price |
|:---------------------------------------------------|:---------------|--------:|
| adobe creative suite cs3 master collection [ mac ] | adobe          |    2499 |

Entity B:
| title                                                                | manufacturer   |   price |
|:---------------------------------------------------------------------|:---------------|--------:|
| adobe creative suite 3 web standard complete package academic cd mac |                |     369 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 803
rtable_id: 3188
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 mappoint 2006 standard edition | microsoft      |     299 |

Entity B:
| title                             | manufacturer   |   price |
|:----------------------------------|:---------------|--------:|
| microsoft office 2004 std upgrade |                |  219.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 146
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   |
|:--------------------------------------------------------------------|:---------------|:--------|
| netmanage rumba unix-hp edition v. 7.3 upgrade license 902453-006 ) | netmanage      |         |

Entity B:
| title                                                                              | manufacturer   |   price |
|:-----------------------------------------------------------------------------------|:---------------|--------:|
| 902453-007-e rumba unix-hp edition upgrade license 1 user volume level e 1000-1999 |                |  106.48 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 137
rtable_id: 1717
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   |
|:------------------------------------------------|:---------------------------|:--------|
| cisco security desktop agent csa-b250-dtop-k9 ) | cisco systems ( ciscopro ) |         |

Entity B:
| title                                                                | manufacturer             |   price |
|:---------------------------------------------------------------------|:-------------------------|--------:|
| cisco security server agent ( windows and solaris ) 100-agent bundle | cisco-systems-enterprise | 64821.4 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 470
rtable_id: 1980
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 |
|:------------------------------------|:---------------|--------:|
| call of duty deluxe ( mac ) ( dvd ) | aspyr media    |   39.99 |

Entity B:
| title                    | manufacturer   |   price |
|:-------------------------|:---------------|--------:|
| aspyr call of duty 2 mac |                |   47.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 713
rtable_id: 978
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 acrobat 7.0 standard academic mac |                |   98.99 |



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

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

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

Entity A:
| title                       | manufacturer   |   price |
|:----------------------------|:---------------|--------:|
| microsoft office excel 2007 | microsoft      |  229.95 |

Entity B:
| title                                         | manufacturer   |   price |
|:----------------------------------------------|:---------------|--------:|
| microsoft ( r ) powerpoint ( r ) 2002 upgrade |                |  108.87 |



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

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

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

Entity A:
| title                                              | manufacturer   |   price |
|:---------------------------------------------------|:---------------|--------:|
| microsoft virtual pc for mac 7.0 with windows 2000 | microsoft      |  249.99 |

Entity B:
| title                                    | manufacturer   |   price |
|:-----------------------------------------|:---------------|--------:|
| microsoft windows vista ultimate upgrade |                |  239.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 145
rtable_id: 2441
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 pro 2007 for mac ( mac ) | intuit         |  199.95 |

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



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

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

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

Entity A:
| title                                | manufacturer       |   price |
|:-------------------------------------|:-------------------|--------:|
| microsoft office small business 2007 | microsoft software |  735.33 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 271
rtable_id: 2837
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 |
|:----------------------------------------------|:-----------------------|--------:|
| world of warcraft expansion : burning crusade | blizzard entertainment |   39.99 |

Entity B:
| title                              | manufacturer   |   price |
|:-----------------------------------|:---------------|--------:|
| vivendi blizzard world of warcraft |                |   24.99 |



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

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

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

Entity A:
| title                  | manufacturer   |   price |
|:-----------------------|:---------------|--------:|
| adobe premiere pro cs3 | adobe          |     799 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 892
rtable_id: 960
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 web premium academic |                |  479.99 |



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

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

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

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

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



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

Entity B:
| title                             | manufacturer   |   price |
|:----------------------------------|:---------------|--------:|
| microsoft office 2004 std upgrade |                |  219.99 |



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

Entity B:
| title                                                                                   | manufacturer   |   price |
|:----------------------------------------------------------------------------------------|:---------------|--------:|
| sage software peachtree pro accounting 2007 software for windows tax & finance software |                |  159.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 548
rtable_id: 1068
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 upsell |                |  819.99 |



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

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

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

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

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



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

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

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

Entity A:
| title                           | manufacturer   |   price |
|:--------------------------------|:---------------|--------:|
| make music finale 2008 academic | emedia         |     350 |

Entity B:
| title                                                  | manufacturer   |   price |
|:-------------------------------------------------------|:---------------|--------:|
| make finale allegro software music production software |                |  164.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 960
rtable_id: 2325
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 ! professional home design suite | punch ! software |   69.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1264
rtable_id: 1433
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 |
|:----------------------|:---------------|--------:|
| spycatcher 2007for pc | avanquest      |   19.99 |

Entity B:
| title                             | manufacturer   |   price |
|:----------------------------------|:---------------|--------:|
| avanquest usa llc spycatcher 2007 |                |    17.5 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1307
rtable_id: 716
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 upgrade | adobe          |     399 |

Entity B:
| title                                                    | manufacturer   |   price |
|:---------------------------------------------------------|:---------------|--------:|
| total training for adobe creative suite 3 design premium |                |  279.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 615
rtable_id: 1612
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 |
|:----------------------|:------------------|--------:|
| ford racing 2 ( mac ) | feral interactive |   19.99 |

Entity B:
| title                                    | manufacturer   |   price |
|:-----------------------------------------|:---------------|--------:|
| feral interactive ford racing 2 for os x |                |      24 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 668
rtable_id: 220
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 |
|:---------------|:---------------|--------:|
| crusader kings | atari          |   19.99 |

Entity B:
| title                         | manufacturer   |   price |
|:------------------------------|:---------------|--------:|
| atari 26162 crusader kings mb |                |   21.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 120
rtable_id: 1754
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   |
|:-------------------|:---------------|:--------|
| apple xsan ( mac ) | apple          |         |

Entity B:
| title                         | manufacturer   |   price |
|:------------------------------|:---------------|--------:|
| adobe illustrator cs3 ( mac ) |                |     599 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1122
rtable_id: 2860
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 rock guitar method | emedia         |   39.99 |

Entity B:
| title                                            | manufacturer   |   price |
|:-------------------------------------------------|:---------------|--------:|
| emedia music corp emedia piano & keyboard method |                |   49.21 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 181
rtable_id: 534
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 architect design suite | imsi design    |   29.99 |

Entity B:
| title                                         | manufacturer   |   price |
|:----------------------------------------------|:---------------|--------:|
| instant architect design suite ( 00ids510cc ) |                |   28.79 |



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

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

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

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

Entity B:
| title                                                                     | manufacturer   |   price |
|:--------------------------------------------------------------------------|:---------------|--------:|
| punch software 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: 2399
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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

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

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

Entity B:
| title                                          | manufacturer   |   price |
|:-----------------------------------------------|:---------------|--------:|
| adobe ( r ) photoshop ( r ) 7.0 upgrade for pc |                |  679.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 923
rtable_id: 1180
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 upsell [ mac ] | adobe          |     899 |

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: 350
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 |
|:-----------------------------|:-----------------|--------:|
| crystal reports xi developer | business objects |     595 |

Entity B:
| title                               | manufacturer   |   price |
|:------------------------------------|:---------------|--------:|
| business objects crystal reports xi |                |  459.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 184
rtable_id: 1771
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 |
|:------------------------|:---------------|--------:|
| microspot x-rip ( mac ) | microspot ltd  |  349.99 |

Entity B:
| title                                                   | manufacturer   |   price |
|:--------------------------------------------------------|:---------------|--------:|
| microsoft office 2004 for students and teachers ( mac ) |                |  134.99 |



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

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

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

Entity A:
| title                                  | manufacturer    |   price |
|:---------------------------------------|:----------------|--------:|
| printmaster 17 gold by encore software | encore software |   30.66 |

Entity B:
| title                                                                  | manufacturer   |   price |
|:-----------------------------------------------------------------------|:---------------|--------:|
| corel intervideo windvd 8 gold software for windows authoring software |                |   49.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1038
rtable_id: 2310
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 japanese ( audio book ) | topics entertainment |         |

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



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

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

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

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

Entity B:
| title                                     | manufacturer   |   price |
|:------------------------------------------|:---------------|--------:|
| word mac 2004 upgrade microsoft d48-00488 |                |   97.36 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 606
rtable_id: 2474
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 |
|:-------------------------------------|:---------------|--------:|
| aircraft collector 's second edition | abacus         |   19.95 |

Entity B:
| title                                               | manufacturer   |   price |
|:----------------------------------------------------|:---------------|--------:|
| git comic book library collector 's edition vol . 1 |                |   19.99 |



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

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

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

Entity A:
| title                         | manufacturer         |   price |
|:------------------------------|:---------------------|--------:|
| instant immersion spanish 2.0 | topics entertainment |   29.99 |

Entity B:
| title                           | manufacturer   |   price |
|:--------------------------------|:---------------|--------:|
| instant immers japanese dlx 2 . |                |   36.11 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 558
rtable_id: 3023
label: 0