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 |
|:------------------------------------------------------|:---------------|--------:|
| microsoft virtual pc for mac 7.0 with windows xp home | microsoft      |  219.99 |

Entity B:
| title                                             | manufacturer   |   price |
|:--------------------------------------------------|:---------------|--------:|
| microsoft windows vista home basic upgrade ( pc ) |                |   99.99 |



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

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

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

Entity A:
| title                                                 | manufacturer   |   price |
|:------------------------------------------------------|:---------------|--------:|
| microsoft virtual pc for mac 7.0 with windows xp home | microsoft      |  219.99 |

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



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

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

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

Entity A:
| title                       | manufacturer   |   price |
|:----------------------------|:---------------|--------:|
| adobe photoshop cs3 [ mac ] | adobe          |     649 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 517
rtable_id: 986
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 mac os x tiger 10.4.6 family pack ( mac ) | apple computer |     199 |

Entity B:
| title                                        | manufacturer   |   price |
|:---------------------------------------------|:---------------|--------:|
| apple apple mac os x server 10 4 7 10 client |                |     499 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1175
rtable_id: 1599
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 ) |                |  178.99 |



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

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

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

Entity A:
| title                              | manufacturer    |   price |
|:-----------------------------------|:----------------|--------:|
| i copy dvds 2 professional edition | me-too-software |   69.99 |

Entity B:
| title                                                                   | manufacturer   |   price |
|:------------------------------------------------------------------------|:---------------|--------:|
| 37510 novabackup professional edition v. 7.5 upgrade license 1 user win |                |   25.06 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 27
rtable_id: 1701
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 | microsoft      |  259.95 |

Entity B:
| title                       | manufacturer   |   price |
|:----------------------------|:---------------|--------:|
| microsoft excel 2007 ( pc ) |                |  229.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 522
rtable_id: 2821
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 professional services edition 2007 | intuit         |  399.95 |

Entity B:
| title                                            | manufacturer   |   price |
|:-------------------------------------------------|:---------------|--------:|
| quickbooks ( r ) credit card processing kit 2007 |                |   39.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 586
rtable_id: 3133
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 |
|:--------------------------------------------------------------------------|:----------------|--------:|
| acad upgrade dragon naturallyspeaking pro solution 9.0 ( a289a-fd7-9 .0 ) | nuance academic |  399.54 |

Entity B:
| title                                                                                                                                     | manufacturer   |   price |
|:------------------------------------------------------------------------------------------------------------------------------------------|:---------------|--------:|
| nuance communications inc. upgrade to dragon naturallyspeaking v8 legal solutions from professional v6 and up ( govt ) olp a590a-sf2-8 .0 |                |     314 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 7
rtable_id: 1617
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 | adobe          |     399 |

Entity B:
| title                      | manufacturer   |   price |
|:---------------------------|:---------------|--------:|
| adobe indesign cs3 for mac |                |  725.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 615
rtable_id: 331
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 |
|:--------------------------------------|:--------------------------|--------:|
| f-secure internet security 2007 3 pcs | global-marketing-partners |   79.99 |

Entity B:
| title                                                      | manufacturer   |   price |
|:-----------------------------------------------------------|:---------------|--------:|
| pc-cillin internet security 2007 3-user ( win me 2000 xp ) |                |   49.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 316
rtable_id: 2624
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 excel 2004 spreadsheet software mac apple & mac software |                |  228.95 |



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

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

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

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

Entity B:
| title                         | manufacturer         |   price |
|:------------------------------|:---------------------|--------:|
| instant immersion italian 2.0 | topics entertainment |   20.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 558
rtable_id: 3048
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 |
|:--------------------------------------|:--------------------------|--------:|
| f-secure internet security 2007 3 pcs | global-marketing-partners |   79.99 |

Entity B:
| title                                                    | manufacturer   |   price |
|:---------------------------------------------------------|:---------------|--------:|
| intego inc internet security barrier x4 antispam edition |                |   71.75 |



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

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

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

Entity A:
| title                                    | manufacturer   |   price |
|:-----------------------------------------|:---------------|--------:|
| microsoft mappoint 2006 standard edition | microsoft      |     299 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 146
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 |
|:----------------------------------------------------|:-------------------|--------:|
| poetry fiction and drama ( win/mac ) ( jewel case ) | fogware publishing |    9.99 |

Entity B:
| title                                              | manufacturer         |   price |
|:---------------------------------------------------|:---------------------|--------:|
| cross stitch design studio ( jewel case ) ( 8006 ) | m-and-r-technologies |    9.59 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 319
rtable_id: 3110
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 onenote 2007 upgrade ( pc ) |                |   79.95 |



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

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

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

Entity A:
| title                                        | manufacturer   |   price |
|:---------------------------------------------|:---------------|--------:|
| adobe creative suite cs3 web standard upsell | adobe          |     799 |

Entity B:
| title                                                                               | manufacturer   |   price |
|:------------------------------------------------------------------------------------|:---------------|--------:|
| 19300109 adobe creative suite 3 design standard product upgrade package 1 user upgr |                |  424.74 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 361
rtable_id: 1853
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 |
|:--------------------------------------|:---------------|--------:|
| reel deal casino championship edition | phantom efx    |   19.99 |

Entity B:
| title                                               | manufacturer   |   price |
|:----------------------------------------------------|:---------------|--------:|
| phantom efx reel deal casino shuffle master edition |                |   17.24 |



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

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

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

Entity A:
| title                                             | manufacturer     |   price |
|:--------------------------------------------------|:-----------------|--------:|
| punch ! home design architectural series 4000 v10 | punch ! software |  199.99 |

