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 |
|:---------------------------------------------------|:---------------|:---------|:----------|--------:|
| bell o high-speed hdmi cable with ethernet 1-meter | tv accessories | bell ' o | hd7101    |   59.99 |

Entity B:
| title                                | category    | brand    | modelno   |   price |
|:-------------------------------------|:------------|:---------|:----------|--------:|
| bell o hd7101 high speed hdmi cables | hdmi cables | bell ' o | hd7101    |   31.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 735
rtable_id: 12273
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 |
|:---------------------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| avery shipping labels with trueblock technology 2 x 4 white 1000 box | stationery & office machinery | avery   |      8463 |   45.91 |

Entity B:
| title                                                                                                  | category        | brand   |   modelno |   price |
|:-------------------------------------------------------------------------------------------------------|:----------------|:--------|----------:|--------:|
| avery shipping labels with trueblock technology inkjet printers 5.5 x 8.5 inches white pack of 50 8126 | shipping labels | avery   |      8126 |    9.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2429
rtable_id: 6262
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 |
|:----------------------|:-----------|:--------|:----------|--------:|
| tomtom one carry case | gps        | tomtom  | 9n00 .181 |   19.96 |

Entity B:
| title                           | category   | brand   | modelno   |   price |
|:--------------------------------|:-----------|:--------|:----------|--------:|
| tomtom one carry case and strap | cases      | tomtom  | 9n00 .100 |     1.7 |



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

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

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

Entity A:
| title                                        | category   | brand   | modelno   |   price |
|:---------------------------------------------|:-----------|:--------|:----------|--------:|
| hp q6511a hp 11a toner 6000 page-yield black | printers   | hp      | q6511a    |  191.03 |

Entity B:
| title                                           | category            | brand   | modelno   |   price |
|:------------------------------------------------|:--------------------|:--------|:----------|--------:|
| c540h1kg high-yield toner 2500 page-yield black | laser printer toner | lexmark |           |   63.51 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 719
rtable_id: 10590
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 |
|:-------------------------------------------|:-----------|:--------|:---------------|--------:|
| lexar platinum ii 16gb sd sdhc memory card | usb drives | lexar   | lsd16gbsbna100 |   32.98 |

Entity B:
| title                                                                | category    | brand   | modelno        |   price |
|:---------------------------------------------------------------------|:------------|:--------|:---------------|--------:|
| lexar lcf4gbbsbna200 platinum ii 4 gb 200x compact flash memory card | blank media | lexar   | lcf4gbbsbna200 |   24.06 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1539
rtable_id: 2841
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 |
|:---------------------------------|:-----------|:----------|:----------|--------:|
| energizer rechargeable batteries | aa         | energizer | nh15bp-8  |   20.79 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2180
rtable_id: 15107
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 |
|:---------------------------------|:-----------|:---------|:----------|--------:|
| trendnet usb to serial converter | computers  | trendnet | tus9      |   15.27 |

Entity B:
| title                                       | category   | brand    | modelno   |   price |
|:--------------------------------------------|:-----------|:---------|:----------|--------:|
| trendnet usb to serial converter tu-s9 blue | usb cables | trendnet | tu-s9     |   11.11 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1485
rtable_id: 1375
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 |
|:-----------------------------------|:-----------|:---------|----------:|--------:|
| logitech wireless mouse dark fleur | mice       | logitech | 910001898 |   27.82 |

Entity B:
| title                                             | category   | brand    | modelno    |   price |
|:--------------------------------------------------|:-----------|:---------|:-----------|--------:|
| logitech wireless mouse m310 dark aces 910-002087 | mice       | logitech | 910-002087 |   24.45 |



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

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

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

Entity A:
| title                                                | category   | brand   | modelno   |   price |
|:-----------------------------------------------------|:-----------|:--------|:----------|--------:|
| hp color laserjet 4600 smart print cartridge magenta | printers   | hp      | c9723a    |  234.84 |

Entity B:
| title                            | category       | brand   | modelno     | price   |
|:---------------------------------|:---------------|:--------|:------------|:--------|
| hp color laserjet cp1215 printer | laser printers | hp      | cc376a #aba |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2002
rtable_id: 13817
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 t060320 ink cartridge magenta | printers   | epson   | t060320   |   16.84 |

