MMTU-benchmark/MMTU huggingface dataset:
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 matte white model c with csr manual screen - 50 x 67 video format | electronics - general | da-lite |     91841 |  397.99 |

Entity B:
| title                                                                            | category           | brand   | modelno   |   price |
|:---------------------------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| da-lite designer contour manual with csr - projection screen - 1 1 - matte white | projection screens | da-lite |           |  299.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 993
rtable_id: 6752
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 |
|:----------------------------------------------|:-----------|:----------------|:----------|--------:|
| pinnacle studio hd v15 ultimate collection pc | software   | avid technology |           |     119 |

Entity B:
| title                    | category              | brand   |     modelno |   price |
|:-------------------------|:----------------------|:--------|------------:|--------:|
| pinnacle studio hd v. 15 | computers accessories | avid    | 82103001801 |   44.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1613
rtable_id: 7732
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 45 black inkjet cartridge 51645a | printers   | hp      | 51645a    |   35.78 |

Entity B:
| title                                | category           | brand   | modelno   |   price |
|:-------------------------------------|:-------------------|:--------|:----------|--------:|
| epson t032120 black inkjet cartridge | inkjet printer ink | epson   | t032120   |    14.2 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 34
rtable_id: 5118
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 |
|:-----------------------------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| smead acid-free poly folder 2 fasteners 1 3 cut top tab letter manila 24 box | stationery & office machinery |         |     10545 |   42.94 |

Entity B:
| title                                                                              | category                       | brand   | modelno   |   price |
|:-----------------------------------------------------------------------------------|:-------------------------------|:--------|:----------|--------:|
| smead 10343 - watershed cutless file folders 1 3 cut top tab letter manila 100 box | storage presentation materials | smead   |           |   57.08 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1689
rtable_id: 20801
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 exilim ex-zs10 14.1 mp digital camera blue w 5x optical zoom 2.7 lcd display | digital cameras | casio   | ex-zs10be |     120 |

Entity B:
| title                                                                                | category                    | brand   | modelno   |   price |
|:-------------------------------------------------------------------------------------|:----------------------------|:--------|:----------|--------:|
| casio exilim ex-s8 12 mp digital camera with 4x optical zoom and 2.7-inch lcd purple | point shoot digital cameras | casio   | exs8pe    |   104.9 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2395
rtable_id: 14483
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 |
|:--------------------------------------------------------|:-----------|:--------|:----------|--------:|
| centon 16gb datastick pro usb flash drive 2-pack bundle | computers  |         |           |      42 |

Entity B:
| title                                                    | category            | brand   | modelno    |   price |
|:---------------------------------------------------------|:--------------------|:--------|:-----------|--------:|
| centon 4 gb datastick pro usb 2.0 flash drive dsp4gb-007 | computer components | centon  | dsp4gb-007 |   10.98 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1869
rtable_id: 15515
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 |
|:----------------------------------------------------|:----------------|:-------------------|:----------|--------:|
| griffin technology outfit gloss ipod touch 4g black | mp3 accessories | griffin technology | gb01967   |   24.99 |

Entity B:
| title                                                         | category   | brand              | modelno   |   price |
|:--------------------------------------------------------------|:-----------|:-------------------|:----------|--------:|
| griffin technology gb01956 motif gloss case for ipod touch 4g | cases      | griffin technology | gb01956   |   12.34 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 218
rtable_id: 13087
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 |
|:---------------------------------|:----------------------|:---------|----------:|--------:|
| fellowes goriser laptop elevator | electronics - general | fellowes |   8030401 |   21.88 |

Entity B:
| title                           | category                            | brand    |   modelno |   price |
|:--------------------------------|:------------------------------------|:---------|----------:|--------:|
| fellowes 8030401 laptop goriser | laptop netbook computer accessories | fellowes |   8030401 |   14.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1758
rtable_id: 13845
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 |
|:------------------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-plex self trimming rear projection screen - 40 1 4 x 53 3 4 video format | electronics - general | da-lite |     27580 | 1892.99 |

