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 ! master landscape & home design | punch ! software |   99.99 |

Entity B:
| title                                       | manufacturer   |   price |
|:--------------------------------------------|:---------------|--------:|
| punch software 90500 home design studio mac | punch software |  135.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1284
rtable_id: 2720
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 |
|:----------------------------------------------------|:---------------|--------:|
| windows vista business spanish full version [ dvd ] | microsoft      |  329.95 |

Entity B:
| title                                               | manufacturer   |   price |
|:----------------------------------------------------|:---------------|--------:|
| adobe ( r ) photoshop ( r ) cs windows full version |                |  590.92 |



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

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 371
rtable_id: 2206
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 home cooking ( jewel case ) | topics entertainment |    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: 331
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 indesign cs3 upgrade [ mac ] | adobe          |     199 |

Entity B:
| title                                 | manufacturer   |   price |
|:--------------------------------------|:---------------|--------:|
| adobe dreamweaver cs3 upgrade windows |                |  236.74 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 593
rtable_id: 1564
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 |
|:----------------|:---------------|--------:|
| restricted area | whiptail       |   19.99 |

Entity B:
| title                                 | manufacturer   |   price |
|:--------------------------------------|:---------------|--------:|
| restricted area ( win 98 me 2000 xp ) |                |   19.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 381
rtable_id: 2640
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 onenote 2007 upgrade | microsoft      |   79.95 |

Entity B:
| title                                                              | manufacturer   |   price |
|:-------------------------------------------------------------------|:---------------|--------:|
| microsoft office onenote 2007 complete package 1 pc cd win english |                |   78.99 |



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

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

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

Entity A:
| title                      | manufacturer    |   price |
|:---------------------------|:----------------|--------:|
| high school advantage 2007 | encore software |   29.95 |

Entity B:
| title                                                                    | manufacturer   |   price |
|:-------------------------------------------------------------------------|:---------------|--------:|
| encore software 10443 elementary school advantage 2007 win 98 me 2000 xp |                |   26.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1055
rtable_id: 772
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 |
|:-----------------------------|:---------------|--------:|
| axis & allies ( jewel case ) | encore         |    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: 933
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 |
|:-------------------------------------|:---------------|--------:|
| adobe after effects professional 7.0 | adobe          |     999 |

Entity B:
| title                                                            | manufacturer   |   price |
|:-----------------------------------------------------------------|:---------------|--------:|
| adobe acrobat 7.0 professional ( education version ) for windows |                |  154.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 250
rtable_id: 1148
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 |
|:-------------------------|:---------------------------|--------:|
| dk smart steps 3rd grade | global-software-publishing |    9.99 |

Entity B:
| title                                                                        | manufacturer   |   price |
|:-----------------------------------------------------------------------------|:---------------|--------:|
| global software a0447jch dk smart steps 2nd grade win 95 98 me 2000 xp vista |                |    9.08 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 709
rtable_id: 2768
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 mac os x v10 .4 tiger software family pack apple & mac software |                |  199.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 591
rtable_id: 2158
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 point-of-sale basic 6.0 | intuit         |  799.95 |

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



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

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

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

Entity A:
| title                                                 | manufacturer   |   price |
|:------------------------------------------------------|:---------------|--------:|
| quickbooks premier professional services edition 2007 | intuit         |  399.95 |

Entity B:
| title                   | manufacturer   |   price |
|:------------------------|:---------------|--------:|
| quickbooks pro 2007 win |                |  192.26 |



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

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

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

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

Entity B:
| title                                       | manufacturer   |   price |
|:--------------------------------------------|:---------------|--------:|
| punch software 90500 home design studio mac | punch software |  135.99 |



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

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

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

Entity A:
| title                                                 | manufacturer   |   price |
|:------------------------------------------------------|:---------------|--------:|
| microsoft windows vista ultimate full version [ dvd ] | microsoft      |  399.95 |

Entity B:
| title                                              | manufacturer   |   price |
|:---------------------------------------------------|:---------------|--------:|
| microsoft office and windows training professional |                |   29.99 |



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

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

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

