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 |
|:------------------------------------------|:---------------|--------:|
| steinberg nuendo 3 digital audio software | steinberg      |    2499 |

Entity B:
| title    | manufacturer   |   price |
|:---------|:---------------|--------:|
| software |                |  736.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 722
rtable_id: 1117
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 ( r ) photoshop ( r ) 7.0 upgrade for pc |                |  679.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 837
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   |
|:-----------------------------------------------------------------|:----------------|:--------|
| the print shop elements : labels & logos sb cs by the print shop | encore software |         |

Entity B:
| title                   | manufacturer   |   price |
|:------------------------|:---------------|--------:|
| the print shop ( r ) 22 |                |   29.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1068
rtable_id: 1157
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 customer manager 2.5 | intuit         |   79.95 |

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



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

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

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

Entity A:
| title                            | manufacturer   |   price |
|:---------------------------------|:---------------|--------:|
| microsoft mappoint 2006 with gps | microsoft      |     349 |

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



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

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

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

Entity A:
| title                               | manufacturer   |   price |
|:------------------------------------|:---------------|--------:|
| microsoft word 2007 version upgrade | microsoft      |  109.95 |

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



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

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

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

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

Entity B:
| title                              | manufacturer   |   price |
|:-----------------------------------|:---------------|--------:|
| microsoft ( r ) expression web 1.0 |                |  299.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 578
rtable_id: 3220
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 |
|:------------------------------------------|:------------------------------------|--------:|
| cinescore professional soundtrack edition | sony-pictures-digital-entertainment |  249.95 |

Entity B:
| title                                             | manufacturer   |   price |
|:--------------------------------------------------|:---------------|--------:|
| the sky 6 professional edition astronomy software |                |  189.95 |



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

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

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

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

Entity B:
| title                              | manufacturer   |   price |
|:-----------------------------------|:---------------|--------:|
| adobe cs3 design standard academic |                |  385.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 593
rtable_id: 242
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 professional 2005 upgrade | microsoft software |     549 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 490
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 |
|:--------------------------|:---------------|--------:|
| stompsoft registry repair | stompsoft inc. |   29.99 |

Entity B:
| title                                                     | manufacturer   |   price |
|:----------------------------------------------------------|:---------------|--------:|
| 05090 registry repair 2005 complete package 1 user cd win |                |   24.59 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 252
rtable_id: 1786
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 small business 2007 | microsoft software |  735.33 |

Entity B:
| title                                                       | manufacturer   |   price |
|:------------------------------------------------------------|:---------------|--------:|
| individual software professor teaches microsoft office 2007 |                |   29.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 271
rtable_id: 831
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 |
|:-------------------------------|:----------------------|--------:|
| let 's learn about time & date | selectsoft publishing |   19.95 |

Entity B:
| title                                             | manufacturer   |   price |
|:--------------------------------------------------|:---------------|--------:|
| it 's about time products learn the switch to mac |                |   28.99 |



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

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

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

Entity A:
| title                       | manufacturer   |   price |
|:----------------------------|:---------------|--------:|
| pop-up stopper professional | panicware      |   29.99 |

Entity B:
| title                         | manufacturer   |   price |
|:------------------------------|:---------------|--------:|
| web easy ( r ) professional 6 |                |   49.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 618
rtable_id: 1183
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 |
|:--------------------------------------------|:---------------|--------:|
| mcafee internet security suite 2007 3 users | mcafee         |   89.99 |

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: 346
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 creative suite cs3 master collection upgrade [ mac ] | adobe          |    1399 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 910
rtable_id: 946
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 |
|:-----------------------------------------------|:----------------|--------:|
| 3d home architect home v. 8 by encore software | encore software |   39.99 |

Entity B:
| title                                          | manufacturer   |   price |
|:-----------------------------------------------|:---------------|--------:|
| encore software 11191 scrabble sb cs by hasbro |                |   17.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1078
rtable_id: 2102
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 |
|:---------------------------|:----------------|--------:|
| high school advantage 2007 | encore software |   29.95 |