Entity B:
| title                                                                              | category           | brand   | modelno   | price   |
|:-----------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| da-lite 27636 da-glas standard rear projection screen 50 1 2 x 67 1 4 video format | projection screens | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2332
rtable_id: 2818
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 |
|:---------------------------------------------------------------------|:------------|:----------------|:-------------------|--------:|
| western digital elements 500gb portable se portable hard drive black | hard drives | western digital | wdbabv5000abk-nesn |   71.98 |

Entity B:
| title                                                                                              | category             | brand           | modelno            |   price |
|:---------------------------------------------------------------------------------------------------|:---------------------|:----------------|:-------------------|--------:|
| western digital my passport essential 500 gb usb 3.0 2.0 portable external hard drive pacific blue | external hard drives | western digital | wdbacy5000abl-nesn |   75.98 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1141
rtable_id: 13253
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 unframed rear projection screen - 57 3 4 x 77 video format | electronics - general | da-lite |     27604 | 1609.99 |

Entity B:
| title                                                                       | category           | brand   |   modelno |   price |
|:----------------------------------------------------------------------------|:-------------------|:--------|----------:|--------:|
| da lite data pro thru-the-wall rear projection screen - 45 x 80 hdtv format | projection screens | da-lite |     23179 |   11773 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1296
rtable_id: 20121
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 |
|:--------------------------------------|:----------------------|:--------|:----------|--------:|
| new york mets ipod touch 4g hard case | electronics - general | tribeca | fva4459   |   29.99 |

Entity B:
| title                                      | category              | brand   | modelno   |   price |
|:-------------------------------------------|:----------------------|:--------|:----------|--------:|
| los angeles lakers ipod touch 4g hard case | computers accessories | tribeca |           |   29.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 960
rtable_id: 18372
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 |
|:------------------------------|:----------------------|:-----------|----------:|--------:|
| case logic 16 laptop backpack | electronics - general | case logic |    154710 |   39.99 |

Entity B:
| title                                                 | category   | brand      | modelno           |   price |
|:------------------------------------------------------|:-----------|:-----------|:------------------|--------:|
| case logic dlbp-114 14-inch laptop backpack dark gray | bags cases | case logic | dlbp-114dark gray |   39.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 661
rtable_id: 2591
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 |
|:-------------------------------------------------------|:-----------|:--------|:----------|--------:|
| crown cushion-step rubber mat 36 x 72 marbleized black | home care  | crown   | cu3672bk  |  194.97 |

Entity B:
| title                                                            | category            | brand   | modelno   | price   |
|:-----------------------------------------------------------------|:--------------------|:--------|:----------|:--------|
| crown cu3672gy - cushion-step mat rubber 36 x 72 marbleized gray | networking products | crown   |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2021
rtable_id: 18319
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 q1421a universal semi-gloss photo paper | stationery & office machinery | hp      | q1421a    |   94.88 |

Entity B:
| title                          | category            | brand   | modelno   |   price |
|:-------------------------------|:--------------------|:--------|:----------|--------:|
| hp q1397a universal bond paper | printer accessories | hp      |           |   33.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1626
rtable_id: 18457
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 |
|:----------------------------------------------------|:-----------------|:----------|:-----------|--------:|
| panasonic bb-hcm580a poe zoom mpeg-4 network camera | garden - general | panasonic | bb-hcm580a |  779.82 |

Entity B:
| title                                                           | category             | brand     | modelno   |   price |
|:----------------------------------------------------------------|:---------------------|:----------|:----------|--------:|
| panasonic bl-c160a outdoor lighted mpeg-4 network camera silver | surveillance cameras | panasonic | bl-c160a  |  247.89 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2340
rtable_id: 20832
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 |
|:-------------------------------------------------|:----------------------|:--------|:----------|--------:|
| msw wireless jawbone icon bluetooth headset mesh | electronics - general | jawbone | jbg01ms   |   72.98 |

Entity B:
| title                                    | category           | brand    |   modelno |   price |
|:-----------------------------------------|:-------------------|:---------|----------:|--------:|
| motorola h270 bluetooth wireless headset | bluetooth headsets | motorola |     89286 |   14.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 755
rtable_id: 18991
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 |
|:----------------------------------------------------|:---------------|:--------|----------:|--------:|
| zax 87303 pro series 3m composite audio video cable | tv accessories | zax     |     87303 |   10.88 |