Entity B:
| title                                        | category          | brand   | modelno   |   price |
|:---------------------------------------------|:------------------|:--------|:----------|--------:|
| epson t009 color ink cartridge epson t009201 | printer ink toner | epson   | rm009201  |   33.66 |



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

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

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

Entity A:
| title                                                                                            | category              | brand     | modelno    |   price |
|:-------------------------------------------------------------------------------------------------|:----------------------|:----------|:-----------|--------:|
| panasonic kx-tga6645b dect 6.0 plus expandable digital cordless answering system with 5 handsets | electronics - general | panasonic | kx-tg6645b |     150 |

Entity B:
| title                                                                                                                         | category            | brand   | modelno   |   price |
|:------------------------------------------------------------------------------------------------------------------------------|:--------------------|:--------|:----------|--------:|
| vtech dect 6.0 black graphite expandable 4-handset cordless phone system with digital answering device and caller id cs6328-4 | cordless telephones | vtech   | cs6328-4  |   62.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2260
rtable_id: 3129
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 |
|:------------------------------------------------------|:----------------------|:--------|:-------------|--------:|
| msi ati radeon hd6670 1gb ddr5 pci-express video card | electronics - general | msi     | r6670-md1gd5 |     107 |

Entity B:
| title                                                                          | category       | brand   | modelno    |   price |
|:-------------------------------------------------------------------------------|:---------------|:--------|:-----------|--------:|
| xfx ati radeon hd 5670 1gb ddr3 vga dvi hdmi pci-express video card hd567xznl3 | graphics cards | xfx     | hd567xznl3 |   74.24 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2422
rtable_id: 11214
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 |
|:--------------------------------------|:----------------------|:--------|:----------|--------:|
| new york mets ipod touch 4g hard case | electronics - general | tribeca | fva4459   |   29.99 |

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



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

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

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

Entity A:
| title                              | category                      | brand   | modelno   |   price |
|:-----------------------------------|:------------------------------|:--------|:----------|--------:|
| canon mp41dhii printing calculator | stationery & office machinery | canon   | mp41dhii  |   70.88 |

Entity B:
| title                                      | category   | brand   | modelno    |   price |
|:-------------------------------------------|:-----------|:--------|:-----------|--------:|
| canon mp27d printing calculator 6995a001ab | printing   | canon   | 6995a001ab |   55.71 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 693
rtable_id: 637
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 dir-412 mobile broadband wireless router | networking | d-link  | dir412    |  119.99 |

Entity B:
| title                                   | category   | brand   | modelno   |   price |
|:----------------------------------------|:-----------|:--------|:----------|--------:|
| d-link dir-632 wireless-n 8-port router | routers    | d-link  | dir-632   |   59.99 |



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

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

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

Entity A:
| title                                                                               | category              | brand   | modelno   |   price |
|:------------------------------------------------------------------------------------|:----------------------|:--------|:----------|--------:|
| uniden d2998 dect 6.0 loud and clear digital answering system with cordless handset | electronics - general | uniden  | d2998     |   79.93 |

Entity B:
| title                                                                                                         | category   | brand     | modelno   |   price |
|:--------------------------------------------------------------------------------------------------------------|:-----------|:----------|:----------|--------:|
| panasonic dect 6.0 expandable digital cordless phone with talking caller id answering system - 2 handset pack |            | panasonic |           |   91.41 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 594
rtable_id: 16460
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 |
|:-----------------------------------|:-----------------|:--------|:-----------|--------:|
| q-see qsbncomp10 antenna connector | garden - general | q-see   | qsbncomp10 |   15.72 |

Entity B:
| title                              | category     | brand                        | modelno   |   price |
|:-----------------------------------|:-------------|:-----------------------------|:----------|--------:|
| q-see qsbncomp10 antenna connector | audio cables | digital peripheral solutions |           |   19.45 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1610
rtable_id: 10450
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 |
|:------------------------------------|:-----------|:--------|:----------|--------:|
| logitech wireless mouse m310 bundle | computers  |         |           |   29.88 |

Entity B:
| title                                              | category   | brand    | modelno    |   price |
|:---------------------------------------------------|:-----------|:---------|:-----------|--------:|
| logitech wireless anywhere mouse mx for pc and mac | mice       | logitech | 910-001637 |   44.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 889
rtable_id: 10731
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 deluxe model b manual screen - 60 x 80 video format | electronics - general | da-lite |     74698 |  188.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: 627
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 |
|:-----------------------------------------------------|:-----------|:------------|:----------|--------:|
| audiosource bi5 5 in-wall construction bracket mount | furniture  | audiosource | bi5       |   25.88 |

