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

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

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

Entity A:
| title                                                                       | category              | brand   |   modelno |   price |
|:----------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite 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 deluxe rear projection screen - 108 x 108 av format | projection screens | da-lite |           |    7950 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2471
rtable_id: 304
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 |
|:--------------------------------------------------------------------------------------|:----------------------|:--------|:----------|--------:|
| vtech ds6151 2-line expandable cordless phone with digital answering system caller id | electronics - general | vtech   | ds6151    |   62.51 |

Entity B:
| title                                                           | category            | brand   | modelno   | price   |
|:----------------------------------------------------------------|:--------------------|:--------|:----------|:--------|
| vtech cs5111-2 two handset cordless phone system with caller id | cordless telephones | vtech   | cs5111-2  |         |



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

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

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

Entity A:
| title                                                    | category    | brand   | modelno     |   price |
|:---------------------------------------------------------|:------------|:--------|:------------|--------:|
| iosafe rugged 250gb usb 3.0 portable external hard drive | hard drives | iosafe  | pa50250u5yr |  249.99 |

Entity B:
| title                                                            | category              | brand   | modelno            |   price |
|:-----------------------------------------------------------------|:----------------------|:--------|:-------------------|--------:|
| hewlett packard hp portable 1 tb usb 3.0 2.0 external hard drive | external data storage | hp      | wdbacz0010bbk-nesn |   89.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 672
rtable_id: 3098
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 |
|:---------------------------------------------------|:---------------|:---------|:----------|--------:|
| bell o high-speed hdmi cable with ethernet 2-meter | tv accessories | bell ' o | hd7102    |   69.99 |

Entity B:
| title                                                     | category    | brand   | modelno     |   price |
|:----------------------------------------------------------|:------------|:--------|:------------|--------:|
| philips swivel high speed hdmi cable with ethernet 8 feet | hdmi cables | philips | sww1436u/27 |   24.98 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 660
rtable_id: 11723
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 gs105 prosafe 5-port gigabit ethernet desktop switch - 10 100 1000 mbps | switches   | netgear | gs105     |   33.88 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2119
rtable_id: 20315
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 |
|:----------------------------------------|:----------------------|:--------|:-----------|--------:|
| jwin bluetooth keyboard for ipad iphone | electronics - general | jwin    | ibtkb20blk |   63.88 |

Entity B:
| title                                                     | category      | brand           | modelno   |   price |
|:----------------------------------------------------------|:--------------|:----------------|:----------|--------:|
| typad gen2 case for ipad with built-in bluetooth keyboard | cases sleeves | accessory power | ty-101    |   39.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2044
rtable_id: 11311
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 |
|:----------------------------------------|:----------------|:--------|:------------|--------:|
| belkin shield micra for ipod touch tint | mp3 accessories | belkin  | f8z646ttc01 |   47.88 |

Entity B:
| title                                            | category   | brand   | modelno     |   price |
|:-------------------------------------------------|:-----------|:--------|:------------|--------:|
| belkin ipod touch shield micra tint-royal purple | cases      | belkin  | f8z646ttc02 |   12.49 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 924
rtable_id: 10244
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 |
|:-------------------------------------------------------|:--------------|:--------|:----------|--------:|
| xantech 283dmw designer blink emitter single mini wire | stereos/audio | xantech | 283dmw    |   11.88 |

Entity B:
| title                                | category               | brand   | modelno   | price   |
|:-------------------------------------|:-----------------------|:--------|:----------|:--------|
| xantech 282d designer emitter single | amplifier installation | xantech |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1208
rtable_id: 16352
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 |
|:-----------------------------------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| pendaflex cutless watershed file folders 1 3 cut top tab letter manila 100 per box | stationery & office machinery |         |     48434 |   22.69 |

Entity B:
| title                                                                         | category                       | brand   | modelno   | price   |
|:------------------------------------------------------------------------------|:-------------------------------|:--------|:----------|:--------|
| smead 15338 - antimicrobial file folders 1 3 cut top tab legal manila 100 box | storage presentation materials | smead   |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1699
rtable_id: 18492
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 |
|:-------------------------------------------------------|:----------------------|:--------|:-------------|--------:|
| siig 1m mini displayport to display port adapter cable | electronics - general | siig    | cb-dp0d11-s1 |   12.88 |

