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 |
|:-------------------------------------------------------------|:----------------------|:---------|:----------|--------:|
| startech.com dp2dvi displayport to dvi video converter cable | electronics - general | startech | dp2dvi    |   18.88 |

Entity B:
| title                                                            | category    | brand    | modelno   |   price |
|:-----------------------------------------------------------------|:------------|:---------|:----------|--------:|
| startech.com dp2hdmi displayport to hdmi video adapter converter | hdmi cables | startech | dp2hdmi   |   15.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2163
rtable_id: 4094
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 |
|:---------------------------------------------------------|:------------------------------|:--------|:----------|--------:|
| cardinal zippered binder pockets 8-1 2 x 11 clear 3 pack | stationery & office machinery |         |           |    5.27 |

Entity B:
| title                                                          | category   | brand   | modelno   | price   |
|:---------------------------------------------------------------|:-----------|:--------|:----------|:--------|
| smead 89500 - poly ring binder pockets 9 x 11-1 2 clear 3 pack |            | smead   |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1362
rtable_id: 18484
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 acid-free poly folder 2 fasteners 1 3 cut top tab letter manila 24 box | stationery & office machinery |         |     10545 |   42.94 |

Entity B:
| title                                                                   | category            | brand   | modelno   | price   |
|:------------------------------------------------------------------------|:--------------------|:--------|:----------|:--------|
| smead 10235 - interior file folders 1 3 cut top tab letter aqua 100 box | printer accessories | smead   |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1689
rtable_id: 13502
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 |
|:------------------------------------------------------|:----------------|:--------|:----------|--------:|
| foldio p2 leather texture folio case for ipad 2 black | mp3 accessories | scosche | ipd2flbk  |   44.88 |

Entity B:
| title                                                                       | category                            | brand   | modelno   | price   |
|:----------------------------------------------------------------------------|:------------------------------------|:--------|:----------|:--------|
| scosche foldio p2 black carbon fiber texture folio case for ipad 2 ipd2cfbk | laptop netbook computer accessories | scosche | ipd2cfbk  |         |



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

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

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

Entity A:
| title                                                                          | category              | brand   |   modelno |   price |
|:-------------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-glas unframed rear projection screen - 43 1 4 x 57 3 4 video format | electronics - general | da-lite |     27602 |  920.99 |

Entity B:
| title                                                      | category           | brand   | modelno   |   price |
|:-----------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| da-glas base rear projection screen - 36 x 48 video format | projection screens | da-lite |           | 1199.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 967
rtable_id: 18465
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 |
|:-----------------|:------------------------|:--------|-------------:|--------:|
| htc sensation 4g | prepaid wireless phones | generic | 610214626400 |       0 |

Entity B:
| title                                   | category          | brand   | modelno   | price   |
|:----------------------------------------|:------------------|:--------|:----------|:--------|
| htc sensation 4g android phone t-mobile | phones with plans | htc     | sensation |         |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2140
rtable_id: 6965
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 |
|:-------------------------------------------------------|:-----------|:--------|:----------|--------:|
| lexmark 12a8425 black high-yield toner print cartridge | printers   | lexmark | 12a8425   |   302.4 |

Entity B:
| title                                     | category            | brand   | modelno   |   price |
|:------------------------------------------|:--------------------|:--------|:----------|--------:|
| brother tn-560 high-yield toner cartridge | laser printer toner | brother | tn-560    |   62.68 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2535
rtable_id: 335
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 |
|:------------------------------------------------|:-----------|:-----------|:----------|--------:|
| rubbermaid techfile plastic magazine file black | storage    | rubbermaid | 40406ros  |    5.88 |

Entity B:
| title                                                                         | category   | brand      | modelno   | price   |
|:------------------------------------------------------------------------------|:-----------|:-----------|:----------|:--------|
| rubbermaid 40406ros - techfile plastic magazine file 3 x 9 5 8 x 11 5 8 black | printers   | rubbermaid |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1207
rtable_id: 6898
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 deluxe rear projection screen - 84 x 84 av format | electronics - general | da-lite |     27650 | 4958.99 |

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



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

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

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

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



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

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

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

Entity A:
| title                                                                        | category              | brand   |   modelno |   price |
|:-----------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-plex thru-the-wall rear projection screen - 81 x 108 video format | electronics - general | da-lite |     23096 |   10049 |

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



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

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

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

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

Entity B:
| title                                        | category   | brand     | modelno   |   price |
|:---------------------------------------------|:-----------|:----------|:----------|--------:|
| 2.4 ghz wireless optical nano mouse blue usb | mice       | gear head | mp2175blu |   14.81 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1656
rtable_id: 20640
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 |
|:---------------------------------------------|:-----------|:--------|:----------|--------:|
| kingwin 2.4 ghz wireless optical mouse kw-06 | mice       | kingwin | kw-06     |    9.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1242
rtable_id: 8846
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 |
|:-----------------------------------------------------------------------|:------------|:--------|:-----------|--------:|
| seagate freeagent goflex 500gb usb 2.0 ultra-portable hard drive black | hard drives | seagate | 9zf2a2-570 |   71.07 |

