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 |
|:------------------------------------------------|:----------------------|:----------|----------:|--------:|
| visiontek radeon hd6770 1gb gddr5 graphics card | electronics - general | visiontek |    900368 |     145 |

Entity B:
| title                                                                  | category              | brand     |   modelno |   price |
|:-----------------------------------------------------------------------|:----------------------|:----------|----------:|--------:|
| visiontek ati radeon hd 5550 1 gb ddr pci express graphics card 900331 | computers accessories | visiontek |    900331 |   54.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1498
rtable_id: 15249
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 |
|:----------------------------------------------------------------------|:---------------|:--------|:-----------|--------:|
| orbital tilt and turn tv wall mount with glass shelving for 25-40 tvs | tv accessories | orbital | resl422b-e |       0 |

Entity B:
| title                                                                                                        | category   | brand   | modelno    |   price |
|:-------------------------------------------------------------------------------------------------------------|:-----------|:--------|:-----------|--------:|
| avf resl422b-f orbital tilt and turn tv mount with av shelving for 25 to 40-inch flat panel tv screens black | tv mounts  | avf     | resl422b-f |  125.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2290
rtable_id: 8322
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 |
|:------------------------------------|:---------------------------------|:--------|:----------------|--------:|
| bower ss26 digital neck strap green | camera and camcorder accessories | bower   | relaunch ss26gr |   12.98 |

Entity B:
| title                               | category                | brand   | modelno   |   price |
|:------------------------------------|:------------------------|:--------|:----------|--------:|
| bower ss26 digital neck strap brown | audio video accessories | atlona  | ss26br    |   12.19 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1266
rtable_id: 19210
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 hx3x12g1333c9 12 gb xms3 6 x 2 gb pc3-10600 1333mhz 240-pin ddr3 core i7 triple channel memory kit desktop memory module | memory     | corsair | hx3x12g1333c9 |  163.82 |

Entity B:
| title                                                                                       | category              | brand   | modelno          |   price |
|:--------------------------------------------------------------------------------------------|:----------------------|:--------|:-----------------|--------:|
| corsair xms3 6 gb pc3-10666 1333mhz triple channel core i7 ddr3 memory kit cmx6gx3m3a1333c9 | computers accessories | corsair | cmx6gx3m3a1333c9 |   44.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1073
rtable_id: 10475
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-mat tensioned advantage electrol - av format 60 x 60 | electronics - general | da-lite |     84367 | 2022.99 |

Entity B:
| title                                                                             | category           | brand   | modelno   |   price |
|:----------------------------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| hc cinema perf tensioned advantage deluxe electrol - hdtv format size 92 diagonal | projection screens | da-lite |           |    4200 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1839
rtable_id: 17381
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 |
|:----------------------------------------|:-----------|:--------------|:----------|--------:|
| north carolina tar heels pro grip mouse | mice       | team pro mark | msu045    |   26.99 |

Entity B:
| title                                        | category              | brand   | modelno   |   price |
|:---------------------------------------------|:----------------------|:--------|:----------|--------:|
| north carolina tar heels iphone 3g hard case | computers accessories | tribeca |           |    9.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 363
rtable_id: 4641
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 advantage deluxe electrol - hdtv format 92 diagonal | electronics - general | da-lite |     88285 | 4242.99 |

Entity B:
| title                                                                                                        | category           | brand   | modelno   |   price |
|:-------------------------------------------------------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| da-lite tensioned advantage deluxe electrol - projection screen rear motorized - 133 in - 16 9 - dual vision | projection screens | da-lite |           |    4990 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 887
rtable_id: 803
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 |
|:-----------------------------------------------------------------------------|:----------------------|:--------|:-------------|--------:|
| vantec nexstar3 superspeed 2.5 sata to usb 3.0 external hard drive enclosure | electronics - general | vantec  | nst-280s3-bk |   26.62 |

Entity B:
| title                                                                                                     | category              | brand   | modelno      |   price |
|:----------------------------------------------------------------------------------------------------------|:----------------------|:--------|:-------------|--------:|
| vantec nexstar 3 nst-360su-bk 3.5-inch sata to usb 2.0 and esata external hard drive enclosure onyx black | hard drive enclosures | vantec  | nst-360su-bk |   28.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2255
rtable_id: 6032
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 60 av format | electronics - general | da-lite |     40223 |  118.99 |

