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

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

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

Entity A:
| title                                                     | manufacturer    | price   |
|:----------------------------------------------------------|:----------------|:--------|
| adobe photoshop cs2 advanced techniques by julieanne kost | software cinema |         |

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: 1229
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 |
|:--------------------------|:---------------|--------:|
| easy drums ( jewel case ) | arcmedia       |    9.99 |

Entity B:
| title                                           | manufacturer   |   price |
|:------------------------------------------------|:---------------|--------:|
| total 3d home deluxe ( jewel case ) ( jce-th6 ) |                |    9.59 |



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

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

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

Entity A:
| title                                     | manufacturer   |   price |
|:------------------------------------------|:---------------|--------:|
| peachtree by sage premium accounting 2007 | sage software  |  499.99 |

Entity B:
| title                               | manufacturer   |   price |
|:------------------------------------|:---------------|--------:|
| peachtree ( r ) pro accounting 2007 |                |  169.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1242
rtable_id: 1139
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 |
|:----------------------------------------------------------|:---------------|--------:|
| encore inc 3d home architect home design deluxe version 9 |                |   25.49 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1257
rtable_id: 313
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 |
|:---------------------------------------------------|:---------------|--------:|
| datapilot cell phone data transfer suite universal | susteen        |   79.99 |

Entity B:
| title                                                          | manufacturer   |   price |
|:---------------------------------------------------------------|:---------------|--------:|
| susteen inc datapilot cell phone data transfer suite universal |                |   67.94 |



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

Entity B:
| title                          | manufacturer   |   price |
|:-------------------------------|:---------------|--------:|
| fallout collection ( dvd-rom ) |                |   24.49 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 671
rtable_id: 2993
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 ( mac ) | microsoft      |  399.99 |

Entity B:
| title                             | manufacturer   |   price |
|:----------------------------------|:---------------|--------:|
| word mac 2004 microsoft d48-00487 |                |  157.18 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1145
rtable_id: 1686
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 soundbooth cs3 audio editing software mac music production software |                |  198.95 |



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

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

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

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

Entity B:
| title                                                         | manufacturer   |   price |
|:--------------------------------------------------------------|:---------------|--------:|
| microsoft word 2004 upgrade for mac os x apple & mac software |                |  108.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 571
rtable_id: 2600
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 |
|:--------------------------|:---------------|--------:|
| monopoly platinum edition | encore         |   19.99 |

Entity B:
| title                                                           | manufacturer   |   price |
|:----------------------------------------------------------------|:---------------|--------:|
| sony media software vegas movie studio + dvd 8 platinum edition |                |  100.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1048
rtable_id: 840
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 |
|:-----------------------------------|:---------------|--------:|
| quickbooks ( r ) simple start 2007 |                |   99.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 539
rtable_id: 1124
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 [ mac ] | adobe          |     649 |

Entity B:
| title                  | manufacturer   |   price |
|:-----------------------|:---------------|--------:|
| adobe cs3 web standard |                | 1035.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 517
rtable_id: 566
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 windows vista business ( pc ) |                |  299.99 |



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

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

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

Entity A:
| title                                                        | manufacturer             | price   |
|:-------------------------------------------------------------|:-------------------------|:--------|
| cisco ios enterprise services complete package cd28-esk9 = ) | cisco systems enterprise |         |

Entity B:
| title                                                                                 | manufacturer   |   price |
|:--------------------------------------------------------------------------------------|:---------------|--------:|
| 395-03824 microsoft exchange server 2007 enterprise edition complete package 1 server |                |  6594.2 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 204
rtable_id: 53
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 dro 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: 179
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 |
|:-------------------------------------------------|:---------------|--------:|
| adobe creative suite cs3 design standard [ mac ] | adobe          |    1199 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 588
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 upgrade ( mac ) | microsoft      |  109.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 823
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 |
|:--------------------------------|:---------------|--------:|
| emedia print music 2006 win/mac | makemusic !    |   69.99 |

Entity B:
| title                                  | manufacturer   |   price |
|:---------------------------------------|:---------------|--------:|
| emedia music corp emedia guitar basics |                |   16.64 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1124
rtable_id: 234
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 |
|:----------------------|:---------------|--------:|
| norton antivirus 2007 | symantec       |   39.99 |

Entity B:
| title                | manufacturer   |   price |
|:---------------------|:---------------|--------:|
| ca anti-spyware 2007 |                |   24.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 312
rtable_id: 2801
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 |
|:----------------------------------------|:---------------|--------:|
| punch software punch ! super home suite |                |   49.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1078
rtable_id: 2432
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 soundbooth cs3 [ mac ] | adobe          |     199 |

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



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

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

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

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

Entity B:
| title                                                                             | manufacturer   |   price |
|:----------------------------------------------------------------------------------|:---------------|--------:|
| microsoft microsoft office 2004 software suite mac education apple & mac software |                |  148.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 606
rtable_id: 2137
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 |
|:--------------------|:-----------------|--------:|
| spy sweeper spanish | webroot software |   29.95 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 13
rtable_id: 2425
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 |
|:----------------------------------|:---------------|--------:|
| norton antivirus mac 10.0 ( mac ) | symantec       |   69.95 |

