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 |
|:---------------------------------------------------------|:----------------------|:-----------------|:------------|--------:|
| cables unlimited - 3.5 mm 50 male to female stereo cable | electronics - general | cables unlimited | aud-1000-50 |    9.88 |

Entity B:
| title                                                       | category            | brand            | modelno   |   price |
|:------------------------------------------------------------|:--------------------|:-----------------|:----------|--------:|
| cables unlimited adp-3780 dvi-d male to hdmi female adapter | connectors adapters | cables unlimited | adp-3780  |    2.68 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1796
rtable_id: 4555
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 |
|:-------------------------------------|:----------------------|:--------|:----------|--------:|
| chicago cubs pink iphone 4 hard case | electronics - general | tribeca | fva4424   |   29.99 |

Entity B:
| title                                       | category              | brand   | modelno   |   price |
|:--------------------------------------------|:----------------------|:--------|:----------|--------:|
| los angeles dodgers pink iphone 4 hard case | computers accessories | tribeca |           |   29.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1070
rtable_id: 2959
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 |
|:--------------------------------------|:----------------------|:--------|:----------|--------:|
| targus chill mat laptop cooling stand | electronics - general | targus  | pa248u2   |   30.44 |

Entity B:
| title                                     | category     | brand   | modelno   |   price |
|:------------------------------------------|:-------------|:--------|:----------|--------:|
| targus notebook cooling chill mat awe11us | cooling pads | targus  | awe11us   |    23.2 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 578
rtable_id: 5365
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 file folders 1 2 cut 1-ply top tab manila 100 box | stationery & office machinery |         |     15320 |   34.05 |

Entity B:
| title                                                                         | category   | brand   | modelno   |   price |
|:------------------------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| smead 10300 - file folders straight cut one-ply top tab letter manila 100 box |            | smead   |           |   22.11 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1711
rtable_id: 13499
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 dual vision tensioned advantage deluxe electrol - hdtv format 92 diagonal | electronics - general | da-lite |     88285 | 4242.99 |

Entity B:
| title                                                                                    | category           | brand   | modelno   | price   |
|:-----------------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| da-lite 97991 dual vision tensioned cosmopolitan electrol - av format 10 6 x 14 diagonal | projection screens | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 887
rtable_id: 16316
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 |
|:------------------------------------------------|:-----------|:-------------|----------:|--------:|
| pc treasures retractable mighty mini mouse navy | mice       | pc treasures |      7221 |    9.88 |

Entity B:
| title                                             | category   | brand        |   modelno |   price |
|:--------------------------------------------------|:-----------|:-------------|----------:|--------:|
| pc treasures mighty mini mouse - 2.4 ghz wireless | mice       | pc treasures |      7230 |   16.69 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 794
rtable_id: 19964
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 deluxe rear projection screen - 96 x 96 av format | electronics - general | da-lite |     27557 | 6426.99 |

Entity B:
| title                                                                       | category           | brand   |   modelno |   price |
|:----------------------------------------------------------------------------|:-------------------|:--------|----------:|--------:|
| da-lite da-plex thru-the-wall rear projection screen - 78 x 139 hdtv format | projection screens | da-lite |     23077 | 9258.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2020
rtable_id: 19283
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 |
|:---------------------------------------------|:-----------|:--------|:-----------|--------:|
| wintec filemate 4gb compactflash memory card | usb drives | wintec  | 3fmcf4gb-r |   15.98 |

Entity B:
| title                                            | category     | brand   | modelno       |   price |
|:-------------------------------------------------|:-------------|:--------|:--------------|--------:|
| wintec filemate 8 gb class 4 microsd memory card | memory cards | wintec  | 3fmusdck8gb-r |   18.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2018
rtable_id: 21729
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 3.5 external usb ide hard drive enclosure black | electronics - general | startech | ide3510u2 |   28.88 |