Entity A:
| title                         | manufacturer        |   price |
|:------------------------------|:--------------------|--------:|
| resumemaker professional 12.0 | individual software |   29.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1021
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 |
|:---------------------------------------|:-----------------|--------:|
| punch ! master landscape & home design | punch ! software |   59.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: 1105
rtable_id: 783
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

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                                                                        | category              | brand   |   modelno |   price |
|:-----------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-glas deluxe rear projection screen - 40 1 4 x 53 3 4 video format | electronics - general | da-lite |     27655 | 1752.99 |

Entity B:
| title                                                        | category           | brand   | modelno                   |   price |
|:-------------------------------------------------------------|:-------------------|:--------|:--------------------------|--------:|
| da-lite deluxe model b video spectra 1.5 - projection screen | projection screens | da-lite | model b video spectra 1.5 |  125.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2504
rtable_id: 6745
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

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                                                                        | category              | brand   |   modelno |   price |
|:-----------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-glas deluxe rear projection screen - 40 1 4 x 53 3 4 video format | electronics - general | da-lite |     27655 | 1752.99 |

Entity B:
| title                                                   | category           | brand   | modelno   |   price |
|:--------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| da-glas base rear projection screen - 70 x 70 av format | projection screens | da-lite |           | 2622.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2504
rtable_id: 16333
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

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                                                                    | category              | brand   |   modelno |   price |
|:-------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-plex self trimming rear projection screen - 60 x 60 av format | electronics - general | da-lite |     27575 | 2680.99 |

Entity B:
| title                                                       | category           | brand   | modelno   |   price |
|:------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| da-plex standard rear projection screen - 96 x 96 av format | projection screens | da-lite |           | 5912.99 |



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

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                                                                        | category              | brand         | modelno   |   price |
|:-----------------------------------------------------------------------------|:----------------------|:--------------|:----------|--------:|
| elite screens cinegray prime vision series fixed frame screen - 135 diagonal | electronics - general | elite screens | pvr135h1  |    1069 |

Entity B:
| title                                                           | category           | brand   | modelno   |   price |
|:----------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| cinewhite prime vision series fixed frame screen - 150 diagonal | projection screens | elite   |           |    1179 |



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

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                                                       | category              | brand   | modelno        |   price |
|:------------------------------------------------------------|:----------------------|:--------|:---------------|--------:|
| evga geforce 8400 gs 1gb ddr3 pci express 2.0 graphics card | electronics - general | evga    | 01g-p3-1302-lr |   44.99 |

Entity B:
| title                                                                                                           | category       | brand   | modelno        |   price |
|:----------------------------------------------------------------------------------------------------------------|:---------------|:--------|:---------------|--------:|
| evga geforce 8400 gs passive 1024mb ddr3 pci-express 2.0 graphics card - 3 year limited warranty 01g-p3-1303-kr | graphics cards | evga    | 01g-p3-1303-kr |   37.24 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1893
rtable_id: 9134
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

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                                                                                 | category              | brand   |   modelno |   price |
|:--------------------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| roocase executive portfolio leather case w 2 screen protector for blackberry playbook | electronics - general | roocase |    220761 |   35.99 |

Entity B:
| title                                                                        | category      | brand   | modelno   |   price |
|:-----------------------------------------------------------------------------|:--------------|:--------|:----------|--------:|
| blurex slim leather portfolio case with 2 tier stand for blackberry playbook | cases sleeves | blurex  | pbsl510   |   19.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2236
rtable_id: 12255
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

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                                                              | category    | brand   |   modelno |   price |
|:-------------------------------------------------------------------|:------------|:--------|----------:|--------:|
| iomega 1tb ego desktop usb 2.0 portable hard drive - midnight blue | hard drives | iomega  |     34837 |   89.98 |