Entity B:
| title                                                                   | category           | brand   | modelno   | price   |
|:------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| da-lite designer model b - projection screen - 1 1 - matte white - fawn | projection screens | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2048
rtable_id: 14698
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 3 cat-5e snagless patch cable blue | electronics - general | belkin  | a3l791-03-blu-s |    4.35 |

Entity B:
| title                                                                               | category        | brand   | modelno         |   price |
|:------------------------------------------------------------------------------------|:----------------|:--------|:----------------|--------:|
| belkin a3l791-14-blu-s rj45m rj45m 14-feet 10 100bt cat5e snagless patch cable blue | ethernet cables | belkin  | a3l791-14-blu-s |    5.11 |



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

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

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

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

Entity B:
| title                           | category           | brand      | modelno   |   price |
|:--------------------------------|:-------------------|:-----------|:----------|--------:|
| canon pg-30 black ink cartridge | inkjet printer ink | compatible |           |    5.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1631
rtable_id: 10624
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 75 tri-color inkjet cartridge cb337wn | printers   | hp      | hp cb337wn140 |   19.47 |

Entity B:
| title                                  | category           | brand   | modelno   |   price |
|:---------------------------------------|:-------------------|:--------|:----------|--------:|
| hp 14d tri-color ink cartridge c5010dn | inkjet printer ink | hp      | c5010dn   |   26.31 |



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

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

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

Entity A:
| title                                                                             | category    | brand           | modelno         |   price |
|:----------------------------------------------------------------------------------|:------------|:----------------|:----------------|--------:|
| western digital 1tb my passport essential se usb 3.0 portable external hard drive | hard drives | western digital | wdbacx0010bbksn |   98.92 |

Entity B:
| title                                                                   | category             | brand           | modelno            |   price |
|:------------------------------------------------------------------------|:---------------------|:----------------|:-------------------|--------:|
| western digital wd elements 500 gb usb 2.0 portable external hard drive | external hard drives | western digital | wdbaar5000abk-nesn |   74.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 419
rtable_id: 3276
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 |
|:---------------------------------------------------------------------------------|:------------------------------|:-----------------|----------:|--------:|
| stanley bostitch 00540 antijam extra heavy-duty stapler 215-sheet capacity black | stationery & office machinery | stanley bostitch |       540 |      65 |

Entity B:
| title                                                                                     | category                 | brand   | modelno   |   price |
|:------------------------------------------------------------------------------------------|:-------------------------|:--------|:----------|--------:|
| stanley bostitch 02210 - electric stapler with anti-jam mechanism 20-sheet capacity black | pda handheld accessories | stanley |           |   50.27 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1988
rtable_id: 11720
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 |
|:--------------------------------------------------------------------------------------------------------------------------------------------------|:-----------------|:-----------------|:----------|--------:|
| svat ultra-slim web-ready 8 channel dvr security system with built-in 19 lcd screen and 4 indoor outdoor hi-res night vision surveillance cameras | garden - general | svat electronics | clearvu10 |    1199 |

Entity B:
| title                                                                                                        | category             | brand    | modelno          |   price |
|:-------------------------------------------------------------------------------------------------------------|:---------------------|:---------|:-----------------|--------:|
| defender sync 19 inch lcd all-in-one security system with 4 hi-res indoor outdoor surveillance cameras black | surveillance cameras | defender | sn503-8ch19m-002 |  699.99 |



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

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

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

Entity A:
| title                                                                                      | category   | brand    | modelno    |   price |
|:-------------------------------------------------------------------------------------------|:-----------|:---------|:-----------|--------:|
| startech superspeed usb 3.0 sata adapter cable for 2.5 in or 3.5 in hard drives usb3s2sata | networking | startech | usb3s2sata |      49 |

