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 |
|:------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| edge 1gb pc2-4200 ddr2 533mhz 240-pin desktop memory module | memory     | edge    | pe197711  |   18.82 |

Entity B:
| title                                                                      | category   | brand   | modelno    |   price |
|:---------------------------------------------------------------------------|:-----------|:--------|:-----------|--------:|
| corsair memory vs1gb533d2 1 gb pc2-4200 533mhz 240-pin ddr2 desktop memory | memory     | corsair | vs1gb533d2 |   15.86 |



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

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

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

Entity A:
| title                                                                 | category              | brand   |   modelno |   price |
|:----------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-glas standard rear projection screen 81 x 108 video format | electronics - general | da-lite |     27917 | 5391.99 |

Entity B:
| title                                                                          | category           | brand   | modelno   | price   |
|:-------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| da-lite 27514 da-plex unframed rear projection screen - 108 x 144 video format | projection screens | da-lite |           |         |



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

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

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

Entity A:
| title                           | category   | brand   | modelno     |   price |
|:--------------------------------|:-----------|:--------|:------------|--------:|
| coby 8gb video mp3 player black | mp3        | coby    | mp727-8gblk |   59.88 |

Entity B:
| title                                             | category    | brand   | modelno   |   price |
|:--------------------------------------------------|:------------|:--------|:----------|--------:|
| coby clip 2 gb mp3 player with flash memory black | mp3 players | coby    | mp550-2g  |   19.54 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 557
rtable_id: 8558
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 shipping labels with trueblock technology 2 x 4 white 1000 box | stationery & office machinery | avery   |      8463 |   45.91 |

Entity B:
| title                                                                            | category       | brand   |   modelno |   price |
|:---------------------------------------------------------------------------------|:---------------|:--------|----------:|--------:|
| avery shipping labels with trueblock technology 2x4 inches white 250 labels 8163 | address labels | avery   |      8163 |    8.19 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2429
rtable_id: 11988
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 - 40 1 4 x 53 3 4 video format | projection screens | da-lite |           | 1525.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2471
rtable_id: 18200
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 |
|:------------------------------------|:----------------|:--------|:----------|--------:|
| arkon ipad desktop and travel stand | mp3 accessories | arkon   | ipm-tab1  |   14.09 |

Entity B:
| title                     | category      | brand   | modelno     |   price |
|:--------------------------|:--------------|:--------|:------------|--------:|
| i.sound ipad travel stand | cases sleeves | i.sound | dgipad-4542 |   16.42 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 168
rtable_id: 12913
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 |
|:-------------------------------------------|:----------------------|:--------------|:------------|--------:|
| creative labs sound blaster tactic3d alpha | electronics - general | creative labs | gh012000003 |   59.99 |

Entity B:
| title                                                               | category             | brand         | modelno       |   price |
|:--------------------------------------------------------------------|:---------------------|:--------------|:--------------|--------:|
| creative labs sb0790 pci sound blaster x-fi xtreme audio sound card | internal sound cards | creative labs | 70sb079000000 |   35.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 669
rtable_id: 8506
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 |
|:--------------------------------------------------------|:----------------------|:--------|:------------|--------:|
| coolmax 3.5 usb 3.0 external hard drive enclosure black | electronics - general | coolmax | hd-381bz-u3 |   26.88 |

Entity B:
| title                                                                                                 | category              | brand   | modelno      |   price |
|:------------------------------------------------------------------------------------------------------|:----------------------|:--------|:-------------|--------:|
| vantec nexstar cx nst-300su-bk 3.5-inch sata to usb 2.0 and esata external hard drive enclosure black | hard drive enclosures | vantec  | nst-300su-bk |   22.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1429
rtable_id: 8071
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 fast-fold deluxe screen system - projection screen - 16 9 - da-mat | projection screens | da-lite |           |  754.85 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2020
rtable_id: 6751
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 |
|:--------------------------------------------------------------------------------------|:---------------------|:--------|:----------|--------:|
| cobra mobile cb radio with nightwatch illuminated display and swr antenna calibration | automotive - general | cobra   | 29-wxnwst |     150 |

Entity B:
| title                                                               | category   | brand   | modelno   |   price |
|:--------------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| cobra 29nw classic cb radio with nightwatch illuminated front panel | cb radios  | cobra   | 29 nw     |   89.11 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1482
rtable_id: 6503
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 fast-fold deluxe screen system - projection screen - 4 3 - da-mat | projection screens | da-lite |           |  529.25 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2020
rtable_id: 8236
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 |
|:------------------------|:----------------------|:---------|:----------|--------:|
| penpower chinese expert | electronics - general | penpower | swlea0010 |  104.88 |

Entity B:
| title                                       | category            | brand    | modelno                 |   price |
|:--------------------------------------------|:--------------------|:---------|:------------------------|--------:|
| penpower chinese expert pen scanner edition | scanner accessories | penpower | penpower chinese expert |  210.39 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1481
rtable_id: 16118
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 |
|:-----------------------------------------------------------|:----------------------|:-----------------|:----------|--------:|
| cables unlimited 2 port e-sata controller pci express card | electronics - general | cables unlimited | ioc-7707  |   49.88 |

