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 |
|:------------------------------------------------------------------------------------------|:----------------------|:--------|:-------------|--------:|
| 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 superspeed 2.5-inch sata to usb 3.0 external hard drive enclosure nst-280s3-bk black | computers accessories | vantec  | nst-280s3-bk |   26.62 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 532
rtable_id: 14015
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 |
|:-----------------------------------------------------------------------------------------|:------------------------------|:-------------|----------:|--------:|
| wausau paper astrobrights colored paper 24lb 8-1 2 x 11 planetary purple 500 sheets ream | stationery & office machinery | wausau paper |     22621 |   10.27 |

Entity B:
| title                                                                                          | category                       | brand   | modelno   |   price |
|:-----------------------------------------------------------------------------------------------|:-------------------------------|:--------|:----------|--------:|
| new-wausau paper 62421 - exact colored paper 24lb 8-1 2 x 11 orchid 500 sheets ream - wau62421 | storage presentation materials | wausau  |           |   30.37 |



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

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

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

Entity A:
| title                                                                      | category              | brand   |   modelno |   price |
|:---------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-glas unframed rear projection screen - 57 3 4 x 77 video format | electronics - general | da-lite |     27604 | 1609.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1296
rtable_id: 17846
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 |
|:------------------------------------------------|:----------------------|:--------|:-----------------|--------:|
| antec tricool 92mm double ball bearing case fan | electronics - general | antec   | tricool 92mm dbb |    8.25 |

Entity B:
| title                                | category   | brand   | modelno       |   price |
|:-------------------------------------|:-----------|:--------|:--------------|--------:|
| antec tricool case fan tricool 120mm |            | antec   | tricool 120mm |   11.19 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2118
rtable_id: 5344
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 8gb microsdhc memory card | usb drives | sandisk | sdsdq008ga11m |   24.88 |

Entity B:
| title                                                          | category     | brand   | modelno   |   price |
|:---------------------------------------------------------------|:-------------|:--------|:----------|--------:|
| sandisk 4gb micro sd high capacity flash memory card microsdhc | memory cards | sandisk | 2048-11   |    1.38 |



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

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

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

Entity A:
| title                                               | category              | brand      | modelno       |   price |
|:----------------------------------------------------|:----------------------|:-----------|:--------------|--------:|
| blackberry leather sleeve for playbook tablet black | electronics - general | blackberry | acc-39311-301 |   29.88 |

Entity B:
| title                                                                           | category      | brand      | modelno       |   price |
|:--------------------------------------------------------------------------------|:--------------|:-----------|:--------------|--------:|
| research in motion gray zip sleeve for blackberry playbook tablet acc-39318-304 | cases sleeves | blackberry | acc-39318-304 |   23.73 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 62
rtable_id: 19392
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 - 50 x 50 av format | electronics - general | da-lite |     27628 | 1631.99 |

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



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

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

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

Entity A:
| title                           | category   | brand   | modelno   |   price |
|:--------------------------------|:-----------|:--------|:----------|--------:|
| hp ce250a black toner cartridge | printers   | hp      | ce250a    |  187.04 |

Entity B:
| title                     | category            | brand   | modelno   |   price |
|:--------------------------|:--------------------|:--------|:----------|--------:|
| canon l50 toner cartridge | laser printer toner | canon   | l50       |     127 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 73
rtable_id: 14518
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 usa nexstar cx 2.5-inch sata to usb 3.0 external hard drive enclosure nst-200s3-bk | external hard drives | vantec  | nst-200s3-bk |   19.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 532
rtable_id: 15291
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 |
|:----------------------------------------------------|:-----------|:----------|:----------|--------:|
| gear head 2.4 ghz wireless optical nano mouse black | mice       | gear head | mp2800blk |   15.82 |

Entity B:
| title                                                                         | category   | brand     | modelno        |   price |
|:------------------------------------------------------------------------------|:-----------|:----------|:---------------|--------:|
| gear head 2.4 ghz wireless optical nano mouse - blue black usb mp2650blu-cp10 | mice       | gear head | mp2650blu-cp10 |   18.76 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1242
rtable_id: 5068
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 |
|:------------------------------------------------------------------------------|:-----------|:--------------|:----------|--------:|
| us brown bear large tilt low to profile mount for 32 to 63 displays in silver | furniture  | us brown bear |           |      59 |

Entity B:
| title                                                                                          | category   | brand           | modelno    |   price |
|:-----------------------------------------------------------------------------------------------|:-----------|:----------------|:-----------|--------:|
| us brown bear w7-63t-blk large tilt adjustable mount for 37 -63 displays turn knob level black | tv mounts  | u.s. brown bear | w7-63t-blk |   43.42 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1463
rtable_id: 19737
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 natural walnut veneer model b manual screen with matte white fabric - 64 x 84 diagonal video format | electronics - general | da-lite |     73197 |  261.99 |

