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

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

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

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

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



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

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

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

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

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 587
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 |
|:-----------------------------------------------|:---------------|--------:|
| microsoft productivity pack for windows mobile | microsoft      |   29.99 |

Entity B:
| title                                                          | manufacturer   |   price |
|:---------------------------------------------------------------|:---------------|--------:|
| microsoft windows services for netware v. 5.0 complete package |                |  138.17 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 492
rtable_id: 1961
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 ! 5 in 1 home design | punch ! software |   39.99 |

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



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

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

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

Entity A:
| title                                              | manufacturer   |   price |
|:---------------------------------------------------|:---------------|--------:|
| microsoft virtual pc for mac 7.0 with windows 2000 | microsoft      |  249.99 |

Entity B:
| title                                                         | manufacturer   |   price |
|:--------------------------------------------------------------|:---------------|--------:|
| microsoft windows vista business upgrade license 1 pc english |                |  168.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 145
rtable_id: 1137
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 |
|:------------------------------------|:---------------|--------:|
| coreldraw graphics suite x3 upgrade | corel          |     179 |

Entity B:
| title                                       | manufacturer   |   price |
|:--------------------------------------------|:---------------|--------:|
| coreldraw graphics suite x3 upgrade windows |                |   184.5 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 573
rtable_id: 1646
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 |
|:--------------------------------------------|:-----------------|--------:|
| punch ! home design architectural series 18 | punch ! software |  129.99 |

Entity B:
| title                                                                          | manufacturer   |   price |
|:-------------------------------------------------------------------------------|:---------------|--------:|
| punch software 42100 punch ! home design architectural series 18 ( small box ) | punch software |  119.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1272
rtable_id: 1342
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 |
|:--------------------------------------------------|:---------------|--------:|
| microsoft ( r ) windows vista ( tm ) home premium |                |  239.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 584
rtable_id: 1169
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 |
|:-----------------------------------------------------|:---------------|--------:|
| digidesign music production toolkit ( pro tools le ) | digidesign     |     495 |

Entity B:
| title                                             | manufacturer   |   price |
|:--------------------------------------------------|:---------------|--------:|
| ableton live 6 software music production software |                |     499 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 804
rtable_id: 2207
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 upsell | adobe          |    1199 |

Entity B:
| title                                       | manufacturer   |   price |
|:--------------------------------------------|:---------------|--------:|
| adobe cs3 master collection upsell from cs1 |                | 2054.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 897
rtable_id: 950
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 deluxe 2.0 | topics entertainment |   49.99 |

Entity B:
| title                                                                | manufacturer   |   price |
|:---------------------------------------------------------------------|:---------------|--------:|
| topics entertainment 80542 instant immersion french 2.0 781735805428 |                |    18.2 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 515
rtable_id: 2227
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 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: 515
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 |
|:-----------------------------------------------|:---------------|--------:|
| microsoft office 2004 standard upgrade ( mac ) | microsoft      |  239.99 |

Entity B:
| title                                                                            | manufacturer   |   price |
|:---------------------------------------------------------------------------------|:---------------|--------:|
| 164-04052 microsoft office publisher 2007 version upgrade package 1 pc cd win en |                |    88.8 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 518
rtable_id: 1805
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 5.0 premiere elements 3.0 bundle | adobe          |  149.99 |

Entity B:
| title                                                       | manufacturer   |   price |
|:------------------------------------------------------------|:---------------|--------:|
| adobe photoshop elements 4.0 photo-editing software for mac |                |   85.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 546
rtable_id: 750
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 |
|:---------------------------------------------------|:-------------------|--------:|
| foreign policy & reform ( win/mac ) ( jewel case ) | fogware publishing |    9.99 |

Entity B:
| title                                                         | manufacturer   |   price |
|:--------------------------------------------------------------|:---------------|--------:|
| poetry fiction and drama ( win/mac ) ( jewel case ) ( 10172 ) |                |    9.59 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 112
rtable_id: 3119
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   |
|:-----------------------------------------------------|:---------------|:--------|
| upgrade emc retrospect 7.5 multi server windows only | dantz          |         |