Entity B:
| title                                                        | category              | brand            | modelno   |   price |
|:-------------------------------------------------------------|:----------------------|:-----------------|:----------|--------:|
| cables unlimited ioc-3200 high-speed 2 port usb 2.0 pci card | computers accessories | cables unlimited | ioc-3200  |   20.14 |



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

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

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

Entity A:
| title                                                            | category   | brand    | modelno       |   price |
|:-----------------------------------------------------------------|:-----------|:---------|:--------------|--------:|
| kingston kth-mlg4 2g 2gb ddr2 240-pin sdram server memory module | memory     | kingston | kth-mlg4 / 2g |   55.92 |

Entity B:
| title                        | category              | brand   | modelno   |   price |
|:-----------------------------|:----------------------|:--------|:----------|--------:|
| 2gb ddr2 sdram memory module | computers accessories | lenovo  | 73p4985   |   61.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1937
rtable_id: 6397
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 |
|:-----------------------------------------------------------------|:---------------|:--------------|:----------|--------:|
| comprehensive 1 4 standard stereo phone jack cable end set of 25 | tv accessories | comprehensive | spj-s     |   35.75 |

Entity B:
| title                                                 | category   | brand         | modelno   | price   |
|:------------------------------------------------------|:-----------|:--------------|:----------|:--------|
| comprehensive mj 3.5 mm mini jack cable end set of 25 |            | comprehensive |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1269
rtable_id: 18029
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 2.5 sata to usb 2.0 and esata external hard drive enclosure midnight blue | electronics - general | vantec  | nst-260su-bl |      23 |

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: 532
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 |
|:----------------------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| avery self-adhesive filing labels 1 3 cut 3-7 16 x 2 3 clear 450 pack | stationery & office machinery | avery   |      5029 |   21.47 |

Entity B:
| title                                                                                 | category        | brand   |   modelno |   price |
|:--------------------------------------------------------------------------------------|:----------------|:--------|----------:|--------:|
| avery 5314 self-adhesive address labels for copiers clear 1 x 2-13 16 660 labels pack | shipping labels | avery   |      5314 |    14.7 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 15
rtable_id: 6272
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 |
|:--------------------------------------|:-----------|:----------|:----------|--------:|
| microsoft windows 7 professional full | software   | microsoft | fqc-00129 |  299.54 |

Entity B:
| title                             | category             | brand     | modelno   |   price |
|:----------------------------------|:---------------------|:----------|:----------|--------:|
| microsoft visio professional 2010 | computer accessories | microsoft | d87-04973 |  444.31 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2234
rtable_id: 21189
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 postage meter labels for personal post office e700 1-3 16 x 6 white 60 pack | stationery & office machinery | avery   |      5289 |    9.54 |

Entity B:
| title                                              | category            | brand   | modelno   | price   |
|:---------------------------------------------------|:--------------------|:--------|:----------|:--------|
| postage meter labels for personal post office e700 | printer accessories | avery   |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1922
rtable_id: 20240
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 |
|:--------------------------------------|:-----------|:--------|:----------|--------:|
| brother tn110bk black toner cartridge | printers   | brother | tn110bk   |   49.88 |

Entity B:
| title                          | category            | brand   | modelno   |   price |
|:-------------------------------|:--------------------|:--------|:----------|--------:|
| brother tn-650 toner cartridge | laser printer toner | brother | tn650     |   76.02 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2349
rtable_id: 21531
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 corded mouse black | mice       | logitech | 910001830 |   17.82 |

Entity B:
| title                           | category   | brand    | modelno    |   price |
|:--------------------------------|:-----------|:---------|:-----------|--------:|
| logitech corded mouse m125 blue | mice       | logitech | 910-001831 |   11.48 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 965
rtable_id: 14673
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 m315 wireless optical mouse blue | mice       | logitech | m315      |   19.88 |

Entity B:
| title                                          | category   | brand     | modelno   |   price |
|:-----------------------------------------------|:-----------|:----------|:----------|--------:|
| 3 button wireless optical wheel mouse blue usb | mice       | gear head | mp2100blu |    12.3 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1656
rtable_id: 13152
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 cyber-shot dsc-t110 16mp digital camera red w 4x optical zoom hd movie capture 3.0 touchscreen lcd w 50 bonus prints | digital cameras | sony    | dsc-t110 / r |  219.99 |

Entity B:
| title                                                                                                                   | category                    | brand   | modelno   |   price |
|:------------------------------------------------------------------------------------------------------------------------|:----------------------------|:--------|:----------|--------:|
| sony cyber-shot dsc-t110 16.1 mp digital camera with 4x optical zoom and 3-inch touchscreen in silver 8gb accessory kit | point shoot digital cameras | sony    | dsc-t110  |  209.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1226
rtable_id: 13482
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 nexstar 2.5 sata to usb 2.0 hard drive dock | electronics - general | vantec  | nst-d100s2 |    24.2 |