Entity B:
| title                                     | category   | brand   | modelno      |   price |
|:------------------------------------------|:-----------|:--------|:-------------|--------:|
| display port to dvi adapter vga m f cable |            | siig    | cb-dp0072-s1 |   16.06 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1191
rtable_id: 2481
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 |
|:----------------------------------------------------------------------------------------------------------------------|:--------------------|:----------|:-----------|--------:|
| panasonic kx-tg7645m dect 6.0 link-to-cell via bluetooth cordless phone with anwering system metallic gray 5 handsets | cordless telephones | panasonic | kx-tg7645m |  129.99 |



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

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

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

Entity A:
| title                                             | category   | brand    |   modelno |   price |
|:--------------------------------------------------|:-----------|:---------|----------:|--------:|
| verbatim 96438 2gb store n go usb 2.0 flash drive | usb drives | verbatim |     96438 |   14.84 |

Entity B:
| title                                                              | category         | brand    |   modelno |   price |
|:-------------------------------------------------------------------|:-----------------|:---------|----------:|--------:|
| verbatim store n go 4 gb usb 2.0 flash drive 96733 metallic purple | usb flash drives | verbatim |     96733 |   11.98 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 547
rtable_id: 1309
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 advantage manual with csr - wide format 130 diagonal | electronics - general | da-lite |     34718 | 1060.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1062
rtable_id: 9063
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 |
|:--------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| lexmark extra high yield return pgm print cartridge - magenta | printers   | lexmark | c782u1mg  |  214.88 |

Entity B:
| title                                               | category           | brand   | modelno   |   price |
|:----------------------------------------------------|:-------------------|:--------|:----------|--------:|
| lexmark 34 high yield black print cartridge 18c0034 | inkjet printer ink | lexmark | 18c0034   |   29.23 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 495
rtable_id: 2835
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 apb-00001 wired desktop 600 keyboard and mouse | electronics - general | microsoft | apb-00001 |   25.84 |

Entity B:
| title                              | category              | brand     | modelno   |   price |
|:-----------------------------------|:----------------------|:----------|:----------|--------:|
| microsoft wired keyboard 600 black | keyboard mouse combos | microsoft | anb-00001 |      13 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 299
rtable_id: 10218
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 |
|:--------------------------------------------|:-----------|:----------|:----------|--------:|
| 2.4 ghz wireless optical nano mouse red usb | mice       | gear head | mp2275red |      12 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 582
rtable_id: 20348
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 dp2dvi displayport to dvi video converter cable | electronics - general | startech | dp2dvi    |   18.88 |

Entity B:
| title                                                                | category         | brand    | modelno   |   price |
|:---------------------------------------------------------------------|:-----------------|:---------|:----------|--------:|
| startech.com mdp2vga mini displayport to vga video adapter converter | video converters | startech | mdp2vga   |   21.52 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2163
rtable_id: 19098
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 |
|:---------------------------------------|:-----------|:--------|:----------|--------:|
| belkin basic wireless n150 usb adapter | networking | belkin  | f7d1101   |   29.99 |

Entity B:
| title                                         | category             | brand   | modelno   |   price |
|:----------------------------------------------|:---------------------|:--------|:----------|--------:|
| belkin f5d8073 n wireless expresscard adapter | computer accessories | belkin  | f5d8073   |      25 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1443
rtable_id: 12286
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 self trimming rear projection screen - 96 x 120 av format | electronics - general | da-lite |     27915 | 7443.99 |

Entity B:
| title                                                                          | category           | brand   | modelno   | price   |
|:-------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| da-lite 27637 da-glas standard rear projection screen 57 3 4 x 77 video format | projection screens | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2472
rtable_id: 21566
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 |
|:-----------------------------------------------------------|:-----------|:--------|:----------|--------:|
| at t cl81211 dect 6.0 digital 2-handset cordless telephone | phones     | at t    | cl81211   |   49.98 |