Entity B:
| title                                     | category              | brand   | modelno   | price   |
|:------------------------------------------|:----------------------|:--------|:----------|:--------|
| zax 87510 pro series rca audio cable 10 m | computers accessories | zax     |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1592
rtable_id: 242
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 |
|:---------------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| acco vinyl report cover prong clip letter 1 2 capacity 10-pack | stationery & office machinery | acco    |     26101 |   10.94 |

Entity B:
| title                                                                            | category   | brand   | modelno   | price   |
|:---------------------------------------------------------------------------------|:-----------|:--------|:----------|:--------|
| oxford 12706 - pressguard coated report cover prong clip letter 3 capacity black |            | oxford  |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1172
rtable_id: 17030
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 ce278a black laserjet print cartridge | printers   | hp      | hp ce278a |   69.84 |

Entity B:
| title                                                     | category            | brand   | modelno   |   price |
|:----------------------------------------------------------|:--------------------|:--------|:----------|--------:|
| hp laserjet 15a black print cartridge in retail packaging | laser printer toner | hp      | c7115a    |      52 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 25
rtable_id: 1036
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 |
|:------------------------------------------|:-----------|:--------|:-----------------|--------:|
| epson t068120-d2 dual black ink cartridge | printers   | epson   | epson t068120-d2 |   39.84 |

Entity B:
| title                                         | category           | brand   | modelno    |   price |
|:----------------------------------------------|:-------------------|:--------|:-----------|--------:|
| epson 68 black ink cart hi capacity dual pack | inkjet printer ink | epson   | t068120-d1 |    36.9 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1631
rtable_id: 15098
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 hc cinema vision tensioned cosmopolitan electrol - av format 7 x 9 diagonal | electronics - general | da-lite |     89892 |    2240 |

Entity B:
| title                                                                               | category           | brand   | modelno   | price   |
|:------------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| da-lite 98801 hc da-mat tensioned cosmopolitan electrol - video format 210 diagonal | projection screens | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 856
rtable_id: 17186
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 |
|:--------------------------------------------------|:-----------|:---------|----------:|--------:|
| verbatim 96438 2gb store n go usb 2.0 flash drive | usb drives | verbatim |     96438 |   14.84 |

Entity B:
| title                                                             | category         | brand    |   modelno |   price |
|:------------------------------------------------------------------|:-----------------|:---------|----------:|--------:|
| verbatim store n go netbook 16 gb usb 2.0 flash drive 97464 black | usb flash drives | verbatim |     97464 |   26.76 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 547
rtable_id: 9294
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 |
|:--------------------------------------------------------------------------------------|:---------------------|:--------|:----------|--------:|
| scosche 1974-up ford chrysler jeep multi-purpose kit including 1999-up grand cherokee | automotive - general | scosche | fcj1276ab |   11.37 |

Entity B:
| title                                                                                                           | category                | brand   | modelno   |   price |
|:----------------------------------------------------------------------------------------------------------------|:------------------------|:--------|:----------|--------:|
| scosche fcj1276ab 1974-up ford chrysler jeep multi-purpose kit including 1999-up grand cherokee intrepid cr1277 | audio video accessories | scosche | fcj1276ab |   11.37 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 903
rtable_id: 16989
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 |
|:------------------------------------------|:-----------|:--------|:----------|--------:|
| sabrent usb 2.0 wireless 802.11 g adapter | networking | sabrent | nt-wghu   |   24.88 |

Entity B:
| title                                                                                           | category            | brand   | modelno   |   price |
|:------------------------------------------------------------------------------------------------|:--------------------|:--------|:----------|--------:|
| sabrent wireless 802.11 n wi-fi mimo network usb 2.0 300 mbps wlan adapter with antenna booster | networking products | sabrent | usb-a11n  |   34.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 131
rtable_id: 1641
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 |
|:-----------------------------------------|:--------------|:--------|:----------|--------:|
| crosley radio keepsake usb turntable tan | stereos/audio | arkon   | cr249-ta  |     118 |

Entity B:
| title                                         | category   | brand   | modelno   |   price |
|:----------------------------------------------|:-----------|:--------|:----------|--------:|
| crosley cr249 bk keepsake usb turntable black | turntables | crosley | cr249 bk  |  113.89 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 931
rtable_id: 12483
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 unframed rear projection screen - 43 1 4 x 57 3 4 video format | electronics - general | da-lite |     27602 |  920.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 967
rtable_id: 20125
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 |
|:----------------------------------|:----------------|:--------|-------------:|--------:|
| marware microshell for ipad black | mp3 accessories |         | 602956006664 |   39.99 |