Entity B:
| title                           | manufacturer   |   price |
|:--------------------------------|:---------------|--------:|
| high school success deluxe 2006 |                |     7.9 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1055
rtable_id: 2045
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 |
|:---------------------------|:----------------------|--------:|
| sonic mega collection plus | sega-of-america-inc . |   19.99 |

Entity B:
| title                             | manufacturer   |   price |
|:----------------------------------|:---------------|--------:|
| hoyle game collection 4 game pack |                |   14.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 671
rtable_id: 3036
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 cs3 production premium upsell |                | 1234.99 |



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

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

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

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

Entity B:
| title                                                                            | manufacturer   |   price |
|:---------------------------------------------------------------------------------|:---------------|--------:|
| vbc-00002 microsoft softgrid for terminal services v. 4.1 license 20 user cals - |                |   419.8 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 251
rtable_id: 1893
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 |
|:------------------------------|:---------------|--------:|
| omnioutliner professional 3.0 | csdc           |   69.95 |

Entity B:
| title                                      | manufacturer   |   price |
|:-------------------------------------------|:---------------|--------:|
| csdc pop-up stopper professional panicware |                |   26.14 |



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

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

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

Entity A:
| title                    | manufacturer   |   price |
|:-------------------------|:---------------|--------:|
| learning quickbooks 2007 | intuit         |   39.95 |

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



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

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

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

Entity A:
| title                        | manufacturer   |   price |
|:-----------------------------|:---------------|--------:|
| adobe photoshop cs3 extended | adobe          |     999 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 839
rtable_id: 986
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 pos : pro multistore 6.0 | intuit inc.    | 1399.95 |

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



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

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

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

Entity A:
| title                                     | manufacturer         | price   |
|:------------------------------------------|:---------------------|:--------|
| instant immersion japanese ( audio book ) | topics entertainment |         |

Entity B:
| title                                                                           | manufacturer   |   price |
|:--------------------------------------------------------------------------------|:---------------|--------:|
| topics entertainment instant immersion italian deluxe 2.0 ( mass merchant box ) |                |   31.06 |



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

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

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

Entity A:
| title                              | manufacturer   |   price |
|:-----------------------------------|:---------------|--------:|
| acrobat professional 8 ( windows ) | adobe          |     273 |

Entity B:
| title                        | manufacturer   |   price |
|:-----------------------------|:---------------|--------:|
| adobe acrobat professional 7 |                |     350 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 654
rtable_id: 3003
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 mappoint 2006 with gps locator ( pc ) |                |  349.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 146
rtable_id: 3029
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   |
|:-------------------------------------------------------------|:--------------------|:--------|
| ca arcserve bkup r11 .5 win svrless bkup opt sp1 - prod only | computer associates |         |

Entity B:
| title                                                      | manufacturer   |   price |
|:-----------------------------------------------------------|:---------------|--------:|
| arcserve bkup protection suite exch r11 .5 upg-v prod only |                | 2249.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 230
rtable_id: 2334
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 |
|:----------------------------|:------------------------|--------:|
| zend studio 5.1 ( win/mac ) | zend-technologies-inc . |     299 |

Entity B:
| title                  | manufacturer   |   price |
|:-----------------------|:---------------|--------:|
| sound studio 3 for mac |                |   79.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1106
rtable_id: 2452
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 |
|:-----------------------------------------|:---------------|--------:|
| 123 movies 2 ipod w / av cables umd size | bling          |   29.99 |

Entity B:
| title                                                                 | manufacturer   |   price |
|:----------------------------------------------------------------------|:---------------|--------:|
| bling software limited 05013 123 movies 2 ipod w / av cables umd size |                |   26.14 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 886
rtable_id: 2309
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 |
|:---------------------|:---------------|--------:|
| print shop 22 deluxe | encore         |   49.99 |

