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 |
|:----------------------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| avery self-adhesive filing labels 1 3 cut 3-7 16 x 2 3 clear 450 pack | stationery & office machinery | avery   |      5029 |   21.47 |

Entity B:
| title                                                                                      | category               | brand   | modelno   |   price |
|:-------------------------------------------------------------------------------------------|:-----------------------|:--------|:----------|--------:|
| new-avery 5029 - self-adhesive filing labels 1 3 cut 2 3 x 3-7 16 clear 450 pack - ave5029 | other office equipment | avery   |           |      35 |



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

Entity B:
| title                                                                          | category           | brand   | modelno   | price   |
|:-------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| da-lite 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: 417
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 |
|:-----------------------------------------|:-----------|:--------|:----------|--------:|
| epson t125420 yellow durabrite cartridge | printers   | epson   | t125420   |   11.88 |

Entity B:
| title                              | category           | brand   | modelno   |   price |
|:-----------------------------------|:-------------------|:--------|:----------|--------:|
| epson t042420 yellow ink cartridge | inkjet printer ink | epson   | t042420   |   10.17 |



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

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

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

Entity A:
| title                                                     | category   | brand   | modelno    |   price |
|:----------------------------------------------------------|:-----------|:--------|:-----------|--------:|
| wintec filemate 4gb sdhc secure digital flash memory card | usb drives | wintec  | 3fmsd4gb-r |    7.99 |

Entity B:
| title                                                                 | category     | brand   | modelno   | price   |
|:----------------------------------------------------------------------|:-------------|:--------|:----------|:--------|
| kodak secure digital sd 8gb multi-use high capacity flash memory card | memory cards | kodak   | ksd8gbpbt |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1992
rtable_id: 9880
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 |
|:----------------------------------------------------------|:----------------------|:--------|:-----------|--------:|
| xfx ati radeon 5670 hd pci-express 1gb ddr3 graphics card | electronics - general | xfx     | hd567xznl3 |   91.88 |

Entity B:
| title                                                                                | category              | brand    | modelno   |   price |
|:-------------------------------------------------------------------------------------|:----------------------|:---------|:----------|--------:|
| sapphire radeon hd 5570 - 1 gb ddr3 hdmi dvi-i vga pci-express graphics card 100293l | computers accessories | sapphire | 100293l   |   79.78 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1931
rtable_id: 177
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 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: 2472
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 |
|:------------------------------------------------------------------|:-----------|:----------------|:------------|--------:|
| western digital 2tb my book studio edition ii external hard drive | computers  | western digital | wdh2q20000n |     199 |

Entity B:
| title                                                                    | category             | brand           | modelno            |   price |
|:-------------------------------------------------------------------------|:---------------------|:----------------|:-------------------|--------:|
| western digital my book for mac 1 tb usb 2.0 desktop external hard drive | external hard drives | western digital | wdbaag0010hch-nesn |   89.99 |



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

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

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

Entity A:
| title                                                                  | category              | brand   |   modelno |   price |
|:-----------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-plex standard rear projection screen - 60 x 80 video format | electronics - general | da-lite |     27544 | 2931.99 |

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



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

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

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

Entity A:
| title                                                             | category              | brand   |   modelno |   price |
|:------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-glas deluxe rear projection screen - 84 x 84 av format | electronics - general | da-lite |     27650 | 4958.99 |

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



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

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

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

Entity A:
| title                                                         | category    | brand    | modelno   |   price |
|:--------------------------------------------------------------|:------------|:---------|:----------|--------:|
| verbatim smartdisk acclaim 320gb usb portable hard drive blue | hard drives | verbatim | ver97185  |   59.84 |

Entity B:
| title                                                                          | category   | brand    |   modelno |   price |
|:-------------------------------------------------------------------------------|:-----------|:---------|----------:|--------:|
| verbatim acclaim 320 gb usb 2.0 portable external hard drive 97164 piano black |            | verbatim |     97164 |   59.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1217
rtable_id: 1319
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 |
|:--------------------------------|:------------|:--------|:----------|--------:|
| pioneer 5.25 2-way speakers 35w | car stereos | pioneer | ts-d1302r |     136 |

