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 |
|:-------------------------------------------------------|:----------------------|:--------|:-----------|--------:|
| elite screens 92 vmax92uwv2 electric projection screen | electronics - general | elite   | vmax92uwv2 |  319.59 |

Entity B:
| title                                                                            | category           | brand   | modelno    |   price |
|:---------------------------------------------------------------------------------|:-------------------|:--------|:-----------|--------:|
| elite screens vmax2 electric projection screen 16 9 aspect ratio-120in max white | projection screens | elite   | vmax120xwh |     350 |



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

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

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

Entity A:
| title                                                      | category   | brand    | modelno          |   price |
|:-----------------------------------------------------------|:-----------|:---------|:-----------------|--------:|
| kingston hyperx 4gb kit 2 x 2gb ddr3 desktop memory module | memory     | kingston | khx1800c9d3k2/4g |   83.99 |

Entity B:
| title                                                                                  | category   | brand    | modelno       |   price |
|:---------------------------------------------------------------------------------------|:-----------|:---------|:--------------|--------:|
| kingston valueram 2gb kit 2x1gb modules 400mhz pc3200 ddr desktop memory kvr400ak2 2gr | memory     | kingston | kvr400ak2/2gr |   83.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1729
rtable_id: 879
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 video spectra 1.5 model c manual screen - 7 x 9 av format | electronics - general | da-lite |     82965 |  503.99 |

Entity B:
| title                                                                | category           | brand   | modelno           |   price |
|:---------------------------------------------------------------------|:-------------------|:--------|:------------------|--------:|
| da-lite deluxe model b video spectra 1.5 - projection screen - 92 in | projection screens | da-lite | video spectra 1.5 |  194.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 244
rtable_id: 14701
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 color laserjet 4600 smart print cartridge magenta | printers   | hp      | c9723a    |  234.84 |

Entity B:
| title                             | category       | brand   | modelno     |   price |
|:----------------------------------|:---------------|:--------|:------------|--------:|
| hp cp2025n color laserjet printer | laser printers | hp      | cb494a #aba |  349.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2002
rtable_id: 1041
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 |
|:-------------------------------------------------|:----------------------|:--------|:----------|--------:|
| michigan wolverines iphone 4 case silicone cover | electronics - general | tribeca | fva3437   |   24.99 |

Entity B:
| title                                  | category              | brand   | modelno   |   price |
|:---------------------------------------|:----------------------|:--------|:----------|--------:|
| utah jazz iphone 4 case silicone cover | computers accessories | tribeca |           |   17.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1229
rtable_id: 14005
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 |
|:--------------------------------------------|:----------------------|:--------|:----------|--------:|
| incipio smart feather for apple ipad 2 lime | electronics - general | incipio | ipad-228  |   33.25 |

Entity B:
| title                                            | category      | brand   | modelno   |   price |
|:-------------------------------------------------|:--------------|:--------|:----------|--------:|
| incipio feather case for ipad 2 - black ipad-206 | cases sleeves | incipio | ipad-206  |   21.69 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1983
rtable_id: 8937
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 |
|:-----------------------------------------|:------------------------------|:-----------|----------:|--------:|
| paper mate mechanical pencil starter set | stationery & office machinery | paper mate |   1739312 |    4.87 |

Entity B:
| title                                                                                            | category            | brand      | modelno   |   price |
|:-------------------------------------------------------------------------------------------------|:--------------------|:-----------|:----------|--------:|
| paper mate 1739312 - megalead mechanical pencil starter set 0.7 mm 2 erasure refills blue barrel | printer accessories | paper mate |           |   23.96 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1559
rtable_id: 14553
label: 1
Task: Entity-Matching (source dataset: Walmart-Amazon)

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

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

Entity A:
| title                                                                     | category              | brand   |   modelno |   price |
|:--------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-glas 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-glas base rear projection screen - 70 x 70 av format | projection screens | da-lite |           | 2622.99 |



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

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

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

Entity A:
| title                                     | category   | brand    | modelno   |   price |
|:------------------------------------------|:-----------|:---------|:----------|--------:|
| logitech m315 wireless optical mouse blue | mice       | logitech | m315      |   19.88 |

Entity B:
| title                              | category   | brand    | modelno    |   price |
|:-----------------------------------|:-----------|:---------|:-----------|--------:|
| logitech wireless mouse m305 black | mice       | logitech | 910-001752 |   20.59 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1656
rtable_id: 8235
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 |
|:--------------------------------------------------------------------|:---------------------|:--------|:------------|--------:|
| iosafe rugged portable 1 tb usb 3.0 external hard drive pa51000u1yr | external hard drives | iosafe  | pa51000u1yr |  284.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 672
rtable_id: 951
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 |
|:------------------------------------------------------|:----------------------|:--------|:----------|--------:|
| uniden d1680 dect 6.0 with caller id and call waiting | electronics - general | uniden  | d1680     |   33.84 |

