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 |
|:-------------------------------------------------------------------|:------------|:--------|----------:|--------:|
| iomega 2tb ego desktop usb 2.0 portable hard drive - midnight blue | hard drives | iomega  |     34822 |  122.98 |

Entity B:
| title                                                                    | category              | brand   |   modelno |   price |
|:-------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| iomega ego helium 1 tb usb 2.0 portable external hard drive 34820 silver | computers accessories | iomega  |     34820 |  124.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 397
rtable_id: 14826
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 - 69 x 92 video format | electronics - general | da-lite |     82969 |  472.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2222
rtable_id: 6745
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 x651h11a high-yield toner 25000 page-yield black | printers   | lexmark | x651h11a  |   565.2 |

Entity B:
| title                                                 | category              | brand   | modelno   | price   |
|:------------------------------------------------------|:----------------------|:--------|:----------|:--------|
| lexmark 08a0476 - 08a0476 toner 3000 page-yield black | computers accessories | lexmark |           |         |



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

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

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

Entity A:
| title                         | category   | brand   | modelno       |   price |
|:------------------------------|:-----------|:--------|:--------------|--------:|
| sandisk 16gb sdhc memory card | usb drives | sandisk | sdsdb016gaw11 |   34.54 |

Entity B:
| title                                     | category   | brand   | modelno   |   price |
|:------------------------------------------|:-----------|:--------|:----------|--------:|
| sandisk microsd to sd memory card adapter |            | sandisk |           |     1.5 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1805
rtable_id: 8138
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 |
|:--------------------------------------|:----------------------|:------------|:----------|--------:|
| plantronics h91cis encore h91 headset | electronics - general | plantronics | h91cis    |  119.88 |

Entity B:
| title                                  | category             | brand       | modelno                                  |   price |
|:---------------------------------------|:---------------------|:------------|:-----------------------------------------|--------:|
| plantronics . audio 626 dsp pc headset | headsets microphones | plantronics | plantronics . audio 626 , dsp pc headset |   28.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2283
rtable_id: 13673
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 |
|:------------------------------------------------------|:----------------------|:--------|:------------|--------:|
| evga geforce 210 512mb ddr3 pci express graphics card | electronics - general | evga    | 512p31310lr |   32.88 |

Entity B:
| title                                                             | category   | brand   | modelno   |   price |
|:------------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| nvidia geforce 310 dms59 pcie16 512mb 2port vga dvi graphics card |            | lenovo  | 57y4167   |  102.24 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 934
rtable_id: 19677
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 |
|:-------------------------------------------|:-----------|:--------|:----------|--------:|
| edge 8gb diskgo usb 2.0 flash drive silver | usb drives | edge    | pe204198  |   10.98 |

Entity B:
| title                                       | category         | brand   |   modelno |   price |
|:--------------------------------------------|:-----------------|:--------|----------:|--------:|
| memorex traveldrive 8gb usb 2.0 flash drive | usb flash drives | memorex |  32509097 |   26.64 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1661
rtable_id: 8711
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 av-gp 320gb sata desktop internal hard drive | hard drives | western digital | wd3200avvs |    51.7 |

Entity B:
| title                                                                          | category             | brand           | modelno            |   price |
|:-------------------------------------------------------------------------------|:---------------------|:----------------|:-------------------|--------:|
| western digital my book essential 2 tb usb 3.0 2.0 desktop external hard drive | external hard drives | western digital | wdbacw0020hbk-nesn |   89.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 998
rtable_id: 21844
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 advantage manual with csr - hdtv format 133 diagonal | electronics - general | da-lite |     85742 | 1267.99 |

Entity B:
| title                                                                    | category           | brand   | modelno   |   price |
|:-------------------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| da-lite advantage manual with csr - projection screen - 1 1 - high power | projection screens | da-lite |           |  709.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1134
rtable_id: 6754
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-plex standard rear projection screen - 96 x 96 av format | projection screens | da-lite |           | 5912.99 |



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

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

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