Entity B:
| title                                 | category           | brand   | modelno   |   price |
|:--------------------------------------|:-------------------|:--------|:----------|--------:|
| pioneer ts-g1343r 5.25 2-way speakers | office electronics | pioneer |           |   29.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1793
rtable_id: 7712
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 |
|:----------------------------------------------------------------------|:----------------------|:-----------|:----------|--------:|
| sennheiser sh 350 ip binaural headset with noise canceling microphone | electronics - general | sennheiser | sh350ip   |     150 |

Entity B:
| title                                                                             | category             | brand      | modelno   |   price |
|:----------------------------------------------------------------------------------|:---------------------|:-----------|:----------|--------:|
| sennheiser pc 151 binaural headset with noise-canceling microphone volume control | headsets microphones | sennheiser | pc 151    |   42.52 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 58
rtable_id: 5531
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 dual vision tensioned cosmopolitan electrol - av format 10 x 10 diagonal | electronics - general | da-lite |     84992 | 2735.99 |

Entity B:
| title                                                                               | category           | brand   | modelno   | price   |
|:------------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| da-lite 98801 hc da-mat tensioned cosmopolitan electrol - video format 210 diagonal | projection screens | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 932
rtable_id: 17186
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 |
|:-------------------------------------------------------------------|:------------|:--------|----------:|--------:|
| iomega 1tb ego desktop usb 2.0 portable hard drive - midnight blue | hard drives | iomega  |     34837 |   89.98 |

Entity B:
| title                                                                             | category             | brand   |   modelno |   price |
|:----------------------------------------------------------------------------------|:---------------------|:--------|----------:|--------:|
| iomega 500gb ego blackbelt portable hard drive superspeed usb 3.0 usb 2.0 - 35314 | external hard drives | iomega  |     35314 |   75.72 |



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

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

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

Entity A:
| title                                          | category   | brand   | modelno       |   price |
|:-----------------------------------------------|:-----------|:--------|:--------------|--------:|
| netgear prosafe gs716t 16-port ethernet switch | networking | netgear | gs716t-200nas |     238 |

Entity B:
| title                                                        | category   | brand   | modelno   |   price |
|:-------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| netgear gs108 prosafe 8-port gigabit ethernet desktop switch | switches   | netgear | gs108na   |   59.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2089
rtable_id: 10622
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 |
|:-----------------------------|:---------------|:--------|:----------|--------:|
| disney toy story cd boom box | portable audio | disney  | ts500b    |   39.54 |

Entity B:
| title                                   | category   | brand   | modelno   | price   |
|:----------------------------------------|:-----------|:--------|:----------|:--------|
| disney toy story boombox - white ts500b | boomboxes  | disney  |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1268
rtable_id: 4380
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 |
|:----------------------------------------------------------------------------------------------------------------|:----------------|:--------|:-----------|--------:|
| canon powershot a3300 is black 16.0 mp digital camera with 5x optical zoom 3.0 lcd 720p video w 50 bonus prints | digital cameras | canon   | 5035b001aa |  156.54 |

Entity B:
| title                                                                 | category                    | brand   | modelno   |   price |
|:----------------------------------------------------------------------|:----------------------------|:--------|:----------|--------:|
| canon powershot a3300 16 mp digital camera with 5x optical zoom black | point shoot digital cameras | canon   | 5035b001  |     159 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 99
rtable_id: 4520
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 |
|:-------------------------------------------------------------------------------------------------|:----------------------|:----------|:-----------|--------:|
| panasonic kx-tga6645b dect 6.0 plus expandable digital cordless answering system with 5 handsets | electronics - general | panasonic | kx-tg6645b |     150 |

