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 |
|:-------------------------|:-----------------|--------:|
| punch 5 in 1 home design | punch ! software |   39.99 |

Entity B:
| title                                                            | manufacturer   |   price |
|:-----------------------------------------------------------------|:---------------|--------:|
| punch software 41100 punch ! home design architectural series 18 | punch software |  118.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1269
rtable_id: 2765
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 | adobe          |     999 |

Entity B:
| title                                | manufacturer   |   price |
|:-------------------------------------|:---------------|--------:|
| adobe cs3 master collection academic |                |  939.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 452
rtable_id: 338
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 |
|:-----------------------------------|:----------------|--------:|
| mother goose interactive storybook | encore software |   19.95 |

Entity B:
| title                        | manufacturer   |   price |
|:-----------------------------|:---------------|--------:|
| feral interactive the movies |                |   47.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 341
rtable_id: 556
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 academic microsoft office project 2003 standard |                |   69.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 522
rtable_id: 1120
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 upgrade [ mac ] | adobe          |     399 |

Entity B:
| title                                                                           | manufacturer   |   price |
|:--------------------------------------------------------------------------------|:---------------|--------:|
| adobe creative suite 3 design standard complete package 1 user academic windows |                |     369 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 465
rtable_id: 1146
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 xp professional edition ( upgrade ) |                |  199.99 |



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

Entity B:
| title                                  | manufacturer   |   price |
|:---------------------------------------|:---------------|--------:|
| systemsuite 6 ( tm ) professional mini |                |   49.99 |



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

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

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

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

Entity B:
| title                          | manufacturer   |   price |
|:-------------------------------|:---------------|--------:|
| production prem cs3 mac upgrad |                |  808.15 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 910
rtable_id: 3017
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 dreamweaver cs3 [ mac ] | adobe          |     399 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 559
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 |
|:---------------------------------------------------|:-------------------|--------:|
| microsoft windows xp professional upgrade with sp2 | microsoft software |  199.99 |

Entity B:
| title                                                                                | manufacturer   |   price |
|:-------------------------------------------------------------------------------------|:---------------|--------:|
| eu063av aba microsoft windows xp professional license and media 1 user cto english - |                |  137.09 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 512
rtable_id: 16
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 |
|:----------------------------------------|:----------------|--------:|
| reader rabbit learning system 1st grade | encore software |   29.99 |

Entity B:
| title                   | manufacturer   |   price |
|:------------------------|:---------------|--------:|
| reader rabbit 1st grade |                |    17.9 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 510
rtable_id: 2056
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 premiere pro cs3 | adobe          |     799 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 892
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 |
|:----------------------------------------|:----------------|--------:|
| 3d home architect landscape designer v8 | encore software |   29.99 |

Entity B:
| title                                                                                     | manufacturer   |   price |
|:------------------------------------------------------------------------------------------|:---------------|--------:|
| punch software 25100 punch ! master landscape & home design architectural 1 user ( s ) pc |                |   45.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 808
rtable_id: 1052
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 |
|:---------------------------------------------|:----------------|--------:|
| calendar creator platinum sb cs by riverdeep | encore software |   29.99 |

Entity B:
| title                      | manufacturer   |   price |
|:---------------------------|:---------------|--------:|
| calendar creator deluxe 10 |                |   49.87 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1086
rtable_id: 1109
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   |
|:--------------------------------------------------|:---------------------|:--------|
| sonicwall global vpn client license 01-ssc-5310 ) | sonic systems inc. . |         |

Entity B:
| title                                                                                | manufacturer   |   price |
|:-------------------------------------------------------------------------------------|:---------------|--------:|
| 01-ssc-3363 sonicwall global management system standard edition license 10 nodes win |                | 1835.31 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 197
rtable_id: 1892
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 33 languages | topics entertainment |   49.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: 276
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 |
|:------------------------------------|:---------------------|--------:|
| instant immersion french deluxe 2.0 | topics entertainment |   49.99 |

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



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

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

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

Entity A:
| title                                                  | manufacturer     | price   |
|:-------------------------------------------------------|:-----------------|:--------|
| century software tinyterm plus v. 4.0 complete product | century software |         |

Entity B:
| title                                                                                                                                          | manufacturer   |   price |
|:-----------------------------------------------------------------------------------------------------------------------------------------------|:---------------|--------:|
| punch software 17100 punch ! super home suite v. 3.0 complete product architectural 1 user complete productcomplete productstandard english pc |                |   45.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 875
rtable_id: 2438
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   |
|:--------------------|:---------------|:--------|
| videostudio 11 plus | corel          |         |

Entity B:
| title                  | manufacturer     |   price |
|:-----------------------|:-----------------|--------:|
| studio plus version 11 | pinnacle systems |   90.99 |



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

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

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

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

Entity B:
| title                      | manufacturer   |   price |
|:---------------------------|:---------------|--------:|
| encore marine aquarium 2.0 |                |   19.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1072
rtable_id: 402
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 | topics entertainment |   29.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 348
rtable_id: 239
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 iwork '06 family pack ( mac dvd ) [ older version ] | apple          |      99 |

Entity B:
| title                                                     | manufacturer   |   price |
|:----------------------------------------------------------|:---------------|--------:|
| apple iwork '06 family pack software apple & mac software |                |      99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 591
rtable_id: 2176
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 windows vista business full version [ dvd ] | microsoft      |  299.95 |