Entity B:
| title                                     | manufacturer   |   price |
|:------------------------------------------|:---------------|--------:|
| emc insignia retrospect desktop 6 upgrade |                |   49.99 |



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

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

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

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

Entity B:
| title                                                                            | manufacturer   |   price |
|:---------------------------------------------------------------------------------|:---------------|--------:|
| 269-10040 microsoft office professional edition 2003 service pack v. 2 media vol |                |   23.53 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 594
rtable_id: 100
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 |
|:--------------------------------------------------|:---------------------------|--------:|
| scansoft paperport professional 11 5 user license | nuance communications inc. |  949.99 |

Entity B:
| title                                                                                  | manufacturer   |   price |
|:---------------------------------------------------------------------------------------|:---------------|--------:|
| fw-6900-2006 ws_ftp professional 2006 license + 1 year service agreement 5 users win - |                |  264.58 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 198
rtable_id: 1836
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 [ mac ] | adobe          |     999 |

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



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

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

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

Entity A:
| title                          | manufacturer     | price   |
|:-------------------------------|:-----------------|:--------|
| ideasoft photo clip art 10 000 | nova development |         |

Entity B:
| title                                               | manufacturer   |   price |
|:----------------------------------------------------|:---------------|--------:|
| nova development corp ideasoft photo clip art 10000 |                |    7.81 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 619
rtable_id: 290
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 licenses exch . srvr extrn conn sa eng ( 39400416 ) | microsoft licenses | 42166.2 |

Entity B:
| title                                               | manufacturer   |   price |
|:----------------------------------------------------|:---------------|--------:|
| microsoft 394-00416 opens exch svr exconn l/sa qual |                | 22575.1 |



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

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

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

Entity A:
| title           | manufacturer   |   price |
|:----------------|:---------------|--------:|
| sony acid pro 5 | sony           |  399.95 |

Entity B:
| title                                                             | manufacturer                        |   price |
|:------------------------------------------------------------------|:------------------------------------|--------:|
| sony media software acid pro 6 software music production software | sony-pictures-digital-entertainment |  299.95 |



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

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

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

Entity A:
| title                                  | manufacturer     |   price |
|:---------------------------------------|:-----------------|--------:|
| spy sweeper w/antivirus family edition | webroot software |   49.95 |

Entity B:
| title                                   | manufacturer   |   price |
|:----------------------------------------|:---------------|--------:|
| family tree maker 16 collectors edition |                |   99.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 999
rtable_id: 3207
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 german deluxe 2.0 | topics entertainment |   39.99 |

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



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

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

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

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

Entity B:
| title                                 | manufacturer   |   price |
|:--------------------------------------|:---------------|--------:|
| adobe cs3 flash professional academic |                |  239.99 |



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

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

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

Entity A:
| title                                               | manufacturer       |   price |
|:----------------------------------------------------|:-------------------|--------:|
| microsoft licenses project svr sa govt ( h2200301 ) | microsoft licenses |  3601.4 |

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



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

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

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

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

Entity B:
| title                                                                                         | manufacturer   |   price |
|:----------------------------------------------------------------------------------------------|:---------------|--------:|
| avid liquid 7.0 professional video editing software for windows professional editing software |                |  439.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 654
rtable_id: 2766
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 |
|:---------------------------------------|:----------------|--------:|
| printmaster 17 gold by encore software | encore software |   30.66 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1038
rtable_id: 741
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 |
|:------------------------------------------|:---------------|--------:|
| steinberg cubase 4 digital audio software | steinberg      |  999.99 |

Entity B:
| title                                                                                            | manufacturer   |   price |
|:-------------------------------------------------------------------------------------------------|:---------------|--------:|
| steinberg wavelab studio 6 audio editing software educational discount music production software |                |  149.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1170
rtable_id: 2331
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 |
|:-------------------------------|:---------------|--------:|
| sims 2 glamour life stuff pack | aspyr media    |   24.99 |