Entity B:
| title                                           | category      | brand   |      modelno |   price |
|:------------------------------------------------|:--------------|:--------|-------------:|--------:|
| marware microshell for ipad 2 pink 602956008576 | cases sleeves | marware | 602956008576 |   16.56 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1705
rtable_id: 12728
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 |
|:-----------------------------------------------------------------------------|:----------------------|:--------|:-------------|--------:|
| vantec nexstar3 superspeed 2.5 sata to usb 3.0 external hard drive enclosure | electronics - general | vantec  | nst-280s3-bk |   26.62 |

Entity B:
| title                                                                                             | category              | brand   | modelno      |   price |
|:--------------------------------------------------------------------------------------------------|:----------------------|:--------|:-------------|--------:|
| vantec nexstar 3 nst-360u2-rd 3.5-inch ide to usb 2.0 external hard drive enclosure brilliant red | hard drive enclosures | vantec  | nst-360u2-rd |   29.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2255
rtable_id: 12058
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 |
|:---------------------------------------|:----------------------|:--------|:-------------|--------:|
| sony zx series stereo headphones white | electronics - general | sony    | mdrzx100/whi |   24.88 |

Entity B:
| title                            | category              | brand   | modelno   |   price |
|:---------------------------------|:----------------------|:--------|:----------|--------:|
| sony mdr-xd100 stereo headphones | home audio crossovers | sony    | mdrxd100  |      14 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1862
rtable_id: 9497
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 |
|:--------------------------------|:-------------|:--------|----------:|--------:|
| sakar crayola digital camcorder | toys - games | sakar   |     32070 |   46.48 |

Entity B:
| title                                       | category     | brand   |   modelno |   price |
|:--------------------------------------------|:-------------|:--------|----------:|--------:|
| sakar 32070 crayola digital camcorder green | camera photo | sakar   |     32070 |    33.5 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1484
rtable_id: 15558
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 |
|:----------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| 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-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: 822
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 |
|:---------------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| v7 m42n01-7n 2.4 ghz wireless laser mouse with stoable nano receiver | mice       | v7      | m42n01-7n |   24.84 |

Entity B:
| title                                                       | category   | brand   | modelno   |   price |
|:------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| v7 3 button 2.4 ghz laser mouse with storable nano receiver | mice       | v7      | m42n01-7n |   19.23 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1936
rtable_id: 11295
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 |
|:--------------------------------------------------------------------------------------------------------------------|:------------|:----------------|:-----------|--------:|
| western digital scorpio blue 120gb notebook internal hard drive 5400rpm eide 8mb cache 100mb s 2.5 wd1200beve - oem | hard drives | western digital | wd1200beve |   64.82 |

Entity B:
| title                                                                                                      | category              | brand           | modelno    |   price |
|:-----------------------------------------------------------------------------------------------------------|:----------------------|:----------------|:-----------|--------:|
| western digital 500 gb scorpio blue sata 3gb s 5400 rpm 8 mb cache bulk oem notebook hard drive wd5000bpvt | computers accessories | western digital | wd5000bpvt |   57.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1154
rtable_id: 11235
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 |
|:--------------------------------------|:---------------------------------|:--------|:-----------|--------:|
| sunpak 67mm circular polarized filter | camera and camcorder accessories | sunpak  | cf-7061 cp |      18 |

Entity B:
| title                                       | category       | brand   | modelno   |   price |
|:--------------------------------------------|:---------------|:--------|:----------|--------:|
| new-67mm circular polarized filter - t43853 | accessory kits | sunpak  |           |     111 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 720
rtable_id: 21218
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 lithium aaa battery | electronics - general | energizer | ea92bp-8  |      21 |

Entity B:
| title                               | category                       | brand     | modelno   |   price |
|:------------------------------------|:-------------------------------|:----------|:----------|--------:|
| energizer a544 6-volt photo battery | batteries chargers accessories | energizer | a544bp    |    5.62 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1806
rtable_id: 3893
label: 0