Entity B:
| title                                                                                         | category             | brand   | modelno     |   price |
|:----------------------------------------------------------------------------------------------|:---------------------|:--------|:------------|--------:|
| seagate freeagent goflex 1 tb usb 3.0 ultra-portable external hard drive in black staa1000101 | external hard drives | seagate | staa1000101 |      87 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 201
rtable_id: 7549
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 |
|:-------------------------------------------------|:----------------------|:--------|:-----------|--------:|
| accell ultraav displayport multi-monitor adapter | electronics - general | accell  | k088b-001b |     149 |

Entity B:
| title                                                          | category   | brand   | modelno    |   price |
|:---------------------------------------------------------------|:-----------|:--------|:-----------|--------:|
| accell ultraav b101b-003b display port with vga active adapter |            | accell  | b101b-003b |   24.99 |



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

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

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

Entity A:
| title                                                                     | category              | brand   |   modelno |   price |
|:--------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-plex self trimming rear projection screen - 96 x 120 av format | electronics - general | da-lite |     27903 | 7799.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: 561
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 |
|:-------------------------------------------------|:------------------------------|:--------|:----------|--------:|
| 3m dry-erase board porcelain 8 x4 aluminum frame | stationery & office machinery | 3m      |           |  707.59 |

Entity B:
| title                                                                                 | category                | brand      | modelno   |   price |
|:--------------------------------------------------------------------------------------|:------------------------|:-----------|:----------|--------:|
| acco brands inc. 2548 magnetic dry-erase board porcelain 96 x 48 white aluminum frame | audio video accessories | kensington |           |  566.81 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2122
rtable_id: 14193
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 advantage manual with csr - wide format 113 diagonal | electronics - general | da-lite |     34716 |  888.99 |

Entity B:
| title                                                                           | category           | brand   | modelno   |   price |
|:--------------------------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| da-lite advantage manual with csr - projection screen - 1 1 - video spectra 1.5 | projection screens | da-lite |           |  594.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 612
rtable_id: 2829
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 500gb usb 3.0 portable external hard drive | hard drives | iosafe  | pa50500u5yr |  299.98 |

Entity B:
| title                                                                                               | category              | brand   |   modelno |   price |
|:----------------------------------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| lacie rugged all-terrain 1 tb firewire 800 firewire 400 usb 2.0 portable external hard drive 301924 | computers accessories | lacie   |    301924 |     199 |



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

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

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

Entity A:
| title                                                   | category   | brand   | modelno   |   price |
|:--------------------------------------------------------|:-----------|:--------|:----------|--------:|
| lexmark t650h11a black high-yield toner print cartridge | printers   | lexmark | t650h11a  |   565.2 |

Entity B:
| title                                       | category          | brand   | modelno   | price   |
|:--------------------------------------------|:------------------|:--------|:----------|:--------|
| 12a6830 black lexmark laser toner cartridge | printer ink toner | lexmark |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1418
rtable_id: 21423
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 |
|:------------------------------------------------------------------|:-----------|:---------|:----------|--------:|
| innovera d2130b black compatible high-yield toner print cartridge | printers   | innovera | d2130b    |    58.9 |

Entity B:
| title                                                                  | category            | brand    | modelno   |   price |
|:-----------------------------------------------------------------------|:--------------------|:---------|:----------|--------:|
| ld compatible samsung mlt-d209l high yield black laser toner cartridge | laser printer toner | 4inkjets |           |   57.99 |



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

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

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

Entity A:
| title                                                                        | category              | brand   |   modelno |   price |
|:-----------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-plex thru-the-wall rear projection screen - 81 x 108 video format | electronics - general | da-lite |     23096 |   10049 |

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: 2430
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 |
|:----------------------------------------|:----------------|:--------|:----------|--------:|
| ifrogz ipod touch 4 luxe lean case pink | mp3 accessories | ifrogz  | it4ll-pnk |   24.99 |

Entity B:
| title                             | category               | brand   | modelno   | price   |
|:----------------------------------|:-----------------------|:--------|:----------|:--------|
| case ipod touch 4 soft gloss pink | mp3 player accessories | unknown |           |         |



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

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

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

Entity A:
| title                                               | category              | brand   | modelno   |   price |
|:----------------------------------------------------|:----------------------|:--------|:----------|--------:|
| cobra 4-pin microphone with noise canceling feature | electronics - general | cobra   | hg-m77    |   18.36 |

Entity B:
| title                                                           | category                | brand   | modelno      |   price |
|:----------------------------------------------------------------|:------------------------|:--------|:-------------|--------:|
| cobra ca-m110r noise canceling replacement cb microphone chrome | microphones accessories | cobra   | ca-m110r chr |   19.96 |



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

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

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

Entity A:
| title                                                        | category              | brand   |   modelno |   price |
|:-------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite high power model b manual screen - 72 x 72 av format | electronics - general | da-lite |     33424 |  229.99 |