Entity A:
| title                                              | category              | brand   | modelno         |   price |
|:---------------------------------------------------|:----------------------|:--------|:----------------|--------:|
| v7 25 cat6 snagless molded network patch cable red | electronics - general | v7      | v7n2c6-25f-reds |    9.76 |

Entity B:
| title                                                                                        | category        | brand   | modelno          |   price |
|:---------------------------------------------------------------------------------------------|:----------------|:--------|:-----------------|--------:|
| v7 cat5e snagless molded network patch cable rj45 male to male black 2-feet v7n3c5e-02f-blks | ethernet cables | v7      | v7n3c5e-02f-blks |    2.83 |



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

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

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

Entity A:
| title                                                             | category              | brand   |   modelno |   price |
|:------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-plex deluxe rear projection screen - 96 x 96 av format | electronics - general | da-lite |     27557 | 6426.99 |

Entity B:
| title                                                              | category           | brand   | modelno   |   price |
|:-------------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| da-plex base rear projection screen - 43 1 4 x 57 3 4 video format | projection screens | da-lite |           | 1669.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2020
rtable_id: 9734
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 |
|:-----------------------------------------------------------------------------|:------------------------------|:--------------------|----------:|--------:|
| tops second nature subject wire notebook college rule 6 x 9-1 2 we 80 sheets | stationery & office machinery | tops business forms |     74109 |    5.54 |

Entity B:
| title                                                                                     | category   | brand    | modelno   |   price |
|:------------------------------------------------------------------------------------------|:-----------|:---------|:----------|--------:|
| national brand 31364 - 3-subject notebook college margin rule 6-3 8 x 9-1 2 we 120 sheets | printers   | national |           |   16.17 |



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

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

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

Entity A:
| title                              | category   | brand    |   modelno |   price |
|:-----------------------------------|:-----------|:---------|----------:|--------:|
| logitech wireless mouse dark fleur | mice       | logitech | 910001898 |   27.82 |

Entity B:
| title                                                | category   | brand    | modelno    |   price |
|:-----------------------------------------------------|:-----------|:---------|:-----------|--------:|
| logitech wireless mouse m185 - swift gray 910-002225 | mice       | logitech | 910-002225 |   18.99 |



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

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

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

Entity A:
| title                                                                       | category              | brand   |   modelno |   price |
|:----------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-view thru-the-wall rear projection screen - 58 x 104 hdtv format | electronics - general | da-lite |     23074 |   22473 |

Entity B:
| title                                                                           | category           | brand   |   modelno |   price |
|:--------------------------------------------------------------------------------|:-------------------|:--------|----------:|--------:|
| da-lite da-plex self trimming rear projection screen - 94 1 2 x 168 hdtv format | projection screens | da-lite |     27151 | 9233.33 |



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

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

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

Entity A:
| title                                                                  | category              | brand   |   modelno |   price |
|:-----------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite matte white model c with csr manual screen - 72 x 72 av format | electronics - general | da-lite |     33403 |  563.99 |

Entity B:
| title                                                          | category           | brand   | modelno     |   price |
|:---------------------------------------------------------------|:-------------------|:--------|:------------|--------:|
| da-lite deluxe model b matte white - projection screen - 72 in | projection screens | da-lite | matte white |   127.1 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1133
rtable_id: 20715
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 |
|:----------------------------------|:------------------------------|:--------|----------:|--------:|
| inland pro 6-sheet paper shredder | stationery & office machinery | inland  |      5301 |   28.54 |

Entity B:
| title                           | category   | brand   |   modelno |   price |
|:--------------------------------|:-----------|:--------|----------:|--------:|
| inland pro 05304 paper shredder | shredders  | inland  |      5304 |   59.54 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 828
rtable_id: 4885
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 bci-6bk black ink tank | inkjet printer ink | canon   | 4705a003  |   11.39 |



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

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

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

Entity A:
| title                                                                    | category                      | brand   |   modelno |   price |
|:-------------------------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| avery allstate-style legal side tab divider title a letter white 25 pack | stationery & office machinery | avery   |     82163 |    5.69 |