Entity B:
| title                                                                                  | category              | brand     | modelno    |   price |
|:---------------------------------------------------------------------------------------|:----------------------|:----------|:-----------|--------:|
| panasonic kx-tg6572r dect 6.0 cordless phone with answering system wine red 2 handsets | telephone accessories | panasonic | kx-tg6572r |      60 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2260
rtable_id: 5733
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 6 x4 aluminum frame | stationery & office machinery | 3m      |           |  579.29 |

Entity B:
| title                                                                                        | category   | brand   | modelno   |   price |
|:---------------------------------------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| new-quartet 2547 - magnetic dry-erase board porcelain 72 x 48 white aluminum frame - qrt2547 | radios     | quartet |           |  471.04 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2549
rtable_id: 20960
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 |
|:-----------------------------------------|:----------------------|:--------|:----------|--------:|
| baltimore ravens ipod touch 4g hard case | electronics - general | tribeca | fva4584   |   29.99 |

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



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

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

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

Entity A:
| title                                                   | category              | brand   | modelno         |   price |
|:--------------------------------------------------------|:----------------------|:--------|:----------------|--------:|
| belkin f2e9142-wht-apl adc to dvi apple monitor adapter | electronics - general | belkin  | f2e9142-wht-apl |   29.88 |

Entity B:
| title                                                          | category            | brand   | modelno     |   price |
|:---------------------------------------------------------------|:--------------------|:--------|:------------|--------:|
| belkin f2e9142-wht pro series adc to dvi apple monitor adapter | connectors adapters | belkin  | f2e9142-wht |   24.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1841
rtable_id: 18623
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 cherry veneer model b manual screen with matte white fabric - 96 x 96 video format | electronics - general | da-lite |     73263 |  446.99 |

Entity B:
| title                                                                                                             | category           | brand   | modelno   | price   |
|:------------------------------------------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| da-lite manual 120 diagonal video format home theater wall screen with concord veneer case and matte white fabric | home audio theater | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1135
rtable_id: 6748
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 |
|:--------------------------------|:----------------------|:--------|:----------|--------:|
| rayovac 6v rechargeable battery | electronics - general | rayovac | rvla      |       0 |

Entity B:
| title                                 | category                | brand    | modelno   |   price |
|:--------------------------------------|:------------------------|:---------|:----------|--------:|
| dual 1200 rechargeable backup battery | audio video accessories | powermat |           |   39.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2180
rtable_id: 19893
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 hc cinema vision tensioned advantage electrol - av format 8 x 8 diagonal | electronics - general | da-lite |     89939 |    2595 |

Entity B:
| title                                                                                       | category           | brand   | modelno   | price   |
|:--------------------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| da-lite 97986 hc cinema vision tensioned cosmopolitan electrol - av format 12 x 12 diagonal | projection screens | da-lite |           |         |



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

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

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

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

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1296
rtable_id: 17837
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 max aaa 6pk | electronics - general | energizer | e92bp-6r  |       0 |

Entity B:
| title                                      | category   | brand     | modelno   |   price |
|:-------------------------------------------|:-----------|:----------|:----------|--------:|
| energizer max aaa alkaline batteries 36 ct | aaa        | energizer |           |   22.98 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 391
rtable_id: 7162
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 |
|:----------------------------------------------------|:------------|:--------|:-----------|--------:|
| pioneer ts-w2502d2 10 champion series pro subwoofer | car stereos | pioneer | ts-w2502d2 |     268 |

Entity B:
| title                                                                    | category   | brand   | modelno    | price   |
|:-------------------------------------------------------------------------|:-----------|:--------|:-----------|:--------|
| pioneer ts-w3002d4 12 in . champion series pro subwoofer with 3500 watts | subwoofers | pioneer | ts-w3002d4 |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2462
rtable_id: 19455
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 27651 da-glas deluxe rear projection screen - 96 x 96 av format | projection screens | da-lite |           |         |



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

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

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