Entity B:
| title                                                              | category             | brand   |   modelno |   price |
|:-------------------------------------------------------------------|:---------------------|:--------|----------:|--------:|
| iomega ego usb 2.0 500 gb compact portable hard drive 34896 silver | external hard drives | iomega  |     34896 |      81 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1979
rtable_id: 4860
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

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                                | category   | brand   | modelno   |   price |
|:-------------------------------------|:-----------|:--------|:----------|--------:|
| hp 27 black inkjet cartridge c8727an | printers   | hp      | c8727an   |   19.97 |

Entity B:
| title                                                     | category           | brand   | modelno    |   price |
|:----------------------------------------------------------|:-------------------|:--------|:-----------|--------:|
| hp 27 black ink cartridge in retail packaging c8727an 140 | inkjet printer ink | hp      | hewc8727an |   18.61 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 428
rtable_id: 6990
label: 1
Task: Entity-Matching (source dataset: Walmart-Amazon)

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                                   | category   | brand   | modelno   |   price |
|:----------------------------------------|:-----------|:--------|:----------|--------:|
| lacie fastkey 120gb usb 3.0 flash drive | usb drives | lacie   | lac130980 |     449 |

Entity B:
| title                                            | category         | brand   |   modelno |   price |
|:-------------------------------------------------|:-----------------|:--------|----------:|--------:|
| lacie iamakey v2 4 gb usb 2.0 flash drive 131104 | usb flash drives | lacie   |    131104 |   17.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2438
rtable_id: 12837
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

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                                                    | category    | brand   | modelno     |   price |
|:---------------------------------------------------------|:------------|:--------|:------------|--------:|
| iosafe rugged 250gb usb 3.0 portable external hard drive | hard drives | iosafe  | pa50250u5yr |  249.99 |

Entity B:
| title                                                                 | category             | brand   | modelno     |   price |
|:----------------------------------------------------------------------|:---------------------|:--------|:------------|--------:|
| iosafe rugged portable 500 gb usb 3.0 external hard drive pa50500u1yr | external hard drives | iosafe  | pa50500u1yr |  149.98 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 672
rtable_id: 14820
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

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                                                                                          | category              | brand   | modelno   |   price |
|:-----------------------------------------------------------------------------------------------|:----------------------|:--------|:----------|--------:|
| casio pouch style leather carrying case for the exilim s and z series digital cameras - 2.75 d | photography - general | casio   | ex-case2  |   14.98 |

Entity B:
| title                                                                           | category       | brand   | modelno   |   price |
|:--------------------------------------------------------------------------------|:---------------|:--------|:----------|--------:|
| new-slim leather case for stylus and fe series digital cameras - black - t38028 | accessory kits | olympus |           |      31 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 643
rtable_id: 270
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

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                                                            | category   | brand    | modelno       |   price |
|:-----------------------------------------------------------------|:-----------|:---------|:--------------|--------:|
| kingston kth-mlg4 2g 2gb ddr2 240-pin sdram server memory module | memory     | kingston | kth-mlg4 / 2g |   55.92 |

Entity B:
| title                                                                               | category   | brand    | modelno        |   price |
|:------------------------------------------------------------------------------------|:-----------|:---------|:---------------|--------:|
| kingston 8 gb ddr2 sdram memory module 8 gb 2 x 4 gb 667mhz ddr2 sdram kth-xw667 8g | memory     | kingston | kth-xw667 / 8g |  220.74 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1937
rtable_id: 11056
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

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                                                             | category                   | brand   | modelno   |   price |
|:------------------------------------------------------------------|:---------------------------|:--------|:----------|--------:|
| pilot begreen b2p roller ball retractable gel ink pen red 5 count | electronics-inflexible kit |         |           |     7.5 |

Entity B:
| title                                                                    | category           | brand   | modelno   |   price |
|:-------------------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| uni-ball 65872 - 207 impact roller ball retractable gel pen red ink bold | inkjet printer ink | uniball |           |    21.3 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 333
rtable_id: 6550
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

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                                                    | category    | brand   | modelno     |   price |
|:---------------------------------------------------------|:------------|:--------|:------------|--------:|
| iosafe rugged 750gb usb 3.0 portable external hard drive | hard drives | iosafe  | pa70750u1yr |  139.98 |