Entity B:
| title                                                                           | category            | brand   | modelno   | price   |
|:--------------------------------------------------------------------------------|:--------------------|:--------|:----------|:--------|
| avery 01388 - preprinted legal side tab dividers exhibit r letter white 25 pack | printer accessories | avery   |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 740
rtable_id: 16777
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 |
|:----------------------------------------------------------------------------|:---------------------------------|:--------|:----------|--------:|
| blue crane nbc121 introduction to the canon 50d volume 1 basic controls dvd | camera and camcorder accessories | norazza | nbc121    |      19 |

Entity B:
| title                                                                                          | category   | brand              | modelno   |   price |
|:-----------------------------------------------------------------------------------------------|:-----------|:-------------------|:----------|--------:|
| introduction to the canon 5d mark ii vol . 1 basic controls training dvd by blue crane digital |            | blue crane digital | zbc123    |   20.33 |



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

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

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

Entity A:
| title                              | category   | brand   | modelno      |   price |
|:-----------------------------------|:-----------|:--------|:-------------|--------:|
| siig usb 2.0 bay media card reader | usb drives | siig    | ju-mr0012-s1 |   16.82 |

Entity B:
| title                         | category             | brand   | modelno      |   price |
|:------------------------------|:---------------------|:--------|:-------------|--------:|
| usb 2.0 bay media card reader | computer accessories | siig    | ju-mr0012-s1 |   16.82 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 294
rtable_id: 19911
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 t650a11a black toner print cartridge | printers   | lexmark | t650a11a  |  202.87 |

Entity B:
| title                                       | category          | brand   | modelno   |   price |
|:--------------------------------------------|:------------------|:--------|:----------|--------:|
| lexmark e120 return program toner cartridge | printer ink toner | lexmark | 12015sa   |   63.99 |



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

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

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

Entity A:
| title                                                             | category              | brand   |   modelno |   price |
|:------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-plex deluxe rear projection screen - 96 x 96 av format | electronics - general | da-lite |     27557 | 6426.99 |

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



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

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

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

Entity A:
| title                             | category       | brand   |   modelno |   price |
|:----------------------------------|:---------------|:--------|----------:|--------:|
| zax pro series component cable 3m | tv accessories | zax     |     87203 |   11.88 |

Entity B:
| title                                     | category              | brand   | modelno   | price   |
|:------------------------------------------|:----------------------|:--------|:----------|:--------|
| zax 87710 pro series subwoofer cable 10 m | computers accessories | zax     |           |         |



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

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

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

Entity A:
| title                                      | category        | brand    |   modelno |   price |
|:-------------------------------------------|:----------------|:---------|----------:|--------:|
| verbatim 94892 datalifeplus 52x cd-r media | mp3 accessories | verbatim |     94892 |   19.88 |

Entity B:
| title                                                                                               | category   | brand    |   modelno |   price |
|:----------------------------------------------------------------------------------------------------|:-----------|:---------|----------:|--------:|
| verbatim 94892 700 mb 52x datalifeplus silver inkjet printable recordable disc cd-r 50-disc spindle | cd-r discs | verbatim |     94892 |   14.15 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1441
rtable_id: 15284
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 |
|:--------------------------------------|:-----------|:--------|:----------|--------:|
| hp laserjet 53x black print cartridge | printers   | hp      | q7553x    |  164.84 |

Entity B:
| title                                                                       | category          | brand   | modelno   |   price |
|:----------------------------------------------------------------------------|:------------------|:--------|:----------|--------:|
| hp color laserjet cc530a dual pack black print cartridges cc530ad dual pack | printer ink toner | hp      | cc530ad   |  141.87 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2405
rtable_id: 14929
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 |
|:---------------------------------|:----------------------|:--------|:-------------|--------:|
| maxell juicy tunes earbuds green | electronics - general | maxell  | 190242 jt-pu |    9.88 |