Entity B:
| title                                                                                              | category   | brand    | modelno    |   price |
|:---------------------------------------------------------------------------------------------------|:-----------|:---------|:-----------|--------:|
| startech.com usb3s2sata superspeed usb 3.0 sata adapter cable for 2.5-inch or 3.5-inch hard drives | hubs       | startech | usb3s2sata |   30.17 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1011
rtable_id: 13413
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 |
|:------------------------------------------------------|:----------------------|:--------|:----------|--------:|
| endust for electronics ultimate office cleaning combo | electronics - general | endust  | 12886bp   |   64.99 |

Entity B:
| title                                                          | category            | brand   | modelno   |   price |
|:---------------------------------------------------------------|:--------------------|:--------|:----------|--------:|
| endust 12879bp electronics office travel screen cleaning combo | monitor accessories | endust  | 12879bp   |   27.66 |



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

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

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

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

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 967
rtable_id: 820
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 |
|:----------------------------------------------------------------------|:------------|:---------------|:----------|--------:|
| zalman n series ssd0064n1 mlc 64gb internal sata ii solid state drive | hard drives | zalman usa inc | ssd0064n1 |     144 |

Entity B:
| title                                                                      | category                | brand   | modelno   | price   |
|:---------------------------------------------------------------------------|:------------------------|:--------|:----------|:--------|
| zalman ssd-n series ssd0064n1 - solid state drive - 64 gb - 2.5 - sata-300 | audio video accessories | zalman  | ssd0064n1 |         |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 907
rtable_id: 13994
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 |
|:--------------------------------------------------------------|:----------------------|:---------|:----------|--------:|
| startech.com icusb2328 8 port usb to rs232 serial adapter hub | electronics - general | startech | icusb2328 |  163.88 |

Entity B:
| title                                                                                            | category       | brand    | modelno    |   price |
|:-------------------------------------------------------------------------------------------------|:---------------|:---------|:-----------|--------:|
| startech.com 1 port metal industrial usb to rs422 rs485 serial adapter with isolation icusb422is | i o port cards | startech | icusb422is |   83.84 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2242
rtable_id: 13418
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 m310 bundle | computers  |         |           |   29.88 |

Entity B:
| title                                                 | category   | brand    | modelno    |   price |
|:------------------------------------------------------|:-----------|:---------|:-----------|--------:|
| logitech wireless performance mouse mx for pc and mac | mice       | logitech | 910-001105 |   79.95 |



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

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

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

Entity A:
| title                                                                    | category              | brand   |   modelno |   price |
|:-------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-plex self trimming rear projection screen - 60 x 60 av format | electronics - general | da-lite |     27575 | 2680.99 |

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



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

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

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

Entity A:
| title                                                                            | category              | brand   |   modelno |   price |
|:---------------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| 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 98812 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: 17184
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 ce278a black laserjet print cartridge | printers   | hp      | hp ce278a |   69.84 |

Entity B:
| title                                                     | category          | brand   | modelno   |   price |
|:----------------------------------------------------------|:------------------|:--------|:----------|--------:|
| hp laserjet 53x black print cartridge in retail packaging | printer ink toner | hp      | q7553x    |  134.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 25
rtable_id: 8668
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 value select cmv4gx3m1a1333c9 4gb ddr3 1333mhz sdram desktop memory module | memory     | corsair | cmv4gx3m1a1333c9 |   49.82 |

Entity B:
| title                                             | category              | brand   | modelno           |   price |
|:--------------------------------------------------|:----------------------|:--------|:------------------|--------:|
| corsair 4 gb ddr3 laptop memory cmso4gx3m1a1333c9 | computers accessories | corsair | cmso4gx3m1a1333c9 |   23.99 |



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

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

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

Entity A:
| title                                                                       | category                      | brand               |   modelno |   price |
|:----------------------------------------------------------------------------|:------------------------------|:--------------------|----------:|--------:|
| tops classified colors notebook narrow rule 5-1 2 x 8-1 2 orchid 100 sheets | stationery & office machinery | tops business forms |     99712 |   11.58 |