Entity B:
| title                                                   | category   | brand   | modelno   | price   |
|:--------------------------------------------------------|:-----------|:--------|:----------|:--------|
| audiosource bc6 6 in-ceiling construction bracket mount | printers   | grade-a |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 639
rtable_id: 17016
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 6.5 3-way speakers 300w | car stereos | pioneer | ts-a1674r |   90.88 |

Entity B:
| title                                              | category         | brand   | modelno   |   price |
|:---------------------------------------------------|:-----------------|:--------|:----------|--------:|
| pioneer ts-a1683r 6.5-inch 280-watt 4-way speakers | coaxial speakers | pioneer | ts-a1683r |   46.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1845
rtable_id: 2204
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 |
|:------------------------------------------------------|:---------------|:--------|:----------|--------:|
| jwin port amplified stereo speaker case for ipad blue | portable audio | jwin    | isp210blu |   62.88 |

Entity B:
| title                                                   | category        | brand   | modelno   |   price |
|:--------------------------------------------------------|:----------------|:--------|:----------|--------:|
| iluv isp110 portable amplified stereo speaker case pink | speaker systems | jwin    | isp110pnk |    9.84 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1249
rtable_id: 12909
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 f540 wireless headset | electronics - general | logitech | 981-000277 |     163 |

Entity B:
| title                           | category   | brand    | modelno    |   price |
|:--------------------------------|:-----------|:---------|:-----------|--------:|
| logitech wireless keyboard k340 | keyboards  | logitech | 920-001771 |   19.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2317
rtable_id: 2256
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 |
|:----------------------------------------------------------|:------------------------------|:-------------|:----------|--------:|
| wilson jones basic vinyl round ring binder w label holder | stationery & office machinery | wilson jones | 36849nhb  |    14.2 |

Entity B:
| title                                                                                            | category      | brand        | modelno   |   price |
|:-------------------------------------------------------------------------------------------------|:--------------|:-------------|:----------|--------:|
| new-wilson jones 36834nbl - basic vinyl round ring binder 1-1 2 capacity dark blue - wlj36834nbl | adapter rings | wilson jones |           |   14.64 |



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

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

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

Entity A:
| title                                                                                                          | category   | brand   | modelno            |   price |
|:---------------------------------------------------------------------------------------------------------------|:-----------|:--------|:-------------------|--------:|
| corsair xms2 2gb 2 x 1gb pc2-6400 800mhz 240-pin ddr2 cl5 dual channel desktop memory kit - twin2x4096-6400c5c | memory     | corsair | twin2x4096-6400c5c |   72.82 |

Entity B:
| title                                                                                        | category   | brand   | modelno            |   price |
|:---------------------------------------------------------------------------------------------|:-----------|:--------|:-------------------|--------:|
| corsair twin2x4096-6400c5c 4gb xms2 pc2-6400 800mhz 240-pin dual channel ddr2 desktop memory | memory     | corsair | twin2x4096-6400c5c |   49.98 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 324
rtable_id: 8519
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 |
|:--------------------------------------------|:----------------------|:--------|:----------|--------:|
| memorex color slim cd jewel cases - 50 pack | electronics - general | memorex | 3202-1950 |   19.88 |

Entity B:
| title                                             | category   | brand   |   modelno |   price |
|:--------------------------------------------------|:-----------|:--------|----------:|--------:|
| memorex 50-pack slim cd dvd jewel cases 5mm clear | bags cases | memorex |  32021951 |   13.65 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2518
rtable_id: 21688
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 |
|:--------------------------------------|:----------------------|:--------|:----------|--------:|
| new york mets ipod touch 4g hard case | electronics - general | tribeca | fva4459   |   29.99 |

Entity B:
| title                                 | category              | brand   | modelno   | price   |
|:--------------------------------------|:----------------------|:--------|:----------|:--------|
| new york jets ipod touch 4g hard case | computers accessories | tribeca |           |         |



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

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

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

Entity A:
| title                                                   | category                      | brand   | modelno   |   price |
|:--------------------------------------------------------|:------------------------------|:--------|:----------|--------:|
| sharpie permanent markers fine point - black - 12 count | stationery & office machinery | sharpie | 30001wm   |    8.24 |