Entity B:
| title                                                        | category            | brand   | modelno   |   price |
|:-------------------------------------------------------------|:--------------------|:--------|:----------|--------:|
| at t cl82409 dect 6.0 cordless phone black silver 4 handsets | cordless telephones | at t    | cl82409   |   90.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 716
rtable_id: 4295
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 |
|:-------------------------------|:----------------------|:-------------|:---------------|--------:|
| cooler master notepal u2 black | electronics - general | coolermaster | r9-nbc-8pbk-gp |   24.82 |

Entity B:
| title                                                   | category     | brand         | modelno        |   price |
|:--------------------------------------------------------|:-------------|:--------------|:---------------|--------:|
| cooler master notepal x2 notebook cooler r9-nbc-4wak-gp | cooling pads | cooler master | r9-nbc-4wak-gp |   27.63 |



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

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

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

Entity A:
| title                                                                  | category   | brand   | modelno   |   price |
|:-----------------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| hon 10500 workstation right pedestal desk 66w x 30d x 29-1 2h mahogany | furniture  | hon     | 10584lnn  |     599 |

Entity B:
| title                                                                                                      | category            | brand   | modelno   |   price |
|:-----------------------------------------------------------------------------------------------------------|:--------------------|:--------|:----------|--------:|
| new-hon p3265rns - metro classic right pedestal workstation desk 66w x 30d mahogany charcoal - honp3265rns | laminating supplies | hon     |           |     884 |



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

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

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

Entity A:
| title                                                                               | category        | brand   | modelno   |   price |
|:------------------------------------------------------------------------------------|:----------------|:--------|:----------|--------:|
| casio exilim ex-zs10 14.1 mp digital camera black w 5x optical zoom 2.7 lcd display | digital cameras | casio   | ex-zs10bk |     120 |

Entity B:
| title                                                                       | category                    | brand   | modelno   |   price |
|:----------------------------------------------------------------------------|:----------------------------|:--------|:----------|--------:|
| casio exilim ex-z16 12 mp digital camera with 3x zoom and 2.7-inch lcd pink | point shoot digital cameras | casio   | ex-z16pk  |   84.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1827
rtable_id: 2580
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 model b manual screen with csr - 60 x 80 video format | electronics - general | da-lite |     85319 |  369.99 |

Entity B:
| title                                                                                                          | category           | brand   | modelno   | price   |
|:---------------------------------------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| honey maple veneer model b manual screen with matte white fabric - diagonal video format size 60 x 60 diagonal | projection screens | da-lite |           |         |



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

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

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

Entity A:
| title                                               | category              | brand   | modelno         |   price |
|:----------------------------------------------------|:----------------------|:--------|:----------------|--------:|
| v7 10 cat6 snagless molded network patch cable gray | electronics - general | v7      | v7n2c6-10f-grys |    5.88 |

Entity B:
| title                                                                                        | category        | brand   | modelno          |   price |
|:---------------------------------------------------------------------------------------------|:----------------|:--------|:-----------------|--------:|
| v7 cat5e snagless molded network patch cable rj45 male to male blue 25-feet v7n3c5e-25f-blus | ethernet cables | v7      | v7n3c5e-25f-blus |    5.13 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 117
rtable_id: 9323
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 |
|:---------------------------------------------------------|:-----------|:----------|:-------------|--------:|
| birdhouse tony hawk 2gb ptero skatedrive usb flash drive | usb drives | ep memory | bh-skthpt/2g |    9.84 |

Entity B:
| title                                                                                            | category         | brand   | modelno                               |   price |
|:-------------------------------------------------------------------------------------------------|:-----------------|:--------|:--------------------------------------|--------:|
| action sport skatedrive birdhouse - tony hawk - birdman crest - usb flash drive - 4 gb - usb 2.0 | usb flash drives | add on  | birdhouse - tony hawk - birdman crest |    11.5 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1404
rtable_id: 20002
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 sdhc secure digital flash memory card | usb drives | wintec  | 3fmsd4gb-r |    7.99 |