Entity B:
| title                                                                                           | category                       | brand   | modelno   |   price |
|:------------------------------------------------------------------------------------------------|:-------------------------------|:--------|:----------|--------:|
| new-tops 73505 - notebook w red cover narrow rule 5-1 2 x 8-1 2 white 100 sheets pad - top73505 | storage presentation materials | tops    |           |      19 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2364
rtable_id: 17917
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 |
|:---------------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| c-line top-load poly sheet protectors heavy gauge letter 200ct | stationery & office machinery |         |     62097 |   28.94 |

Entity B:
| title                                                                                            | category                       | brand   | modelno   |   price |
|:-------------------------------------------------------------------------------------------------|:-------------------------------|:--------|:----------|--------:|
| new-c-line 62097 - top-load polypropylene sheet protectors heavy gauge letter 200 box - cli62097 | storage presentation materials | c-line  |           |      39 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 725
rtable_id: 16277
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 |
|:---------------------------------------------------|:-----------|:----------|:-----------|--------:|
| 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 8 gb usb 2.0 compact flash card udma da-cf30-08g-c | blank media | dane-elec | da-cf30-08g-c |   29.06 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 90
rtable_id: 21917
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 |
|:-----------------------------------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| pendaflex cutless watershed file folders 1 3 cut top tab letter manila 100 per box | stationery & office machinery |         |     48434 |   22.69 |

Entity B:
| title                                                                                            | category            | brand     | modelno   | price   |
|:-------------------------------------------------------------------------------------------------|:--------------------|:----------|:----------|:--------|
| new-pendaflex 02086 - file folders infopocket 1 3 cut top tab letter assorted 30 pack - ess02086 | laminating supplies | pendaflex |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1699
rtable_id: 20672
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 |
|:-----------------------------------|:----------------------|:---------|:----------|--------:|
| ape case ac165 digital camera case | photography - general | ape case | ac165     |   12.85 |

Entity B:
| title                                           | category   | brand   | modelno   |   price |
|:------------------------------------------------|:-----------|:--------|:----------|--------:|
| ape case basics mini digital camera pouch ac120 | cases bags | norazza | ac120     |     1.2 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1193
rtable_id: 14236
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 |
|:---------------------------------------|:----------------|:---------|:----------|--------:|
| nextware jellybean case for ipad black | mp3 accessories | nextware | jelpad-bk |   29.95 |

Entity B:
| title                               | category      | brand   | modelno   |   price |
|:------------------------------------|:--------------|:--------|:----------|--------:|
| adesso carrying case for ipad black | cases sleeves | adesso  | acs-100fb |   15.96 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 281
rtable_id: 2429
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 ce505xd black laserjet print cartridges 2pk | printers   | hp      | hp ce505xd |  258.84 |

Entity B:
| title                                                                   | category          | brand   | modelno   |   price |
|:------------------------------------------------------------------------|:------------------|:--------|:----------|--------:|
| hp color laserjet q6001a q6002a q6003a tri-pack print cartridges ce257a | printer ink toner | hp      | ce257a    |     212 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 95
rtable_id: 9002
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 |
|:--------------------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| quality park white redi-strip poly expansion mailers 100 per carton | stationery & office machinery |         |     46390 |   74.94 |

Entity B:
| title                                                                                                       | category                       | brand        | modelno   |   price |
|:------------------------------------------------------------------------------------------------------------|:-------------------------------|:-------------|:----------|--------:|
| new-quality park 46393 - redi-strip poly expansion mailer side seam 13 x 16 x 2 white 100 carton - qua46393 | storage presentation materials | quality park |           |  175.48 |



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

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

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

Entity A:
| title                                                        | category        | brand   | modelno      |   price |
|:-------------------------------------------------------------|:----------------|:--------|:-------------|--------:|
| sony mdrex35lp vb colorful headphone with case - violet blue | mp3 accessories | sony    | mdrex35lp/vb |   13.54 |

Entity B:
| title                                                                   | category   | brand   | modelno         |   price |
|:------------------------------------------------------------------------|:-----------|:--------|:----------------|--------:|
| sony mdr-ex35lp vb ex style headphones with deep bass sound violet blue | headphones | sony    | mdr-ex35lp / vb |   12.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 42
rtable_id: 172
label: 1