Entity B:
| title                                                                                                 | category              | brand   | modelno      |   price |
|:------------------------------------------------------------------------------------------------------|:----------------------|:--------|:-------------|--------:|
| vantec nexstar sx nst-285u2-bk 2.5-inch ide to usb 2.0 external hard drive enclosure onyx black black | hard drive enclosures | vantec  | nst-285u2-bk |   14.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1536
rtable_id: 10077
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 |
|:--------------------------------------|:------------------------------|:--------|----------:|--------:|
| avery digital postal scale kit 25 lbs | stationery & office machinery | avery   |     32400 |   89.88 |

Entity B:
| title                    | category      | brand   | modelno   |   price |
|:-------------------------|:--------------|:--------|:----------|--------:|
| sp5 digital postal scale | postal scales | pelouze | sp5       |   29.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 783
rtable_id: 13698
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 |
|:-----------------------------------------------|:--------------|:--------|:----------|--------:|
| dj-tech t545a 15 600w 2-way active loudspeaker | stereos/audio | dj tech | t545a     |     358 |

Entity B:
| title                                  | category           | brand   | modelno   |   price |
|:---------------------------------------|:-------------------|:--------|:----------|--------:|
| djtech super powered 15 600 w dj spkrs | home audio theater | dj-tech | t545a     |  396.74 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1396
rtable_id: 2438
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 |
|:---------------------------------------|:-----------|:---------|----------:|--------:|
| logitech wireless mouse m315 victorian | mice       | logitech | 910002534 |   19.88 |

Entity B:
| title                                             | category   | brand    | modelno    |   price |
|:--------------------------------------------------|:-----------|:---------|:-----------|--------:|
| logitech wireless mouse m305 dark vine 910-002081 | mice       | logitech | 910-002081 |   23.65 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2517
rtable_id: 118
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 |
|:------------------------------------------------------------|:-----------|:---------|:----------|--------:|
| guardian ecoguard indoor rubber wiper mats 36 x 60 charcoal | rugs       | guardian | eg030504  |   55.97 |

Entity B:
| title                                                                  | category                       | brand    | modelno   | price   |
|:-----------------------------------------------------------------------|:-------------------------------|:---------|:----------|:--------|
| guardian eg030504 - ecoguard indoor wiper mats rubber 36 x 60 charcoal | storage presentation materials | guardian |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1834
rtable_id: 16331
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 |
|:-----------------------------------------|:----------------------|:--------|:----------|--------:|
| jvc inner-ear sports clip earbuds violet | electronics - general | jvc     | haebx5v   |   19.95 |

Entity B:
| title                                            | category   | brand   | modelno   |   price |
|:-------------------------------------------------|:-----------|:--------|:----------|--------:|
| new-inner-ear sports clip earbuds - red - dq2349 | headphones | jvc     |           |      21 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2477
rtable_id: 17116
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 72-in-one card reader with sim slot | photography - general | sunpak  | 72-in-1-cr |       0 |

Entity B:
| title                                                                               | category            | brand   | modelno   |   price |
|:------------------------------------------------------------------------------------|:--------------------|:--------|:----------|--------:|
| sunpak 72-in-1 high speed card reader - universal usb 2.0 card reader including sim | memory card readers | sunpak  |           |   19.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 33
rtable_id: 11683
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 |
|:---------------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| universal pressboard classification folder legal box of 10 red | stationery & office machinery |         |     82007 |   47.84 |

Entity B:
| title                                                                                    | category   | brand   | modelno   |   price |
|:-----------------------------------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| smead 29820 - pressboard end tab classification folder legal 8-section gray-green 10 box |            | smead   |           |   80.84 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1688
rtable_id: 20800
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 |
|:---------------------------------------------|:----------------------|:--------|:----------|--------:|
| slappa ladies damask netbook sleeve in white | electronics - general | slappa  | nsv-121   |   39.99 |

Entity B:
| title                                                            | category   | brand   | modelno    |   price |
|:-----------------------------------------------------------------|:-----------|:--------|:-----------|--------:|
| slappa sl-nsv-122 10-inch lady damask netbook sleeve black black | bags cases | slappa  | sl-nsv-122 |   22.49 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1467
rtable_id: 11532
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 |
|:---------------------------------------------|:-----------|:--------|:-----------|--------:|
| wintec filemate 4gb compactflash memory card | usb drives | wintec  | 3fmcf4gb-r |   15.98 |