Entity B:
| title                             | manufacturer   |   price |
|:----------------------------------|:---------------|--------:|
| norton antivirus 2007 3 user pack |                |   49.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 617
rtable_id: 2999
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 audition 2.0 upgrade | adobe          |     129 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 504
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 |
|:------------------------------------------|:---------------|--------:|
| quickbooks premier nonprofit edition 2007 | intuit         |  399.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: 520
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   |
|:----------------------------------------------------------------------------------------|:----------------|:--------|
| hp storageworks secure path for windows workgroup edition v. 4.0 c license 213076-b26 ) | hewlett packard |         |

Entity B:
| title                                                                           | manufacturer   |   price |
|:--------------------------------------------------------------------------------|:---------------|--------:|
| t3586a hp storageworks secure path for linux workgroup edition v. 3.0 c license |                | 65395.2 |



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

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

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

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

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



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

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

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

Entity A:
| title                    | manufacturer         |   price |
|:-------------------------|:---------------------|--------:|
| kids power fun for girls | topics entertainment |   19.99 |

Entity B:
| title                    | manufacturer   |   price |
|:-------------------------|:---------------|--------:|
| kids power fun for girls |                |    15.9 |



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

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

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

Entity A:
| title                                        | manufacturer   |   price |
|:---------------------------------------------|:---------------|--------:|
| apple remote desktop 3 unlim managed systems | apple          |     499 |

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: 995
rtable_id: 2135
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 office and windows training ( win 98 me nt 2000 xp ) |                |   29.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 518
rtable_id: 1585
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 |
|:---------------------------------------------------------|:---------------|--------:|
| valuesoft tune transfer for ipod software for windows xp | valuesoft      |   29.95 |

Entity B:
| title                                                                  | manufacturer   |   price |
|:-----------------------------------------------------------------------|:---------------|--------:|
| iparrot thai/english phrase translator software for ipod ipod software |                |   19.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1176
rtable_id: 2687
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 |
|:-------------------------------------------|:---------------|--------:|
| brain food games : cranium collection 2006 | encore         |   19.95 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1036
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 |
|:------------------------------------------------------------------------------|:---------------|--------:|
| sony creative software vegas43 ; dvd production suite v. 7.0 complete product |                |  262.82 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 557
rtable_id: 2671
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 professional ( mac ) | microsoft      |  499.99 |

Entity B:
| title                                   | manufacturer   |   price |
|:----------------------------------------|:---------------|--------:|
| microsoft windows vista business ( pc ) |                |  299.99 |



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

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

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

Entity A:
| title                                   | manufacturer   |   price |
|:----------------------------------------|:---------------|--------:|
| apple garageband jam pack : remix tools | apple          |      99 |

Entity B:
| title                                           | manufacturer   |   price |
|:------------------------------------------------|:---------------|--------:|
| garageband jampack rhythm section ( mac ) apple |                |   99.99 |



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

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

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

Entity A:
| title                                                                      | manufacturer   |   price |
|:---------------------------------------------------------------------------|:---------------|--------:|
| microsoft windows server 2003 client additional license for devices 5 pack | microsoft      |     209 |

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: 1
original: ltable_id: 431
rtable_id: 3109
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 |
|:--------------------|:---------------|--------:|
| the big mix ( mac ) | aladdin        |   59.99 |

Entity B:
| title       | manufacturer   |   price |
|:------------|:---------------|--------:|
| the big mix |                |    36.9 |



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

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

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

Entity A:
| title                                | manufacturer   |   price |
|:-------------------------------------|:---------------|--------:|
| adobe photoshop elements 4.0 ( mac ) | adobe          |   89.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 536
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 |
|:----------------------------------------------|:---------------|--------:|
| intuit quicken home inventory manager windows | intuit         |   34.95 |

Entity B:
| title                                     | manufacturer   |   price |
|:------------------------------------------|:---------------|--------:|
| intuit inc quicken home inventory manager |                |   29.78 |



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

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

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

Entity A:
| title                            | manufacturer         | price   |
|:---------------------------------|:---------------------|:--------|
| instant immersion hawaiian audio | topics entertainment |         |

Entity B:
| title                                               | manufacturer   |   price |
|:----------------------------------------------------|:---------------|--------:|
| topics entertainment instant immersion german audio |                |   12.05 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1341
rtable_id: 307
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 landscape v. 8 by encore software | encore software |   39.99 |

Entity B:
| title                                              | manufacturer   |   price |
|:---------------------------------------------------|:---------------|--------:|
| 3d home architect landscape v. 8by encore software |                |   26.36 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 779
rtable_id: 2587
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 |
|:---------------------------------------------------------------------------------|:---------------|--------:|
| motu digital performer 5 digital audio software competitive upgrade ( mac only ) | motu           |     395 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1162
rtable_id: 2238
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 [ mac ] | adobe          |     649 |

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



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

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

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

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

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



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