Entity B:
| title                     | category   | brand   |   modelno |   price |
|:--------------------------|:-----------|:--------|----------:|--------:|
| maxell juicy tunes earbud | headphones | maxell  |    190239 |    8.05 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1741
rtable_id: 8736
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 |
|:------------------------------------|:-----------------|:---------|:----------|--------:|
| motorola xoom vehicle power adapter | laptop computers | motorola | 89453n    |   26.99 |

Entity B:
| title                                                                      | category                       | brand    | modelno   |   price |
|:---------------------------------------------------------------------------|:-------------------------------|:---------|:----------|--------:|
| motorola vehicle power adapter for motorola xoom motorola retail packaging | batteries chargers accessories | motorola | 89453n    |   16.25 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1024
rtable_id: 12674
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 |
|:----------------------------------------|:----------------------|:--------|:----------|--------:|
| epson america powerlite d6250 projector | electronics - general | epson   | elpd6250  |    1599 |

Entity B:
| title                                      | category         | brand   | modelno    | price   |
|:-------------------------------------------|:-----------------|:--------|:-----------|:--------|
| epson powerlite 1770w projector v11h362020 | video projectors | epson   | v11h362020 |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1471
rtable_id: 1177
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 cr1620 lithium battery card of 5 ormd | coin button cell | energizer | cr1620    |    4.45 |



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

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

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

Entity A:
| title                                             | category   | brand     | modelno   |   price |
|:--------------------------------------------------|:-----------|:----------|:----------|--------:|
| microsoft wireless mobile mouse 4000 sgkomen pink | mice       | microsoft | d5d-00052 |      20 |

Entity B:
| title                                                  | category   | brand     | modelno   |   price |
|:-------------------------------------------------------|:-----------|:----------|:----------|--------:|
| microsoft wireless mobile mouse 4000 - ocean teal blue | mice       | microsoft | d5d-00025 |   18.29 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 219
rtable_id: 730
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 |
|:-----------------------------|:-----------|:--------|:-----------|--------:|
| d-link wireless access point | computers  | d-link  | dwl-2100ap |  119.88 |

Entity B:
| title                                     | category                | brand   | modelno   |   price |
|:------------------------------------------|:------------------------|:--------|:----------|--------:|
| asus wl330ge wireless pocket access point | audio video accessories | asus    | wl-330ge  |   43.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1072
rtable_id: 11222
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 |
|:-----------------------------|:-----------|:--------|:-----------|--------:|
| d-link wireless access point | computers  | d-link  | dwl-2100ap |  119.88 |

Entity B:
| title                       | category            | brand   | modelno      |   price |
|:----------------------------|:--------------------|:--------|:-------------|--------:|
| wireless-n 150 access point | networking products | netgear | wn604-100nas |   63.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1072
rtable_id: 20411
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 |
|:---------------------------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| roocase executive portfolio leather case stylus for asus eee pad transformer tf101 10.1-inch | electronics - general | roocase |    222057 |   55.99 |

Entity B:
| title                                                                                                                                                 | category      | brand   | modelno   |   price |
|:------------------------------------------------------------------------------------------------------------------------------------------------------|:--------------|:--------|:----------|--------:|
| roocase executive portfolio magenta leather case cover with landscape portrait view for asus eee pad transformer 10.1-inch tf101 android tablet wi-fi | cases sleeves | roocase |           |   43.64 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 523
rtable_id: 7630
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 honey maple veneer model b manual screen with matte white fabric - 60 x 60 diagonal video format | electronics - general | da-lite |     87184 |  167.99 |

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



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

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

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

Entity A:
| title                                                                     | category       | brand         | modelno        |   price |
|:--------------------------------------------------------------------------|:---------------|:--------------|:---------------|--------:|
| comprehensive wallplate with vga stereo mini s-video and 5 rca connectors | tv accessories | comprehensive | wp-2100-e-p-ac |    77.6 |

Entity B:
| title                                                                        | category   | brand         | modelno   | price   |
|:-----------------------------------------------------------------------------|:-----------|:--------------|:----------|:--------|
| comprehensive wp-2300-e-s-ac wallplate with 2 xlr latching-female connectors |            | comprehensive |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1935
rtable_id: 5916
label: 0