Entity B:
| title                                                                                                           | category           | brand   | modelno   | price   |
|:----------------------------------------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| da-lite manual 84 x 84 diagonal square format office wall screen with cherry veneer case and matte white fabric | projection screens | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 92
rtable_id: 6749
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 4gb tuff - n - tiny usb 2.0 flash drive green | usb drives | verbatim |           |   11.98 |

Entity B:
| title                                         | category         | brand    |   modelno |   price |
|:----------------------------------------------|:-----------------|:---------|----------:|--------:|
| verbatim 32 gb usb 2.0 flash drive 97408 blue | usb flash drives | verbatim |     97408 |   36.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1673
rtable_id: 21478
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 5 cat6 snagless molded network patch cable red | electronics - general | v7      | v7n2c6-05f-reds |    4.88 |

Entity B:
| title                                                                                       | category        | brand   | modelno          |   price |
|:--------------------------------------------------------------------------------------------|:----------------|:--------|:-----------------|--------:|
| v7 cat5e snagless molded network patch cable rj45 male to male grey 7-feet v7n3c5e-07f-grys | ethernet cables | v7      | v7n3c5e-07f-grys |    3.48 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 342
rtable_id: 15292
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 |
|:---------------------------------------------|:----------------------|:--------|:----------|--------:|
| dell switch by design studio lids shaadi 15r | electronics - general | dell    | yxmrf     |      39 |

Entity B:
| title                                                                 | category              | brand   | modelno                                 |   price |
|:----------------------------------------------------------------------|:----------------------|:--------|:----------------------------------------|--------:|
| dell switch by design studio lid for inspiron r series laptop - amira | computers accessories | dell    | switch by design studio , amira - 17 '' |   49.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1594
rtable_id: 21672
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 12 y audio cable | electronics - general | belkin  | f8v235-12 |    4.87 |

Entity B:
| title                              | category   | brand   | modelno    |   price |
|:-----------------------------------|:-----------|:--------|:-----------|--------:|
| belkin pureav rca audio cable 6 ft | rca cables | belkin  | av20300-06 |    9.15 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1066
rtable_id: 10279
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 |
|:------------------------------------|:----------------|:---------|:---------------|--------:|
| simplism shoulder case for ipad red | mp3 accessories | simplism | trlcslipaddren |   58.76 |

Entity B:
| title                                     | category      | brand    | modelno         |   price |
|:------------------------------------------|:--------------|:---------|:----------------|--------:|
| simplism silicone case set for ipad brown | cases sleeves | simplism | tr-scipad-br/en |   19.71 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 741
rtable_id: 5511
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 7 lcd dual screen tablet portable dvd player | dvd players | coby    | tfdvd7752 |  139.29 |

Entity B:
| title                                                              | category             | brand   | modelno   |   price |
|:-------------------------------------------------------------------|:---------------------|:--------|:----------|--------:|
| philips pd9012 37 9-inch lcd dual screen portable dvd player black | portable dvd players | philips | pd9012/37 |  150.67 |



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

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

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

Entity A:
| title                                 | category   | brand   | modelno   |   price |
|:--------------------------------------|:-----------|:--------|:----------|--------:|
| hp laserjet 53x black print cartridge | printers   | hp      | q7553x    |  164.84 |

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



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

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

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

Entity A:
| title                                           | category   | brand   | modelno    |   price |
|:------------------------------------------------|:-----------|:--------|:-----------|--------:|
| hp 564 tri-color combo inkjet cartridge cd994fn | printers   | hp      | hp cd994fn |    26.5 |

Entity B:
| title                         | category           | brand   | modelno       |   price |
|:------------------------------|:-------------------|:--------|:--------------|--------:|
| hp 95 tri-color ink cartridge | inkjet printer ink | hp      | c8766wn # 140 |   24.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2097
rtable_id: 1342
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 |
|:------------------------|:----------------------|:--------|:----------|--------:|
| koss earbud stereophone | electronics - general | koss    | ispark    |   30.29 |

Entity B:
| title                                                              | category   | brand   | modelno   |   price |
|:-------------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| koss kdx100chr chrome noise isolation earbud stereophones - chrome | headphones | koss    | kdx100    |   32.33 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1313
rtable_id: 7836
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 |
|:---------------------------------------------------------|:----------------------|:--------|:----------|--------:|
| jvc lightweight folding headphones with bass boost black | electronics - general | jvc     | has600b   |   49.95 |