Entity B:
| title                                                               | category              | brand   |   modelno | price   |
|:--------------------------------------------------------------------|:----------------------|:--------|----------:|:--------|
| iomega ego helium 320 gb usb 2.0 portable external hard drive 34943 | computers accessories | iomega  |     34943 |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 176
rtable_id: 12918
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

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                               | category   | brand   | modelno   |   price |
|:------------------------------------|:-----------|:--------|:----------|--------:|
| hon 310 series full-suspension file | storage    | hon     | 315cpp    |     549 |

Entity B:
| title                                                                              | category                       | brand   | modelno   | price   |
|:-----------------------------------------------------------------------------------|:-------------------------------|:--------|:----------|:--------|
| hon 514cpq - 510 series four-drawer full-suspension file legal 52h x25d light gray | storage presentation materials | hon     |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 497
rtable_id: 18462
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

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                 | category              | brand     | modelno   |   price |
|:----------------------|:----------------------|:----------|:----------|--------:|
| energizer max aaa 6pk | electronics - general | energizer | e92bp-6r  |       0 |

Entity B:
| title                        | category            | brand     | modelno   |   price |
|:-----------------------------|:--------------------|:----------|:----------|--------:|
| energizer max n size 2-count | household batteries | energizer |           |    3.15 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 391
rtable_id: 4794
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

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                                                             | category              | brand   | modelno   |   price |
|:------------------------------------------------------------------|:----------------------|:--------|:----------|--------:|
| coby purple high-performance isolation stereo earphones cvem79pur | electronics - general | coby    | cvem79pur |    8.54 |

Entity B:
| title                                                                           | category   | brand   | modelno   |   price |
|:--------------------------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| coby jammerz platinum high-performance isolation stereo earphones cvem79red red | headphones | coby    | cvem79red |    7.35 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2105
rtable_id: 12536
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

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                                                             | category              | brand   |   modelno |   price |
|:------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-glas deluxe rear projection screen - 84 x 84 av format | electronics - general | da-lite |     27650 | 4958.99 |

Entity B:
| title                                                          | category           | brand   | modelno     |   price |
|:---------------------------------------------------------------|:-------------------|:--------|:------------|--------:|
| da-lite deluxe model b matte white - projection screen - 72 in | projection screens | da-lite | matte white |   127.1 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2389
rtable_id: 20715
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

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                                                                 | category              | brand   |   modelno |   price |
|:----------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-glas standard rear projection screen 81 x 108 video format | electronics - general | da-lite |     27917 | 5391.99 |

Entity B:
| title                                                                   | category           | brand   | modelno   | price   |
|:------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| da-lite 27651 da-glas deluxe rear projection screen - 96 x 96 av format | projection screens | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 822
rtable_id: 18153
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

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                                                   | category              | brand    | modelno   |   price |
|:--------------------------------------------------------|:----------------------|:---------|:----------|--------:|
| startech.com pex1p 1 port pcie dp parallel adapter card | electronics - general | startech | pex1p     |   32.88 |

Entity B:
| title                                                                | category       | brand    | modelno    |   price |
|:---------------------------------------------------------------------|:---------------|:---------|:-----------|--------:|
| startech.com 1 port pci rs232 powered serial adapter card pci1s650pw | i o port cards | startech | pci1s650pw |   36.78 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 687
rtable_id: 16750
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

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                                                  | category   | brand   |   modelno |   price |
|:-------------------------------------------------------|:-----------|:--------|----------:|--------:|
| adobe software photoshop premiere element bd version 8 | software   | adobe   |  65045677 |  149.99 |

Entity B:
| title                                                            | category      | brand   |   modelno |   price |
|:-----------------------------------------------------------------|:--------------|:--------|----------:|--------:|
| adobe photoshop elements 5.0 premier elements 3.0 lb old version | photo editing | adobe   |  29180251 |  111.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1028
rtable_id: 18409
label: 0