Entity B:
| title                                                   | category           | brand   | modelno    |   price |
|:--------------------------------------------------------|:-------------------|:--------|:-----------|--------:|
| da-lite model b with csr high power - projection screen | projection screens | da-lite | high power |  289.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2434
rtable_id: 809
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 mp2300blk 3 button wireless optical wheel mouse - black silver | mice       | gear head | mp2300blk |   13.82 |

Entity B:
| title                                                             | category              | brand     | modelno   |   price |
|:------------------------------------------------------------------|:----------------------|:----------|:----------|--------:|
| gear head 2.4 ghz wireless desktop 5 button optical mouse kb5800w | keyboard mouse combos | gear head | kb5800w   |   30.93 |



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

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

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

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

Entity B:
| title                                                                                                   | category                    | brand   | modelno   |   price |
|:--------------------------------------------------------------------------------------------------------|:----------------------------|:--------|:----------|--------:|
| casio ex-s200pk 14.1 mp digital camera with 4x optical image stabilized zoom with 2.7 inch tft lcd pink | point shoot digital cameras | casio   | ex-s200pk |     139 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2395
rtable_id: 4490
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 esata usb to sata external hard drive docking station for 2.5 hdd | electronics - general | startech | satadocku2e |   29.84 |

Entity B:
| title                                                                                                      | category              | brand    | modelno     |   price |
|:-----------------------------------------------------------------------------------------------------------|:----------------------|:---------|:------------|--------:|
| startech.com esata usb to sata external hard drive docking station for 2.5 or 3.5-inch satadocku2e - black | computers accessories | startech | satadocku2e |   26.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1589
rtable_id: 2645
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 |
|:-------------------------------------------------------------------------------|:-----------|:--------|:--------------|--------:|
| corsair memory vs2gbkit400c3 2 gb pc3200 400mhz 184-pin ddr desktop memory kit | memory     | corsair | vs2gbkit400c3 |   59.82 |

Entity B:
| title                                                                    | category   | brand   | modelno    |   price |
|:-------------------------------------------------------------------------|:-----------|:--------|:-----------|--------:|
| corsair memory vs1gb400c3 1 gb pc-3200 400mhz 184-pin ddr desktop memory | memory     | corsair | vs1gb400c3 |   24.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 722
rtable_id: 3097
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 - 60 x 80 video format | electronics - general | da-lite |     23046 |   13998 |

Entity B:
| title                                                                      | category           | brand   |   modelno |   price |
|:---------------------------------------------------------------------------|:-------------------|:--------|----------:|--------:|
| da-lite da-view thru-the-wall rear projection screen - 45 x 80 hdtv format | projection screens | da-lite |     23065 | 12909.9 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 852
rtable_id: 12781
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 |
|:----------------------------------------------------------------------------------|:------------|:----------------|:----------------|--------:|
| western digital 1tb my passport essential se usb 3.0 portable external hard drive | hard drives | western digital | wdbacx0010bbksn |   98.92 |

Entity B:
| title                                                                                                  | category             | brand           | modelno    |   price |
|:-------------------------------------------------------------------------------------------------------|:---------------------|:----------------|:-----------|--------:|
| western digital my passport studio 500 gb firewire 800 400 usb 2.0 portable external hard drive silver | external hard drives | western digital | wdmt5000tn |  128.98 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 419
rtable_id: 8992
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 |
|:-------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| sharpie retractable fine point permanent markers | stationery & office machinery | sharpie |     32760 |    5.99 |

Entity B:
| title                                                                                 | category     | brand   | modelno   |   price |
|:--------------------------------------------------------------------------------------|:-------------|:--------|:----------|--------:|
| sharpie 1753180 - porous point retractable permanent water resistant pen red ink fine | distribution | sharpie |           |   22.35 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2284
rtable_id: 20015
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 |
|:----------------------------------------------------|:----------------------|:--------------------|:----------|--------:|
| green onions supply iveil hybrid keyboard protector | electronics - general | green onions supply | rt-kbhb06 |   31.88 |

Entity B:
| title                                                                                       | category   | brand   | modelno   |   price |
|:--------------------------------------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| green onions supply iveil hybrid keyboard protector for 11-inch apple macbook air rt-kbhb08 | keyboards  | green   | rt-kbhb08 |      29 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 708
rtable_id: 1101
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 27636 da-glas standard rear projection screen 50 1 2 x 67 1 4 video format | projection screens | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2472
rtable_id: 2818
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 ktd-dm8400a 1g 1gb ddr2 sdram memory module | memory     | kingston | ktd-dm8400a / 1g |   22.92 |

Entity B:
| title                                                                                    | category   | brand    | modelno          |   price |
|:-----------------------------------------------------------------------------------------|:-----------|:---------|:-----------------|--------:|
| kingston 256mb ddr2 sdram memory module 256mb 1 x 256mb ddr2 sdram 144pin kth-lj2015 256 | memory     | kingston | kth-lj2015 / 256 |     9.6 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 41
rtable_id: 8855
label: 0