Entity A:
| title                                                       | category   | brand     | modelno       |   price |
|:------------------------------------------------------------|:-----------|:----------|:--------------|--------:|
| action sport drives 4gb santa cruz usb skate drive rob eyes | usb drives | ep memory | sc-skatere/4g |   10.84 |

Entity B:
| title                                           | category         | brand   | modelno   |   price |
|:------------------------------------------------|:-----------------|:--------|:----------|--------:|
| action sports 4gb santa cruz surfdrive - archie | usb flash drives | dane    |           |    11.5 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 775
rtable_id: 8422
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 onion supply rt-spipad01 glossy screen protector for apple ipad | mp3 accessories | green onions supply | rt-spipad01 |   40.18 |

Entity B:
| title                                                                                        | category   | brand   | modelno     |   price |
|:---------------------------------------------------------------------------------------------|:-----------|:--------|:------------|--------:|
| green onions supply iveil hybrid keyboard protector for apple ipad keyboard dock rt-kbhbipad | keyboards  | green   | rt-kbhbipad |   25.78 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 579
rtable_id: 3128
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 |
|:------------------------------------|:-----------|:--------|:----------------|--------:|
| jaton geforce 6200 256mb video card | computers  | jaton   | video-338pci-lp |   97.82 |

Entity B:
| title                                                                  | category              | brand   | modelno              |   price |
|:-----------------------------------------------------------------------|:----------------------|:--------|:---------------------|--------:|
| jaton geforce 6200 128 mb dual vga pci video card video-338pci-128twin | computers accessories | jaton   | video-338pci-128twin |   74.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 911
rtable_id: 19841
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 m310 peacock blue | mice       | logitech | 910-001923 |   21.18 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1888
rtable_id: 12765
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 |
|:---------------------------------|:-----------|:--------|:----------|--------:|
| apple ipad 10w usb power adapter | mp3        | apple   | mc359ll/a |      29 |

Entity B:
| title                       | category                   | brand    | modelno   |   price |
|:----------------------------|:---------------------------|:---------|:----------|--------:|
| mini usb auto power adapter | two-way radios accessories | motorola | cchusb    |   20.48 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 345
rtable_id: 13329
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 |
|:--------------------------------------------------------------------------|:----------------|:---------|:-----------|--------:|
| polaroid i1237 pink 12mp digital camera w 3x optical zoom 2.7 lcd display | digital cameras | polaroid | cia-1237pc |      68 |

Entity B:
| title                                                                                | category   | brand    | modelno   |   price |
|:-------------------------------------------------------------------------------------|:-----------|:---------|:----------|--------:|
| polaroid dvg-720bc digital camera with 3x optical zoom and 2.7-inch lcd screen black | camcorders | polaroid | dvg-720bc |  109.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1209
rtable_id: 11696
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 |
|:---------------------------------------------------|:-----------|:----------|:-----------|--------:|
| dane-elec 8gb high-speed compact flash memory card | usb drives | dane-elec | dacf3008gc |   44.88 |

Entity B:
| title                                                                        | category    | brand     | modelno       |   price |
|:-----------------------------------------------------------------------------|:------------|:----------|:--------------|--------:|
| dane-elec high speed 300x 4 gb usb 2.0 compact flash card udma da-cf30-04g-c | blank media | dane-elec | da-cf30-04g-c |   17.99 |



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

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

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

Entity A:
| title                             | category   | brand   | modelno   |   price |
|:----------------------------------|:-----------|:--------|:----------|--------:|
| epson t020201 color ink cartridge | printers   | epson   | t020201   |      27 |

Entity B:
| title                                                   | category           | brand    | modelno   |   price |
|:--------------------------------------------------------|:-------------------|:---------|:----------|--------:|
| ld epson s020191 s191089 color compatible ink cartridge | inkjet printer ink | 4inkjets |           |    6.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 65
rtable_id: 7146
label: 0