Entity B:
| title                                          | manufacturer   |   price |
|:-----------------------------------------------|:---------------|--------:|
| aspyr media inc sims 2 glamour life stuff pack |                |   23.44 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1191
rtable_id: 567
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 audition 2.0 upgrade | adobe          |     129 |

Entity B:
| title                                                                                      | manufacturer        |   price |
|:-------------------------------------------------------------------------------------------|:--------------------|--------:|
| adobe audition 2.0 audio production software educational discount audio software for video | adobe-education-box |  148.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 504
rtable_id: 2292
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 elements 3.0 [ lb ] | adobe          |   99.99 |

Entity B:
| title                            | manufacturer   |   price |
|:---------------------------------|:---------------|--------:|
| adobe photoshop elements 4.0 mac |                |   79.99 |



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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 512
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 flash pro cs3 upgrade [ mac ] | adobe          |     199 |

Entity B:
| title                                  | manufacturer        |   price |
|:---------------------------------------|:--------------------|--------:|
| adobe illustrator cs3 for mac academic | adobe-education-box |  199.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1262
rtable_id: 358
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 |
|:-------------------------------------------------------------------------------------------------------------------------------------------------------------|:---------------|--------:|
| sonicwall 01-ssc-6997 3yr snwl client/server anti-virus 1000u sonicwall client/server anti-virus suite subscription license 3 years 1000 users 0758479069973 |                | 58683.4 |



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

Entity B:
| title                                           | manufacturer   |   price |
|:------------------------------------------------|:---------------|--------:|
| punch software 20100 punch ! 5 in 1 home design | punch software |   35.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1275
rtable_id: 783
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 frontpage 2003 academic version windows ) | microsoft      |  159.98 |

Entity B:
| title                                     | manufacturer   |   price |
|:------------------------------------------|:---------------|--------:|
| microsoft windows xp home edition sp2 oem |                |   95.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 93
rtable_id: 375
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 non-profit edition 2005 | intuit inc.    |  499.95 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 396
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 |
|:---------------------------------|:---------------|--------:|
| apple final cut studio 2 ( mac ) | apple          |    1299 |

Entity B:
| title                                                 | manufacturer   |   price |
|:------------------------------------------------------|:---------------|--------:|
| apple software m9372z/a final cut express 2.0 upgrade | apple software |   79.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1111
rtable_id: 2621
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 |
|:-----------------|:---------------|--------:|
| jeopardy! deluxe | encore         |   19.99 |

Entity B:
| title                  | manufacturer   |   price |
|:-----------------------|:---------------|--------:|
| aspyr simcity 4 deluxe |                |   53.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 786
rtable_id: 370
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 excel 2004 ( mac ) | microsoft      |  229.99 |

Entity B:
| title                                     | manufacturer   |   price |
|:------------------------------------------|:---------------|--------:|
| word mac 2004 upgrade microsoft d48-00488 |                |   97.36 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 781
rtable_id: 2474
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 |
|:---------------------------------------------------------|:---------------|--------:|
| modeless liquid ledger personal finance software ( mac ) | csdc           |   79.99 |

Entity B:
| title                                                        | manufacturer   |   price |
|:-------------------------------------------------------------|:---------------|--------:|
| freeverse software 005 solace ( mac 9.1-9.x 10.1 or higher ) |                |   18.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1075
rtable_id: 1384
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 |
|:------------------------------|:---------------|--------:|
| hoyle mahjongg ( jewel case ) | encore         |    9.99 |

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



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

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

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

Entity A:
| title                                        | manufacturer   |   price |
|:---------------------------------------------|:---------------|--------:|
| adobe after effects 7.0 professional ( mac ) | adobe          |     999 |

Entity B:
| title                                 | manufacturer   |   price |
|:--------------------------------------|:---------------|--------:|
| adobe cs3 flash professional academic |                |  239.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 333
rtable_id: 448
label: 0