Entity B:
| title                                                                                | manufacturer   |   price |
|:-------------------------------------------------------------------------------------|:---------------|--------:|
| u84-00101 microsoft windows server 2003 for small business license 5 device cals ope |                |   303.9 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 584
rtable_id: 1828
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 office visio standard 2007 upgrade ( pc ) |                |  129.95 |



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

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

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

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

Entity B:
| title                                                                               | manufacturer   |   price |
|:------------------------------------------------------------------------------------|:---------------|--------:|
| 29500244 adobe creative suite 3 design premium product upgrade package 1 user upgra |                | 1687.48 |



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

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

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

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

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



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

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

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

Entity A:
| title                                                      | manufacturer    |   price |
|:-----------------------------------------------------------|:----------------|--------:|
| adventure workshop 4th-6th grade 7th ed sb cs by riverdeep | encore software |   19.99 |

Entity B:
| title                                                   | manufacturer   |   price |
|:--------------------------------------------------------|:---------------|--------:|
| encore inc adventure workshop 4th-6th grade 8th edition |                |    17.1 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1064
rtable_id: 691
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 architectura series 18 | punch ! software |  129.99 |

Entity B:
| title                                                                                                                                             | manufacturer   |   price |
|:--------------------------------------------------------------------------------------------------------------------------------------------------|:---------------|--------:|
| punch software 41100 punch ! home design architectural series 18 complete product architectural 1 user ( s ) complete product standard english pc |                |  112.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1258
rtable_id: 1044
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 |
|:-----------------------------------|:---------------|--------:|
| mac os x server v10 .4.7 10-client | apple          |     499 |

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



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

Entity B:
| title                                                           | manufacturer   |   price |
|:----------------------------------------------------------------|:---------------|--------:|
| encore software 10691 the print shop 22 sb cs by the print shop |                |   25.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 40
rtable_id: 2093
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 |
|:---------------------------|:--------------------|--------:|
| systemsuite 8 professional | individual software |   49.99 |

Entity B:
| title                     | manufacturer   |   price |
|:--------------------------|:---------------|--------:|
| orgchart professional 1.3 |                |   39.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1293
rtable_id: 2998
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 distiller svr v6-cd sun 100u 42050106 ) | adobe          | 9104.19 |

Entity B:
| title                                               | manufacturer   |   price |
|:----------------------------------------------------|:---------------|--------:|
| adobe 42050106 acrobat distiller svr v6-cd sun 100u | adobe          | 5399.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 187
rtable_id: 1516
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 |
|:-----------------------------------|:---------------|--------:|
| iriscard pro business card scanner | iris           |  199.99 |

Entity B:
| title                            | manufacturer   |   price |
|:---------------------------------|:---------------|--------:|
| palo alto business plan pro 2007 |                |   83.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 91
rtable_id: 3145
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 | topics entertainment |   29.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: 348
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 |
|:-----------------------------|:---------------|--------:|
| microsoft data analyzer 2002 | microsoft      |     179 |

Entity B:
| title                         | manufacturer   |   price |
|:------------------------------|:---------------|--------:|
| microsoft office outlook 2007 |                |  109.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 497
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 |
|:---------------------------|:---------------|--------:|
| microsoft works suite 2006 | microsoft      |      99 |

Entity B:
| title                               | manufacturer   |   price |
|:------------------------------------|:---------------|--------:|
| microsoft ( r ) mappoint ( r ) 2006 |                |  249.99 |



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

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

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

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

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 516
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 |
|:-------------------------------------|:----------------|--------:|
| broderbund printmaster platinum 16.0 | encore software |   39.99 |

Entity B:
| title                              | manufacturer   |   price |
|:-----------------------------------|:---------------|--------:|
| encore inc printmaster gold v 17.0 |                |    17.1 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 301
rtable_id: 219
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 dss software v. 4.0 complete package t1936aa ua0 ) | hewlett-packard - ( consumables ) |  630.36 |

Entity B:
| title                                                                                                                                                     | manufacturer                      |   price |
|:----------------------------------------------------------------------------------------------------------------------------------------------------------|:----------------------------------|--------:|
| hewlett packard t1936aa ua0 hp digital sending software 4.0 complete product document management 1 device ( s ) complete product standard multilingual pc | hewlett-packard - ( consumables ) |  342.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 799
rtable_id: 804
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 |
|:------------------|:-------------------|--------:|
| britannica deluxe | avanquest software |   29.95 |

Entity B:
| title                | manufacturer   |   price |
|:---------------------|:---------------|--------:|
| resume writer deluxe |                |    12.9 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 947
rtable_id: 2070
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 corel painter x pc/mac | corel          |  155.22 |

Entity B:
| title                                               | manufacturer   |   price |
|:----------------------------------------------------|:---------------|--------:|
| corel corporation ptr9engpcma ae painter ix win/mac |                |   89.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 830
rtable_id: 2494
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 |
|:---------------------------------|:---------------|--------:|
| scrabble complete ( jewel case ) | encore         |    9.99 |

Entity B:
| title                                         | manufacturer   |   price |
|:----------------------------------------------|:---------------|--------:|
| geometry ( win/mac ) ( jewel case ) ( 10158 ) |                |    9.59 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1303
rtable_id: 3106
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 academic |                |  339.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 883
rtable_id: 216
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 |
|:-----------------------------|:---------------|--------:|
| cell phone software solution | susteen        |   113.1 |

Entity B:
| title                                                | manufacturer   |   price |
|:-----------------------------------------------------|:---------------|--------:|
| steinberg software cubase se 3.0 educational edition |                |  145.73 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 432
rtable_id: 208
label: 0