Entity B:
| title                                                    | category          | brand   | modelno   |   price |
|:---------------------------------------------------------|:------------------|:--------|:----------|--------:|
| san36701 - permanent marker retractable fine point black | printer ink toner | sanford |           |    2.68 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 978
rtable_id: 20226
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 |
|:---------------------------------------|:----------------------|:--------|----------:|--------:|
| ge 3.6 v 700mah cordless phone battery | electronics - general | ge      |     36562 |       0 |

Entity B:
| title                                             | category   | brand            |   modelno |   price |
|:--------------------------------------------------|:-----------|:-----------------|----------:|--------:|
| ge cordless phone nimh 3.6 v 700mah battery 76413 | batteries  | general electric |     76413 |    9.07 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2238
rtable_id: 21675
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 |
|:-----------------------------------------------|:----------------------|:-----------|:-------------|--------:|
| case logic 13.3 black neoprene notebook sleeve | electronics - general | case logic | pls-13 black |      20 |

Entity B:
| title                                                            | category                            | brand      | modelno      |   price |
|:-----------------------------------------------------------------|:------------------------------------|:-----------|:-------------|--------:|
| caselogic pls-13 neoprene 13.3-inch neoprene laptop sleeve black | laptop netbook computer accessories | case logic | pls-13 black |   18.36 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2392
rtable_id: 15893
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 |
|:---------------------------------------------|:----------------|:--------|----------:|--------:|
| amzer anti-glare screen protector for ipad 2 | mp3 accessories | amzer   |     90786 |   13.88 |

Entity B:
| title                                          | category   | brand   | modelno   | price   |
|:-----------------------------------------------|:-----------|:--------|:----------|:--------|
| i-tec t6020 ipad r anti-glare screen protector | printers   | i-tec   |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 753
rtable_id: 17191
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 red 5-feet v7n3c5e-05f-reds | ethernet cables | v7      | v7n3c5e-05f-reds |    1.76 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1284
rtable_id: 9325
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 |
|:-------------------------------------|:-----------|:----------|:----------|--------:|
| viewsonic pocket camcorder projector | camcorders | viewsonic | 3dv5      |  129.98 |

Entity B:
| title                                                 | category   | brand     | modelno   |   price |
|:------------------------------------------------------|:-----------|:----------|:----------|--------:|
| viewsonic 3dv5 pocket 3d hd camcorder with 5m ff lens | camcorders | viewsonic | 3dv5      |      99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1829
rtable_id: 19353
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 video spectra 1.5 model c manual screen - 78 x 139 hdtv format | electronics - general | da-lite |     82973 |  787.99 |

Entity B:
| title                                                                   | category           | brand   | modelno           |   price |
|:------------------------------------------------------------------------|:-------------------|:--------|:------------------|--------:|
| da-lite model b with csr video spectra 1.5 - projection screen - 106 in | projection screens | da-lite | video spectra 1.5 |   279.5 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1258
rtable_id: 10744
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 8gb sd card secure digital high capacity 8 gb memory card | usb drives | v7      | vasdh8gcl4r-1n |   10.26 |

Entity B:
| title                                          | category    | brand   | modelno        |   price |
|:-----------------------------------------------|:------------|:--------|:---------------|--------:|
| v7 8gb sd card class 6 high capacity sdhc 8 gb | blank media | v7      | vasdh8gcl6r-1n |   14.84 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1218
rtable_id: 13309
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 |
|:---------------------------------------------------------------|:-----------|:-----------|:----------|--------:|
| kensington k72334us slimblade mouse with nano receiver - laser | mice       | kensington | k72334us  |   32.88 |

Entity B:
| title                                         | category            | brand      | modelno   |   price |
|:----------------------------------------------|:--------------------|:-----------|:----------|--------:|
| new-si640 laser mouse w nano recvr - k72334us | connectors adapters | kensington |           |   46.33 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 600
rtable_id: 4691
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 |
|:-------------------------------------------|:----------------------|:--------|:----------|--------:|
| cobra 15-band digital radar laser detector | electronics - general | cobra   | xrs-9645  |  135.25 |

Entity B:
| title                                     | category        | brand   | modelno   |   price |
|:------------------------------------------|:----------------|:--------|:----------|--------:|
| cobra esd7100 9 band radar laser detector | radar detectors | cobra   | esd7100   |      38 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1325
rtable_id: 19703
label: 0