Entity B:
| title                                                | category    | brand     | modelno      |   price |
|:-----------------------------------------------------|:------------|:----------|:-------------|--------:|
| dane-elec 4 gb compactflash memory card da-cf-4096-r | blank media | dane-elec | da-cf-4096-r |   10.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2018
rtable_id: 10463
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 kx-tga6645b dect 6.0 plus expandable digital cordless answering system with 5 handsets | electronics - general | panasonic | kx-tg6645b |     150 |

Entity B:
| title                                                                                  | category            | brand   | modelno   | price   |
|:---------------------------------------------------------------------------------------|:--------------------|:--------|:----------|:--------|
| vtech ls6425-3 dect 6.0 digital three handset cordless answering system with caller id | cordless telephones | vtech   | ls6425-3  |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2260
rtable_id: 3283
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 |
|:-----------------------------------|:-----------|:---------|:-----------|--------:|
| logitech m305 wireless mouse black | mice       | logitech | 910-001752 |   29.73 |

Entity B:
| title                                    | category   | brand    | modelno    |   price |
|:-----------------------------------------|:-----------|:---------|:-----------|--------:|
| logitech wireless mouse m310 soft violet | mice       | logitech | 910-001918 |   23.13 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 742
rtable_id: 2790
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 |
|:-----------------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| avery index maker clear label unpunched dividers with white tabs | stationery & office machinery | avery   |     11442 |   77.18 |

Entity B:
| title                                                                   | category              | brand   |   modelno |   price |
|:------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| avery index maker clear label dividers with 5 white tabs 25 count 11446 | binder index dividers | avery   |     11446 |   52.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 851
rtable_id: 12312
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 parallel adapter card pci1pecp | accessories supplies | startech | pci1pecp  |   27.98 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 687
rtable_id: 5427
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 c5055a hp90 print head cleaner cyan | printers   | hp      | c5055a    |  173.25 |

Entity B:
| title                                 | category          | brand   | modelno   | price   |
|:--------------------------------------|:------------------|:--------|:----------|:--------|
| hp 90 - printhead with cleaner c5054a | printer ink toner | hp      | c5054a    |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2292
rtable_id: 9912
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 |
|:-----------------------------------------------------|:-----------|:--------|:----------|--------:|
| brother tn450 black toner cartridge high yield toner | printers   | brother | tn450     |   48.88 |

Entity B:
| title                                                  | category            | brand   | modelno   |   price |
|:-------------------------------------------------------|:--------------------|:--------|:----------|--------:|
| brother tn550 3 500 yld standard yield toner cartridge | laser printer toner | brother | tn550     |   47.49 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2538
rtable_id: 2809
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 14.1 laptop sleeve | electronics - general | case logic |    117505 |   17.59 |

Entity B:
| title                                          | category   | brand      | modelno      |   price |
|:-----------------------------------------------|:-----------|:-----------|:-------------|--------:|
| case logic vls-116 16-inch laptop sleeve black | bags cases | case logic | vls-116black |   15.65 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 295
rtable_id: 12589
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 deluxe rear projection screen - 96 x 96 av format | electronics - general | da-lite |     27557 | 6426.99 |

Entity B:
| title                                                                       | category           | brand   |   modelno |   price |
|:----------------------------------------------------------------------------|:-------------------|:--------|----------:|--------:|
| da-lite da-glas thru-the-wall rear projection screen - 72 x 96 video format | projection screens | da-lite |     23050 | 8968.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2020
rtable_id: 19011
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 |
|:-------------------------------------------------------------------------------------------------------|:----------------|:--------|:----------|--------:|
| kodak easyshare m552 dark pink 14mp digital camera w 5x optical zoom 2.7 lcd display w 50 bonus prints | digital cameras | kodak   | m552pink  |   94.54 |