Entity B:
| title                                                                                                                              | manufacturer   |   price |
|:-----------------------------------------------------------------------------------------------------------------------------------|:---------------|--------:|
| punch software 20100 punch ! home design complete product architectural 1 user complete productcomplete productstandard english pc |                |   36.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1290
rtable_id: 1057
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 play guitar deluxe v2 . | topics entertainment |   39.48 |

Entity B:
| title                                            | manufacturer   |   price |
|:-------------------------------------------------|:---------------|--------:|
| topics entertainment instant play keyboard v2 .0 |                |   17.55 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 925
rtable_id: 572
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 |
|:--------------|:---------------|--------:|
| stopzilla 4.0 | roxio          |   47.33 |

Entity B:
| title                   | manufacturer   |   price |
|:------------------------|:---------------|--------:|
| roxio inc stopzilla 4.0 |                |   26.14 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 630
rtable_id: 274
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 publisher with digital imaging 2003 [ old version ] | microsoft      |  209.99 |

Entity B:
| title                                                                                   | manufacturer   |   price |
|:----------------------------------------------------------------------------------------|:---------------|--------:|
| a01-00017 microsoft office publisher 2003 w / microsoft digital image pro 9 complete pa |                |  218.19 |



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

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

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

Entity A:
| title                                      | manufacturer    |   price |
|:-------------------------------------------|:----------------|--------:|
| i transfer dvds 2 ipod edition ( win/mac ) | me-too-software |   29.99 |

Entity B:
| title                                  | manufacturer    |   price |
|:---------------------------------------|:----------------|--------:|
| me too software i transfer dvds 2 ipod | me-too-software |   29.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 762
rtable_id: 396
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 |
|:------------------|:---------------|--------:|
| hoyle casino 2007 | encore         |   19.95 |

Entity B:
| title            | manufacturer   |   price |
|:-----------------|:---------------|--------:|
| hoyle card games |                |    9.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 778
rtable_id: 3039
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 fireworks cs3 |                |  309.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 892
rtable_id: 428
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 xp professional full version with sp2 | microsoft      |  299.99 |

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



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

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

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

Entity A:
| title                           | manufacturer   |   price |
|:--------------------------------|:---------------|--------:|
| quickbooks customer manager 2.5 | intuit         |   79.95 |

Entity B:
| title            | manufacturer   |   price |
|:-----------------|:---------------|--------:|
| quickbooks ( r ) |                |  103.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 993
rtable_id: 1214
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 aperture 1.5 | apple          |     299 |

Entity B:
| title          | manufacturer   |   price |
|:---------------|:---------------|--------:|
| apple ilife 06 |                |   70.47 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 603
rtable_id: 2020
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 acrobat standard 8.0 | adobe          |  449.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1251
rtable_id: 558
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 office outlook 2007 |                |  109.95 |



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

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

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

Entity A:
| title                    | manufacturer   |   price |
|:-------------------------|:---------------|--------:|
| system care professional | 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: 866
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 |
|:----------------------------|:---------------|--------:|
| microsoft word 2004 ( mac ) | microsoft      |  229.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 605
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 |
|:-------------------------------|:---------------------|--------:|
| instant immersion japanese 2.0 | topics entertainment |   19.99 |

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



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

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

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

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

Entity B:
| title                       | manufacturer   |   price |
|:----------------------------|:---------------|--------:|
| adobe premiere elements 3.0 |                |   89.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 26
rtable_id: 2391
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 master collection |                | 2499.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 876
rtable_id: 953
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 |
|:--------------------------------|:---------------|--------:|
| rollercoaster tycoon 3 : soaked | aspyr media    |   19.99 |

Entity B:
| title                                  | manufacturer   |   price |
|:---------------------------------------|:---------------|--------:|
| aspyr roller coaster tycoon 3 mac os x |                |   45.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 748
rtable_id: 965
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 ( r ) office 2004 for mac standard edition upgrade version |                |  234.95 |



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

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

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

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

Entity B:
| title                                     | manufacturer   |   price |
|:------------------------------------------|:---------------|--------:|
| microsoft w87-02380 office sbe 2007 win32 |                |  400.34 |



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

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

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

Entity A:
| title                                                | manufacturer   |   price |
|:-----------------------------------------------------|:---------------|--------:|
| adobe creative suite cs3 web premium upgrade [ mac ] | adobe          |     499 |

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



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

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

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

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

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 883
rtable_id: 190
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 production studio premium | adobe          |    1699 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 382
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   |
|:---------------------------------------------------------------------------------------------------------------------------------|:------------------|:--------|
| adobe photoshop elements 4.0 plus adobe premiere elements 2.0 complete package 1 user cd mini-box win canadian french 29180162 ) | adobe systems inc |         |

Entity B:
| title                                                                           | manufacturer   |   price |
|:--------------------------------------------------------------------------------|:---------------|--------:|
| 25510587 adobe after effects cs3 professional complete package 1 user dvd win c |                | 1054.23 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 157
rtable_id: 25
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 |
|:------------------------------------------------|:---------------|--------:|
| h & r block taxcut 2006 home & business + state | h & r block    |   79.99 |

Entity B:
| title                               | manufacturer   |   price |
|:------------------------------------|:---------------|--------:|
| kiplingers home & business attorney |                |   29.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 567
rtable_id: 3143
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 upgrade [ mac ] | adobe          |     199 |

Entity B:
| title                                                                      | manufacturer      |   price |
|:---------------------------------------------------------------------------|:------------------|--------:|
| adobe systems inc 13102124 adobe photoshop cs 2 mac os x v. 10.2.8 to 10.3 | adobe systems inc |  788.63 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 543
rtable_id: 1667
label: 0