Entity B:
| title                                                                                                        | category            | brand   | modelno   |   price |
|:-------------------------------------------------------------------------------------------------------------|:--------------------|:--------|:----------|--------:|
| new-uniden d1660 dect 6.0 cordless phone system with call waiting caller id single-handset system - unnd1660 | cordless telephones | uniden  |           |   24.09 |



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

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

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

Entity A:
| title                                    | category   | brand   | modelno   |   price |
|:-----------------------------------------|:-----------|:--------|:----------|--------:|
| epson t125420 yellow durabrite cartridge | printers   | epson   | t125420   |   11.88 |

Entity B:
| title                                       | category           | brand   | modelno   |   price |
|:--------------------------------------------|:-------------------|:--------|:----------|--------:|
| epson t044120 durabrite black ink cartridge | inkjet printer ink | epson   | t044120   |    9.19 |



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

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

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

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

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1296
rtable_id: 18153
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 40184 model b manual wall and ceiling projection screen | electronics - general | da-lite |     40184 |   47.84 |

Entity B:
| title                                                    | category           | brand          |   modelno |   price |
|:---------------------------------------------------------|:-------------------|:---------------|----------:|--------:|
| 70inx70in model b manual screen wall ceiling matte white | projection screens | da-lite screen |     40188 |   54.54 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 327
rtable_id: 15969
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 deluxe rear projection screen - 96 x 96 av format | electronics - general | da-lite |     27651 | 6128.99 |

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



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

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

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

Entity A:
| title                                     | category   | brand   | modelno          |   price |
|:------------------------------------------|:-----------|:--------|:-----------------|--------:|
| epson t068120-d2 dual black ink cartridge | printers   | epson   | epson t068120-d2 |   39.84 |

Entity B:
| title                                 | category           | brand   | modelno   |   price |
|:--------------------------------------|:-------------------|:--------|:----------|--------:|
| epson t029201 tri-color ink cartridge | inkjet printer ink | epson   | t029201   |   14.69 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1631
rtable_id: 1172
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 |
|:------------------------------------------------------------|:----------------|:-------------------|:----------|--------:|
| cocoon innovations grid-it large organizer for binder black | mp3 accessories | cocoon innovations | cpg25bk   |   19.99 |

Entity B:
| title                                                | category   | brand   | modelno   |   price |
|:-----------------------------------------------------|:-----------|:--------|:----------|--------:|
| cocoon cpg20bk grid-it organizer 15 x 9.5 inch black | bags cases | cocoon  | cpg20bk   |   24.45 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 238
rtable_id: 4451
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 |
|:----------------------------------------------|:--------------------|:--------|:----------|--------:|
| hp 92298x 98x microfine black toner cartridge | laser printer toner | hp      | 92298x    |   57.98 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 944
rtable_id: 6997
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 430w atx12v 2.3 80 plus computer power supply active pfc | electronics - general | startech | atx2power430 |      60 |

Entity B:
| title                                                                                                | category       | brand    | modelno      |   price |
|:-----------------------------------------------------------------------------------------------------|:---------------|:---------|:-------------|--------:|
| startech.com professional 630 watt atx12v 2.3 80 plus computer modular power supply atx atx2pw630pro | power supplies | startech | atx2pw630pro |  104.75 |



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

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

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

Entity A:
| title                                                                        | category              | brand   |   modelno |   price |
|:-----------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-plex deluxe rear projection screen - 50 1 2 x 67 1 4 video format | electronics - general | da-lite |     27562 | 2544.99 |

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



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

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

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

Entity A:
| title                                                 | category              | brand   | modelno   |   price |
|:------------------------------------------------------|:----------------------|:--------|:----------|--------:|
| endust for electronics ultimate office cleaning combo | electronics - general | endust  | 12886bp   |   64.99 |

Entity B:
| title                                                     | category            | brand   | modelno   |   price |
|:----------------------------------------------------------|:--------------------|:--------|:----------|--------:|
| endust 12886bp electronics ultimate office cleaning combo | monitor accessories | endust  | 12886bp   |   29.86 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2087
rtable_id: 11143
label: 1
Task: Entity-Matching (source dataset: Walmart-Amazon)

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

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

Entity A:
| title                                                                       | category              | brand   |   modelno |   price |
|:----------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-view thru-the-wall rear projection screen - 60 x 80 video format | electronics - general | da-lite |     23046 |   13998 |

Entity B:
| title                                                                      | category           | brand   | modelno   | price   |
|:---------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| da-lite 27912 da-glas unframed rear projection screen - 96 x 120 av format | projection screens | da-lite |           |         |



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

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

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

Entity A:
| title                                                     | category              | brand    | modelno   |   price |
|:----------------------------------------------------------|:----------------------|:---------|:----------|--------:|
| startech 3 slim 3.5 mm right angle stereo audio cable m m | electronics - general | startech | mu3mms2ra |    7.88 |

