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 1st-3rd grade 8th edition | encore         |   19.99 |

Entity B:
| title                    | manufacturer   |   price |
|:-------------------------|:---------------|--------:|
| brain play 1st-3rd grade |                |    17.9 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 359
rtable_id: 1240
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 remote desktop 3 10 managed systems | apple          |     299 |

Entity B:
| title                                                | manufacturer   |   price |
|:-----------------------------------------------------|:---------------|--------:|
| apple software m9953z/a remote desktop 2.2 10 client | apple software |  294.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1119
rtable_id: 1351
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 ( mac ) | microsoft      |  229.99 |

Entity B:
| title                                 | manufacturer   |   price |
|:--------------------------------------|:---------------|--------:|
| microsoft ( r ) project standard 2007 |                |  599.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 225
rtable_id: 3171
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 |
|:-------------------------------------------------------------------|:---------------|--------:|
| encore software 10449 high school advantage 2007 win 98 me 2000 xp |                |   26.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1055
rtable_id: 758
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 |
|:------------------------------------------------|:---------------|--------:|
| individual small business advantage deluxe 2006 | individual     |   49.99 |

Entity B:
| title                       | manufacturer   |   price |
|:----------------------------|:---------------|--------:|
| phonics success deluxe 2006 |                |    22.9 |



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

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

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

Entity A:
| title              | manufacturer   |   price |
|:-------------------|:---------------|--------:|
| the sims 2 ( mac ) | aspyr media    |   49.99 |

Entity B:
| title               | manufacturer   |   price |
|:--------------------|:---------------|--------:|
| sims 2 pets for mac |                |   34.99 |



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

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

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

Entity A:
| title                                                        | manufacturer       |   price |
|:-------------------------------------------------------------|:-------------------|--------:|
| microsoft licenses win svr 2003 device cal l/sa ( r1800144 ) | microsoft licenses |   74.59 |

Entity B:
| title                                                             | manufacturer   |   price |
|:------------------------------------------------------------------|:---------------|--------:|
| windows sbs cal 2003 20-clt addpak device cal microsoft t74-00003 |                | 1413.42 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 228
rtable_id: 1633
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 mac 2004 english 3pk dsp 731-01163 ) | microsoft corporation |         |

Entity B:
| title                                                 | manufacturer   |   price |
|:------------------------------------------------------|:---------------|--------:|
| microsoft office basic edition 2003 license and media |                |  124.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 773
rtable_id: 1014
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   |
|:------------------------|:------------------|:--------|
| solitaire antics deluxe | masque publishing |         |

Entity B:
| title                      | manufacturer   |   price |
|:---------------------------|:---------------|--------:|
| encore inc hoyle solitaire |                |    7.83 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1315
rtable_id: 671
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 |
|:------------------------------------------------------------------------------------|:---------------|--------:|
| power production storyboard quick 5 software for mac and windows animation software |                |     299 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 492
rtable_id: 2172
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 |
|:-------------------------|:---------------------|--------:|
| math success deluxe 2006 | topics entertainment |   49.99 |

Entity B:
| title                       | manufacturer   |   price |
|:----------------------------|:---------------|--------:|
| phonics success deluxe 2006 |                |    22.9 |



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

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

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

Entity A:
| title                                            | manufacturer         |   price |
|:-------------------------------------------------|:---------------------|--------:|
| microsoft office & windows training professional | topics entertainment |   49.95 |

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



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

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

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

Entity A:
| title                               | manufacturer   | price   |
|:------------------------------------|:---------------|:--------|
| onone software intellihance pro 4.1 | onone software |         |

Entity B:
| title                                              | manufacturer   |   price |
|:---------------------------------------------------|:---------------|--------:|
| onone software genuine fractals print pro software |                |  269.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 859
rtable_id: 802
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 language lab deluxe edition | topics entertainment |         |

Entity B:
| title                           | manufacturer   |   price |
|:--------------------------------|:---------------|--------:|
| instant immers italian dlux 2 . |                |   36.11 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 44
rtable_id: 3016
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 [ mac ] | adobe          |     599 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 772
rtable_id: 902
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   |
|:-----------------------------------------------------------|:----------------|:--------|
| marine aquarium & goldfish screen saver by encore software | encore software |         |

Entity B:
| title                                                            | manufacturer   |   price |
|:-----------------------------------------------------------------|:---------------|--------:|
| encore software 10561 marine aquarium & goldfish screen saver by |                |   17.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1072
rtable_id: 2046
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 ( r ) works suite 2006 |                |   99.99 |



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

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

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

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

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 593
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 |
|:-----------------------------------------------|:---------------|--------:|
| adobe creative suite cs3 design premium upsell | adobe          |    1599 |

Entity B:
| title                               | manufacturer   |   price |
|:------------------------------------|:---------------|--------:|
| adobe cs3 production premium upsell |                | 1234.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1322
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 office excel 2007 | microsoft      |  229.95 |

Entity B:
| title                         | manufacturer   |   price |
|:------------------------------|:---------------|--------:|
| microsoft onenote 2007 ( pc ) |                |   99.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 578
rtable_id: 2867
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 |
|:----------------------------------|:---------------|--------:|
| vcomm system suite professional 7 | avanquest      |   49.95 |

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



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

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

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

Entity A:
| title                | manufacturer   |   price |
|:---------------------|:---------------|--------:|
| ulead videostudio 10 | corel          |   69.99 |

Entity B:
| title                                                                                           | manufacturer   |   price |
|:------------------------------------------------------------------------------------------------|:---------------|--------:|
| corel ulead videostudio 11 plus video editing and dvd authoring software win authoring software |                |  129.95 |



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

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

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