Entity B:
| title                                                                               | manufacturer   |   price |
|:------------------------------------------------------------------------------------|:---------------|--------:|
| encore software 10731 the print shop 22 pro publisherdeluxe sb cs by the print shop |                |   81.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 738
rtable_id: 2018
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 landscape design 3.0 |                |    17.9 |



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

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

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

Entity A:
| title                      | manufacturer   |   price |
|:---------------------------|:---------------|--------:|
| adobe indesign cs3 [ mac ] | adobe          |     699 |

Entity B:
| title                             | manufacturer   |   price |
|:----------------------------------|:---------------|--------:|
| adobe cs3 design premium academic |                |  575.99 |



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

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

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

Entity A:
| title                       | manufacturer   |   price |
|:----------------------------|:---------------|--------:|
| microsoft word 2004 ( mac ) | microsoft      |  229.99 |

Entity B:
| title                               | manufacturer   |   price |
|:------------------------------------|:---------------|--------:|
| office mac 2004 microsoft 731-01002 |                |  331.77 |



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

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

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

Entity A:
| title                                                             | manufacturer   | price   |
|:------------------------------------------------------------------|:---------------|:--------|
| snap enterprise data replicator advanced license for 10000 series | adaptec        |         |

Entity B:
| title                                                                               | manufacturer   |   price |
|:------------------------------------------------------------------------------------|:---------------|--------:|
| 5325301935 snap enterprise data replicator license 1 additional server linux unix w |                | 4401.41 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 133
rtable_id: 1875
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 |
|:---------------------------|:---------------|--------:|
| high school advantage 2008 | encore         |   39.99 |

Entity B:
| title                                                              | manufacturer   |   price |
|:-------------------------------------------------------------------|:---------------|--------:|
| encore software 12380 high school advantage 2008 win 2000 xp vista |                |   34.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1053
rtable_id: 759
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 |
|:---------------------------------|:---------------|--------:|
| sony sound forge 9 boxed upgrade | sony media     |  232.05 |

Entity B:
| title                                                                             | manufacturer                        |   price |
|:----------------------------------------------------------------------------------|:------------------------------------|--------:|
| sony media software sound forge audio studio 8 software music production software | sony-pictures-digital-entertainment |   69.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 879
rtable_id: 1060
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 |
|:-------------------------------------------------|:--------------------|--------:|
| total 3d home & landscape design suite version 9 | individual software |   39.99 |

Entity B:
| title                                                         | manufacturer   |   price |
|:--------------------------------------------------------------|:---------------|--------:|
| punch software 25100 punch ! master landscape and home design | punch software |   45.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1257
rtable_id: 1039
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 |
|:----------------------------------------------------------|:---------------|--------:|
| e-mu em8685 beat garden x emulator x2/proteus x2 soundset | e-mu           |  129.99 |

Entity B:
| title                                                                                | manufacturer   |   price |
|:-------------------------------------------------------------------------------------|:---------------|--------:|
| e-mu beat garden x for emulator x and proteus x software modules sounds for software |                |   69.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1089
rtable_id: 1372
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 word 2007 version upgrade | microsoft      |  109.95 |

Entity B:
| title                          | manufacturer   |   price |
|:-------------------------------|:---------------|--------:|
| microsoft ( r ) frontpage 2002 |                |  169.56 |



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

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

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

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

Entity B:
| title                                                                  | manufacturer   |   price |
|:-----------------------------------------------------------------------|:---------------|--------:|
| encore software 10444 elementary school advantage 2007 sb cs by encore |                |   25.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 944
rtable_id: 2589
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 |
|:-----------------|:---------------|--------:|
| quickbooks ( r ) |                |  178.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 532
rtable_id: 1311
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 ( r ) money 2004 standard |                |   29.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 146
rtable_id: 3183
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 dreamweaver cs3 academic | adobe-education-box |  195.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 592
rtable_id: 580
label: 0