Entity B:
| title                                                  | category   | brand   | modelno   | price   |
|:-------------------------------------------------------|:-----------|:--------|:----------|:--------|
| jvc has150bx light weight flat folding headphone black | headphones | jvc     | has150bx  |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 705
rtable_id: 14798
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 pj phono rca jack cable end set of 25 |            | comprehensive |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1269
rtable_id: 18322
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 8gb cruzer usb flash drive pink | usb drives | sandisk | sdcz36z008gaw11p |   12.88 |

Entity B:
| title                                                         | category         | brand   | modelno        |   price |
|:--------------------------------------------------------------|:-----------------|:--------|:---------------|--------:|
| sandisk cruzer micro 16 gb usb 2.0 flash drive sdcz6-016g-a11 | usb flash drives | sandisk | sdcz6-016g-a11 |   49.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 339
rtable_id: 1619
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 |
|:-------------------------------------------------------------------------------|:-----------|:----------|:--------------|--------:|
| tony hawk birdhouse crowned skatedrive 2gb usb flash drive w xbox live support | usb drives | ep memory | bh-skthcrn/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: 915
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 |
|:---------------------------------------|:-----------|:---------|----------:|--------:|
| logitech wireless mouse m315 victorian | mice       | logitech | 910002534 |   19.88 |

Entity B:
| title                                               | category   | brand    | modelno    |   price |
|:----------------------------------------------------|:-----------|:---------|:-----------|--------:|
| logitech wireless mouse m310 blue shards 910-002483 | mice       | logitech | 910-002483 |   19.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2517
rtable_id: 12764
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 standard rear projection screen - 60 x 80 video format | electronics - general | da-lite |     27544 | 2931.99 |

Entity B:
| title                                                                        | category           | brand   |   modelno |   price |
|:-----------------------------------------------------------------------------|:-------------------|:--------|----------:|--------:|
| da-lite da-glas thru-the-wall rear projection screen - 90 x 120 video format | projection screens | da-lite |     23056 | 8729.48 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 417
rtable_id: 8786
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 |
|:--------------------------------|:----------------------|:--------|:----------|--------:|
| san francisco 49ers camera case | electronics - general | tribeca | fva2773   |   19.99 |

Entity B:
| title                                       | category              | brand   | modelno   |   price |
|:--------------------------------------------|:----------------------|:--------|:----------|--------:|
| san francisco 49ers ipod touch 4g hard case | computers accessories | tribeca |           |   29.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2258
rtable_id: 8795
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 cat5e snagless network patch cable blue | electronics - general | v7      | v7n3c5e-10f-blus |    4.88 |

Entity B:
| title                                                                                        | category        | brand   | modelno          |   price |
|:---------------------------------------------------------------------------------------------|:----------------|:--------|:-----------------|--------:|
| v7 cat5e snagless molded network patch cable rj45 male to male green 1-foot v7n3c5e-01f-grns | ethernet cables | v7      | v7n3c5e-01f-grns |    2.71 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 305
rtable_id: 9326
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 72 x 96 video format | electronics - general | da-lite |     27639 | 4448.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 625
rtable_id: 4728
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 |
|:-----------------------------------------|:----------------|:--------|:----------|--------:|
| ifrogz ipod touch 4 luxe lean case white | mp3 accessories | ifrogz  | it4ll-wht |   24.99 |

Entity B:
| title                                   | category   | brand   | modelno    |   price |
|:----------------------------------------|:-----------|:--------|:-----------|--------:|
| ifrogz luxe lean case for iphone 4 pink | cases      | ifrogz  | ip4gll-pnk |   19.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2476
rtable_id: 12982
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 tn360 black toner cartridge | printers   | brother | tn360     |   45.54 |

Entity B:
| title                           | category            | brand   | modelno   |   price |
|:--------------------------------|:--------------------|:--------|:----------|--------:|
| canon 104 black toner cartridge | laser printer toner | canon   | 0263b001a |   64.06 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 944
rtable_id: 5936
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 da-plex unframed rear projection screen - 108 x 144 video format | projection screens | da-lite |     27514 |    8094 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2472
rtable_id: 14687
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 unframed rear projection screen - 84 x 84 av format | electronics - general | da-lite |     27503 | 3561.99 |

Entity B:
| title                                                                      | category           | brand   | modelno   | price   |
|:---------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| da-lite 20032 holoscreen rear projection screen - 33 x 50 1 2 video format | projection screens | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1257
rtable_id: 14707
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 dect 6.0 expandable digital cordless answering system - 4 handset system kx-tg9334t | cordless telephones | panasonic | kx-tg9334t |   99.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2260
rtable_id: 7768
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-view thru-the-wall rear projection screen - 58 x 104 hdtv format | electronics - general | da-lite |     23074 |   22473 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 166
rtable_id: 286
label: 0