Entity A:
| title                           | manufacturer   |   price |
|:--------------------------------|:---------------|--------:|
| quicken legal business pro 2007 | nolo press     |   79.99 |

Entity B:
| title                       | manufacturer   |   price |
|:----------------------------|:---------------|--------:|
| quicken 2007 premier win cd | intuit         |   73.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1241
rtable_id: 3055
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 pro 2007 3 user | intuit         |  398.99 |



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

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

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

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

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



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

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

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

Entity A:
| title                              | manufacturer        |   price |
|:-----------------------------------|:--------------------|--------:|
| jumpstart advanced 2nd grade v2 .0 | knowledge adventure |   19.99 |

Entity B:
| title                                                       | manufacturer   |   price |
|:------------------------------------------------------------|:---------------|--------:|
| jumpstart advanced 3rd grade ( pc/mac ) knowledge adventure |                |   19.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 394
rtable_id: 2757
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 |
|:-------------------------|:--------------------|--------:|
| photostory on cd & dvd 5 | magix entertainment |   19.99 |

Entity B:
| title                                                       | manufacturer   |   price |
|:------------------------------------------------------------|:---------------|--------:|
| magix entertainment corp. xtreme photostory on cd and dvd 6 |                |   26.14 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1357
rtable_id: 413
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 |
|:---------------------------------|:----------------|--------:|
| elementary school advantage 2007 | encore software |   29.99 |

Entity B:
| title                  | manufacturer   |   price |
|:-----------------------|:---------------|--------:|
| spanish advantage 2007 |                |   28.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1020
rtable_id: 3132
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 office and windows training professional |                |   29.99 |



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

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

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

Entity A:
| title                                                                               | manufacturer   |   price |
|:------------------------------------------------------------------------------------|:---------------|--------:|
| microsoft windows terminal server 2003 client additional license for users - 5 user | microsoft      |     669 |

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



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

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

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

Entity A:
| title               | manufacturer   |   price |
|:--------------------|:---------------|--------:|
| print workshop 2007 | valusoft       |   19.99 |

Entity B:
| title            | manufacturer   |   price |
|:-----------------|:---------------|--------:|
| the printshop 20 |                |    19.9 |



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

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

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

Entity A:
| title                                    | manufacturer   | price   |
|:-----------------------------------------|:---------------|:--------|
| autodesk discreet combustion 4 windows ) | autodesk       |         |

Entity B:
| title                                                                 | manufacturer   |   price |
|:----------------------------------------------------------------------|:---------------|--------:|
| autodesk combustion 4.0 compositing software win compositing software |                |     889 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 168
rtable_id: 2164
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 cs3 extended | adobe          |     999 |

Entity B:
| title                                                                | manufacturer   |   price |
|:---------------------------------------------------------------------|:---------------|--------:|
| adobe photoshop cs3 extended complete package 1 user academic cd mac |                |     279 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 839
rtable_id: 1135
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 photoshop cs3 for mac upgrade |                |  189.99 |



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

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

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

Entity A:
| title                        | manufacturer   |   price |
|:-----------------------------|:---------------|--------:|
| adobe contribute cs3 [ mac ] | adobe          |     149 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 930
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 |
|:-----------------------|:---------------|--------:|
| adobe premiere pro cs3 | adobe          |     799 |

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



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

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

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

Entity A:
| title                                            | manufacturer   |   price |
|:-------------------------------------------------|:---------------|--------:|
| corel wordperfect office x3 professional edition | corel          |  399.99 |

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: 594
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 |
|:-------------------------------|:---------------------|--------:|
| instant immersion japanese 2.0 | topics entertainment |   19.99 |

Entity B:
| title                                                        | manufacturer   |   price |
|:-------------------------------------------------------------|:---------------|--------:|
| topics entertainment instant immersion japanese crash course |                |    6.56 |



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

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

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

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

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 853
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 |
|:------------------------------------------------------------------------------------|:---------------|--------:|
| microsoft windows terminal server 2003 client additional license for users - 5 user | microsoft      |     669 |

Entity B:
| title                                         | manufacturer   |   price |
|:----------------------------------------------|:---------------|--------:|
| microsoft windows vista business full version |                |  249.95 |



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

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

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

Entity A:
| title                                          | manufacturer   |   price |
|:-----------------------------------------------|:---------------|--------:|
| microsoft office 2004 standard upgrade ( mac ) | microsoft      |  239.99 |

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



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

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

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

Entity A:
| title                                 | manufacturer         |   price |
|:--------------------------------------|:---------------------|--------:|
| instant immersion japanese deluxe 2.0 | topics entertainment |   39.99 |

Entity B:
| title                          | manufacturer         |   price |
|:-------------------------------|:---------------------|--------:|
| instant immersion 33 languages | topics entertainment |   43.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 890
rtable_id: 2996
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 |
|:---------------------------------------------------------------------------------------|:---------------|--------:|
| t74-00004 microsoft windows small business server 2003 license 20 additional user cals |                |  1834.4 |



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

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

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

Entity A:
| title                               | manufacturer   | price   |
|:------------------------------------|:---------------|:--------|
| onone software intellihance pro 4.1 | onone software |         |

Entity B:
| title                         | manufacturer        |   price |
|:------------------------------|:--------------------|--------:|
| onone software inc. mpr-40212 | onone software inc. |   66.27 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 859
rtable_id: 2398
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 cs3 design premium macosx dvd | adobe          |     599 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1130
rtable_id: 521
label: 0