Entity B:
| title                                                           | category            | brand    | modelno   |   price |
|:----------------------------------------------------------------|:--------------------|:---------|:----------|--------:|
| startech.com mu3mms slim 3.5 mm stereo audio cable - m m 3-feet | connectors adapters | startech | mu3mms    |    3.49 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1573
rtable_id: 5414
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 - purple black usb mp2950pur-cp10 | mice       | gear head | mp2950pur-cp10 |   14.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1242
rtable_id: 13107
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 |
|:----------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| amzer luxe argyle high-gloss skin case for samsung galaxy clear | electronics - general | amzer   |     89720 |   14.88 |

Entity B:
| title                                                                                   | category   | brand   | modelno   |   price |
|:----------------------------------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| amzer luxe argyle high gloss tpu soft gel skin case for samsung focus i917 - smoke grey | cases      | amzer   | amz89964  |    8.75 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 638
rtable_id: 20333
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 |
|:--------------------------------------------------------------------------------------------------|:-----------|:--------|:----------------|--------:|
| corsair cm2x2048-6400c5 xms2 2gb pc2-6400 800mhz 240-pin ddr2 cl5 dual channel desktop memory kit | memory     | corsair | cm2x2048-6400c5 |   40.82 |

Entity B:
| title                                                                                    | category              | brand   | modelno      |   price |
|:-----------------------------------------------------------------------------------------|:----------------------|:--------|:-------------|--------:|
| corsair memory vs4gsds800d2 4 gb 2 x 2 gb pc2-6400 800mhz 200-pin ddr2 laptop memory kit | computers accessories | corsair | vs4gsds800d2 |   64.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 599
rtable_id: 6458
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 3 button wireless optical wheel mouse blk slvr usb | audio video accessories | gear head | mp2300blk |   18.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1242
rtable_id: 6308
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 |
|:---------------------------------------------------------------------------|:---------------------|:----------------|:-------------------|--------:|
| western digital wd elements se 750 gb usb 2.0 portable external hard drive | external hard drives | western digital | wdbabv7500abk-nesn |   69.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 672
rtable_id: 1284
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 8 gb professional class 10 secure digital sdhc card | memory cards | wintec  | 3fmsd8gbc10-r |   11.99 |



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

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

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

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

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



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

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

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

Entity A:
| title                                                 | category    | brand   | modelno    |   price |
|:------------------------------------------------------|:------------|:--------|:-----------|--------:|
| sony bdp-s360 1080p blu-ray disc player - refurbished | dvd players | sony    | rbbdp-s360 |      79 |

Entity B:
| title                             | category             | brand   | modelno   | price   |
|:----------------------------------|:---------------------|:--------|:----------|:--------|
| sony bdp-s280 blu-ray disc player | blu-ray disc players | sony    |           |         |



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

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

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

Entity A:
| title                                                   | category                      | brand   |   modelno |   price |
|:--------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| smead file folders 1 2 cut 1-ply top tab manila 100 box | stationery & office machinery |         |     15320 |   34.05 |

Entity B:
| title                                                                              | category   | brand   | modelno   | price   |
|:-----------------------------------------------------------------------------------|:-----------|:--------|:----------|:--------|
| smead 10776 - kraft file folder 2 5 cut right two-ply top tab letter brown 100 box |            | smead   |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1711
rtable_id: 18813
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 |
|:----------------------------------------------------------|:-----------------|:--------|:-----------|--------:|
| tp-link tl-sc3171g wireless day night surveillance camera | garden - general | tp link | tl-sc3171g |     172 |

Entity B:
| title                                             | category       | brand   | modelno   |   price |
|:--------------------------------------------------|:---------------|:--------|:----------|--------:|
| tp-link tl-sc3130 2-way audio surveillance camera | bullet cameras | tp-link | tl-sc3130 |   79.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 898
rtable_id: 7376
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 holoscreen rear projection screen - 22 x 33 3 4 video format | electronics - general | da-lite |     20030 |    1600 |

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: 626
rtable_id: 286
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 |
|:-----------------------------|:-----------|:--------|:----------|--------:|
| canon cli-226 black ink tank | printers   | canon   | 4546b001  |   13.97 |

Entity B:
| title                                   | category           | brand   | modelno   |   price |
|:----------------------------------------|:-------------------|:--------|:----------|--------:|
| canon cli-8 8-color multipack ink tanks | inkjet printer ink | canon   | 0620b015  |    83.5 |



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

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

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

Entity A:
| title                         | category              | brand     | modelno   |   price |
|:------------------------------|:----------------------|:----------|:----------|--------:|
| energizer lithium aaa battery | electronics - general | energizer | ea92bp-8  |      21 |

Entity B:
| title                          | category         | brand     | modelno   |   price |
|:-------------------------------|:-----------------|:----------|:----------|--------:|
| energizer 2l76bp photo battery | camera batteries | energizer | 2l76bp    |    3.73 |



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