Entity B:
| title                                             | category     | brand   | modelno        |   price |
|:--------------------------------------------------|:-------------|:--------|:---------------|--------:|
| wintec filemate 16 gb class 4 microsd memory card | memory cards | wintec  | 3fmusdck16gb-r |   34.65 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1992
rtable_id: 20767
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 dvd-224blk compact dvd player | dvd players | coby    | dvd-224blk |   34.88 |

Entity B:
| title                                         | category   | brand   | modelno   |   price |
|:----------------------------------------------|:-----------|:--------|:----------|--------:|
| coby dvd209blk ultra-compact dvd player black |            | coby    | dvd209blk |   26.98 |



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

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

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

Entity A:
| title                                                                       | category              | brand   |   modelno |   price |
|:----------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-plex self trimming rear projection screen - 58 x 104 hdtv format | electronics - general | da-lite |     27590 | 4635.99 |

Entity B:
| title                                                                               | category           | brand   |   modelno |   price |
|:------------------------------------------------------------------------------------|:-------------------|:--------|----------:|--------:|
| da-lite da-view thru-the-wall rear projection screen - 50 1 2 x 67 1 4 video format | projection screens | da-lite |     23034 | 9739.76 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1060
rtable_id: 21811
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 |
|:------------------------------------------------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| weyerhaeuser company multiuse premium paper 98 brightness 24lb 8-1 2 x 14 white 500 sheets ream | stationery & office machinery |         |     85781 |   12.47 |

Entity B:
| title                                                                                                   | category                       | brand   | modelno   |   price |
|:--------------------------------------------------------------------------------------------------------|:-------------------------------|:--------|:----------|--------:|
| new-domtar 85311 - colorprint premium paper 98 brightness 28lb 11 x 17 white 500 sheets ream - dmr85311 | storage presentation materials | domtar  |           |   45.89 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 684
rtable_id: 280
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 model b manual screen - 72 x 72 av format | electronics - general | da-lite |     33424 |  229.99 |

Entity B:
| title                                                          | category           | brand   | modelno    |   price |
|:---------------------------------------------------------------|:-------------------|:--------|:-----------|--------:|
| da-lite deluxe model b high power - projection screen - 100 in | home audio theater | da-lite | high power |  269.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2434
rtable_id: 10752
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 |
|:--------------------------------------------|:------------|:--------|:----------|--------:|
| boss mp3 cd receiver speaker package system | car stereos | boss    | 655ck     |      78 |

Entity B:
| title                                                        | category   | brand   | modelno   |   price |
|:-------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| boss 586ck 160 watt cd am fm receiver speaker package system | cd players | boss    | 586ck     |   63.48 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 202
rtable_id: 6373
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 |
|:---------------------------------------------------|:---------------|:---------|:----------|--------:|
| bell o high-speed hdmi cable with ethernet 2-meter | tv accessories | bell ' o | hd7102    |   69.99 |

Entity B:
| title                                                                          | category    | brand        |   modelno |   price |
|:-------------------------------------------------------------------------------|:------------|:-------------|----------:|--------:|
| cables to go 40304 high speed hdmi cable with ethernet black 2 meter 6.56-feet | hdmi cables | cables to go |     40304 |   12.99 |



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

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

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

Entity A:
| title                                 | category                         | brand   | modelno    |   price |
|:--------------------------------------|:---------------------------------|:--------|:-----------|--------:|
| sunpak 67mm circular polarized filter | camera and camcorder accessories | sunpak  | cf-7061 cp |      18 |

Entity B:
| title                                       | category       | brand   | modelno   |   price |
|:--------------------------------------------|:---------------|:--------|:----------|--------:|
| new-72mm circular polarized filter - t43854 | accessory kits | sunpak  |           |   34.39 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 720
rtable_id: 20978
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 silhouette flexible poly view binder 1 capacity | stationery & office machinery | avery   |     17232 |    5.86 |

Entity B:
| title                                                                               | category   | brand   | modelno   |   price |
|:------------------------------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| avery 17334 - silhouette poly view binder w inside pocket 1-1 2 capacity light blue |            | avery   |           |     9.5 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 989
rtable_id: 2358
label: 0