Entity B:
| title                                                                                              | category                    | brand   |   modelno |   price |
|:---------------------------------------------------------------------------------------------------|:----------------------------|:--------|----------:|--------:|
| kodak easyshare m552 14 mp digital camera with 5x optical zoom and 2.7-inch lcd - orange new model | point shoot digital cameras | kodak   |   8996464 |      89 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2149
rtable_id: 11836
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 |
|:-------------------------------------|:----------------------|:--------|:----------|--------:|
| chicago cubs pink iphone 4 hard case | electronics - general | tribeca | fva4424   |   29.99 |

Entity B:
| title                                         | category              | brand   | modelno   |   price |
|:----------------------------------------------|:----------------------|:--------|:----------|--------:|
| philadelphia phillies pink iphone 4 hard case | computers accessories | tribeca |           |   23.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1070
rtable_id: 18840
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 |
|:--------------------------------------------|:-----------|:--------|:-------------|--------:|
| netgear prosafe plus 8-port ethernet switch | networking | netgear | gs108e100nas |   78.88 |

Entity B:
| title                                                          | category   | brand   | modelno        | price   |
|:---------------------------------------------------------------|:-----------|:--------|:---------------|:--------|
| netgear gs748ts prosafe 48-port gigabit stackable smart switch | switches   | netgear | gs748ts-100nas |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2119
rtable_id: 6613
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 thru-the-wall rear projection screen - 78 x 139 hdtv format | electronics - general | da-lite |     23077 |   11386 |

Entity B:
| title                                                          | category           | brand   | modelno   |   price |
|:---------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| da-plex base rear projection screen - 57 3 4 x 77 video format | projection screens | da-lite |           | 2608.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2471
rtable_id: 17892
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 |
|:--------------------------|:------------|:--------|:----------|--------:|
| rca 9 portable dvd player | dvd players | rca     | drc99392  |       0 |

Entity B:
| title                                               | category             | brand   | modelno   |   price |
|:----------------------------------------------------|:---------------------|:--------|:----------|--------:|
| rca drc6317e portable dvd player with 7-inch screen | portable dvd players | rca     | drc6317e  |   81.72 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 819
rtable_id: 10176
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 deluxe rear projection screen - 58 x 104 hdtv format | electronics - general | da-lite |     27571 | 4629.99 |

Entity B:
| title                                                                      | category           | brand   | modelno   | price   |
|:---------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| da-lite 27639 da-glas standard rear projection screen 72 x 96 video format | projection screens | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2220
rtable_id: 18443
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 |
|:----------------------------------------------------|:----------------------|:-----------|:--------------|--------:|
| blackberry leather sleeve for playbook tablet black | electronics - general | blackberry | acc-39311-301 |   29.88 |

Entity B:
| title                                                                               | category      | brand      | modelno       |   price |
|:------------------------------------------------------------------------------------|:--------------|:-----------|:--------------|--------:|
| research in motion leather book binder for blackberry playbook tablet acc-40278-301 | cases sleeves | blackberry | acc-40278-301 |   29.39 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 62
rtable_id: 9423
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 pro series component cable 3m | tv accessories | zax     |     87203 |   11.88 |

Entity B:
| title                                        | category             | brand   | modelno   |   price |
|:---------------------------------------------|:---------------------|:--------|:----------|--------:|
| zax 85210 select series component cable 10 m | computer accessories | zax     |           |    31.3 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1211
rtable_id: 15173
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 smartdisk acclaim 320gb usb portable hard drive blue | hard drives | verbatim | ver97185  |   59.84 |

Entity B:
| title                                                                  | category   | brand    |   modelno |   price |
|:-----------------------------------------------------------------------|:-----------|:---------|----------:|--------:|
| verbatim acclaim 500 gb usb 2.0 portable external hard drive 97184 red |            | verbatim |     97184 |   69.24 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1217
rtable_id: 5250
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 high power advantage manual with csr - av format 8 x 10 diagonal | electronics - general | da-lite |     85687 | 1303.99 |

Entity B:
| title                                                                    | category           | brand   | modelno   |   price |
|:-------------------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| hc matte white advantage manual with csr - video format size 72 diagonal | projection screens | da-lite |           |   566.5 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2145
rtable_id: 14644
label: 0