Entity B:
| title                                                                                       | category              | brand   | modelno      |   price |
|:--------------------------------------------------------------------------------------------|:----------------------|:--------|:-------------|--------:|
| vantec nexstar cx nst-300s2-bk 3.5-inch sata to usb 2.0 external hard drive enclosure black | hard drive enclosures | vantec  | nst-300s2-bk |   21.28 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1225
rtable_id: 15994
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 tx2511 laminated tape cartridge | stationery & office machinery | brother | tx2511    |   34.88 |

Entity B:
| title                                                               | category       | brand   | modelno   |   price |
|:--------------------------------------------------------------------|:---------------|:--------|:----------|--------:|
| brother tape cartridge 0.5 in wide non-laminated black on blue m531 | labeling tapes | brother | m531      |    9.49 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1583
rtable_id: 2278
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 matte white deluxe model b manual screen - 60 x 80 video format | electronics - general | da-lite |     74698 |  188.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 627
rtable_id: 20429
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 - 90 x 120 video format | projection screens | da-lite |     23055 |   12222 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2020
rtable_id: 805
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 |
|:-----------------------------------------|:-----------|:--------|:---------------|--------:|
| sandisk ultraii 8gb memory stick pro duo | usb drives | sandisk | sdmspdh008ga11 |   52.88 |

Entity B:
| title                                                     | category     | brand   | modelno          |   price |
|:----------------------------------------------------------|:-------------|:--------|:-----------------|--------:|
| sandisk 2 gb ultra ii memory stick pro duo retail package | memory cards | sandisk | sdmspdh-2048-901 |    18.9 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 390
rtable_id: 11588
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 pt-18r p-touch label printer | printers   | brother | pt-18r    |  129.88 |

Entity B:
| title                                   | category            | brand   | modelno   |   price |
|:----------------------------------------|:--------------------|:--------|:----------|--------:|
| brother pt-1230pc thermal label printer | printer accessories | brother |           |   24.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1666
rtable_id: 18150
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 t020201 color ink cartridge | printers   | epson   | t020201   |      27 |

Entity B:
| title                                     | category           | brand   | modelno   |   price |
|:------------------------------------------|:-------------------|:--------|:----------|--------:|
| epson t033520 light cyan inkjet cartridge | inkjet printer ink | epson   | t033520   |   12.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 65
rtable_id: 1171
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 da-plex thru-the-wall rear projection screen - 72 x 96 video format | projection screens | da-lite |     23049 |   10252 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 967
rtable_id: 21693
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-tex rear tensioned advantage electrol - hdtv format 184 diagonal | electronics - general | da-lite |     35199 | 4612.99 |

Entity B:
| title                                                                        | category           | brand   | modelno   | price   |
|:-----------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| hc matte white advantage deluxe electrol - wide format size wide 94 diagonal | projection screens | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 280
rtable_id: 13373
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 |
|:--------------------------------------------------------------------------------------------------|:----------------------|:------------|:----------|--------:|
| seal shield ssksv107 silver seal medical grade keyboard - dishwasher safe antimicrobial black usb | electronics - general | seal shield | ssksv107  |   38.84 |

Entity B:
| title                                     | category              | brand       | modelno   |   price |
|:------------------------------------------|:----------------------|:------------|:----------|--------:|
| seal shield ssk107 medical grade keyboard | computers accessories | seal shield | ssk107    |   30.88 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2452
rtable_id: 2138
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 |
|:--------------------------------------------|:----------------------|:--------|:------------|--------:|
| acme smart 15 laptop sleeve wet black antik | electronics - general | acme    | am00778-ceu |   29.88 |

Entity B:
| title                                                   | category   | brand     | modelno     |   price |
|:--------------------------------------------------------|:-----------|:----------|:------------|--------:|
| acme made smart laptop sleeve mb pro 15 wet black antik | bags cases | acme made | am00777-ceu |   19.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2079
rtable_id: 4000
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 |
|:-----------------------------------|:-----------|:--------|:----------|--------:|
| ihome wireless optical mouse black | mice       | ihome   | ih-m821wb |   25.56 |

Entity B:
| title                             | category   | brand   | modelno   |   price |
|:----------------------------------|:-----------|:--------|:----------|--------:|
| usb wireless optical scroll mouse | mice       | generic |           |    6.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 582
rtable_id: 21979
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 |
|:---------------------------------------------------------------|:-----------|:--------|------------:|--------:|
| genius easypen i405 graphics tablet - 4 - 2540 lpi - pen - usb | computers  | genius  | 31100058100 |   47.82 |

Entity B:
| title                                      | category         | brand   |     modelno |   price |
|:-------------------------------------------|:-----------------|:--------|------------:|--------:|
| genius easypen i405 graphics tablet silver | graphics tablets | genius  | 31100058100 |   35.35 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 604
rtable_id: 15829
label: 1