MMTU-benchmark/MMTU huggingface dataset:
Task: Entity-Matching (source dataset: Walmart-Amazon)

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

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

Entity A:
| title                                                                                               | category                      | brand   |   modelno |   price |
|:----------------------------------------------------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| avery matte white cd labels for color laser printers and copiers 30 disc labels and 60 spine labels | stationery & office machinery | avery   |      6692 |   14.88 |

Entity B:
| title                                                                              | category                    | brand   |   modelno |   price |
|:-----------------------------------------------------------------------------------|:----------------------------|:--------|----------:|--------:|
| avery cd labels for laser printers white 100 disc labels and 200 spine labels 5698 | printer labels laser inkjet | avery   |      5698 |   27.29 |



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

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

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

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

Entity B:
| title                                                      | category           | brand   | modelno   |   price |
|:-----------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| da-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: 2430
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 |
|:-------------------------------------------------------------------------------|:----------------------|:--------------|:------------|--------:|
| elite screens cinewhite cinema235 series fixed frame wide screen - 85 diagonal | electronics - general | elite screens | r85wh1-wide |     409 |

Entity B:
| title                                                          | category           | brand   | modelno   |   price |
|:---------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| cinegray prime vision series fixed frame screen - 165 diagonal | projection screens | elite   |           |    1249 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 581
rtable_id: 16199
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 |
|:-------------------------------------|:--------------|:--------|:----------|--------:|
| xantech 282d designer emitter single | stereos/audio | xantech | 282d      |   15.88 |

Entity B:
| title                                     | category            | brand   | modelno   |   price |
|:------------------------------------------|:--------------------|:--------|:----------|--------:|
| xantech 284d5p designer dual emitter 5 pk | connectors adapters | xantech |           |      82 |



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

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

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

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

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



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

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

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

Entity A:
| title                                                                        | category              | brand   |   modelno |   price |
|:-----------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-glas deluxe rear projection screen - 40 1 4 x 53 3 4 video format | electronics - general | da-lite |     27655 | 1752.99 |

Entity B:
| title                                                                          | category           | brand   | modelno   | price   |
|:-------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| da-lite 27578 da-plex self trimming rear projection screen - 96 x 96 av format | projection screens | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2504
rtable_id: 8791
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 cosmopolitan electrol - av format 7 x 9 diagonal | electronics - general | da-lite |     89892 |    2240 |

Entity B:
| title                                                                                  | category           | brand   | modelno   | price   |
|:---------------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| da-lite 98811 pearlescent tensioned cosmopolitan electrol - av format 12 x 12 diagonal | projection screens | da-lite |           |         |



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

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

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

Entity A:
| title                                            | category   | brand   | modelno      |   price |
|:-------------------------------------------------|:-----------|:--------|:-------------|--------:|
| wintec filemate 4gb swivel usb flash drive black | usb drives | wintec  | 3fmusb4gwb-r |    7.84 |

Entity B:
| title                                         | category         | brand   | modelno       |   price |
|:----------------------------------------------|:-----------------|:--------|:--------------|--------:|
| wintec filemate 32 gb swivel usb drive - blue | usb flash drives | wintec  | 3fmusb32gwn-r |   44.94 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 528
rtable_id: 5203
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 |
|:---------------------------------------|:-----------|:--------|:----------------|--------:|
| dell 15 standard yield black cartridge | printers   | dell    | series 15 black |   18.97 |

Entity B:
| title                                          | category           | brand   | modelno   |   price |
|:-----------------------------------------------|:-------------------|:--------|:----------|--------:|
| lexmark standard yield 100 black ink cartridge | inkjet printer ink | lexmark | 14n0820   |    9.77 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1781
rtable_id: 827
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 4gb flash memory card black | usb drives | sony    | sf4n4/tq  |   10.88 |

Entity B:
| title                                                   | category     | brand   | modelno   |   price |
|:--------------------------------------------------------|:-------------|:--------|:----------|--------:|
| sony 2 gb memory stick pro duo flash memory card msmt2g | memory cards | sony    | msmt2g    |   10.56 |



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

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

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

Entity A:
| title                                                  | category   | brand   | modelno   |   price |
|:-------------------------------------------------------|:-----------|:--------|:----------|--------:|
| lexmark 12a8425 black high-yield toner print cartridge | printers   | lexmark | 12a8425   |   302.4 |

Entity B:
| title                                              | category           | brand   | modelno   |   price |
|:---------------------------------------------------|:-------------------|:--------|:----------|--------:|
| lexmark 32 black print cartridge twin pack 18c0533 | inkjet printer ink | lexmark | 18c0532   |   39.12 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2535
rtable_id: 19570
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 green | electronics - general | v7      | v7n2c6-25f-grns |    9.76 |

Entity B:
| title                                                                                       | category        | brand   | modelno          |   price |
|:--------------------------------------------------------------------------------------------|:----------------|:--------|:-----------------|--------:|
| v7 cat5e snagless molded network patch cable rj45 male to male blue 3-feet v7n3c5e-03f-blus | ethernet cables | v7      | v7n3c5e-03f-blus |    1.43 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1169
rtable_id: 5266
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 38a black cartridge in retail packaging q1338a | laser printer toner | hp      | q1338a    |  125.31 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 25
rtable_id: 13622
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-tg4022n dect 6.0 plus expandable cordless answering system w 2 handsets | electronics - general | panasonic | kx-tg4022n |   44.98 |

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



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

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

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

Entity A:
| title                                        | category        | brand   | modelno   |   price |
|:---------------------------------------------|:----------------|:--------|:----------|--------:|
| griffin ipod touch 4g screen care kit 3 pack | mp3 accessories | arkon   | gb01913   |    13.3 |

Entity B:
| title                                       | category   | brand              | modelno   |   price |
|:--------------------------------------------|:-----------|:-------------------|:----------|--------:|
| griffin reveal case for ipod touch 4g black | cases      | griffin technology | gb01915   |    5.99 |



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

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

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

Entity A:
| title                                                               | category              | brand   |   modelno |   price |
|:--------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite video spectra 1.5 model b manual screen - 84 x 84 av format | electronics - general | da-lite |     83225 |  139.99 |

Entity B:
| title                                                                                                       | category           | brand   | modelno           |   price |
|:------------------------------------------------------------------------------------------------------------|:-------------------|:--------|:------------------|--------:|
| da-lite deluxe model b manual wall ceiling projection screen 50 x 67 video format video spectra 1.5 surface | projection screens | da-lite | video spectra 1.5 |  165.31 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2390
rtable_id: 14686
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 |
|:--------------------------------------------------|:----------------------|:--------|:------------|--------:|
| targus 13.3 widescreen lcd monitor privacy screen | electronics - general | targus  | asf133w9usz |   42.07 |

Entity B:
| title                                                              | category       | brand   | modelno   |   price |
|:-------------------------------------------------------------------|:---------------|:--------|:----------|--------:|
| 3m privacy filter - 3m pf19 .0 w widescreen monitor privacy screen | screen filters | 3m      | pf19 .0 w |   65.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2225
rtable_id: 19491
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 |
|:-----------------------------------------------------------------------------------------|:----------------|:--------|:----------|--------:|
| kodak easyshare m530 red 12mp digital camera w 3x optical zoom 2.7 lcd w 50 bonus prints | digital cameras | kodak   | m530 red  |   99.54 |

Entity B:
| title                                                               | category                    | brand   | modelno   | price   |
|:--------------------------------------------------------------------|:----------------------------|:--------|:----------|:--------|
| kodak easyshare c913 9.2 mp digital camera with 3xoptical zoom pink | point shoot digital cameras | kodak   | c913 pink |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 688
rtable_id: 13786
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-lite holo screen - projection screen rear | video projectors | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1132
rtable_id: 6750
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 stp-fsa floating camera strap | dvd accessories | sony    | stpfsa    |   19.44 |

Entity B:
| title                                     | category   | brand   | modelno            |   price |
|:------------------------------------------|:-----------|:--------|:-------------------|--------:|
| vivitar orange floating foam camera strap |            | vivitar | viv-flt-stp-orange |    4.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 749
rtable_id: 9276
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 |
|:-------------------------------------|:----------------------|:----------|:-------------|--------:|
| manfrotto unica v dslr messenger bag | photography - general | manfrotto | mb-sm390-5bc |   89.99 |

Entity B:
| title                                              | category   | brand     | modelno      |   price |
|:---------------------------------------------------|:-----------|:----------|:-------------|--------:|
| manfrotto mb sm390-5bb unica v messenger bag black | cases bags | manfrotto | mb sm390-5bb |   89.89 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1262
rtable_id: 20118
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 |
|:-------------------------------------------------------------------------|:------------------------------|:--------|:----------|--------:|
| quartet premium dry-erase board in white with aluminum frame 48 w x 36 h | stationery & office machinery | quartet |           |  275.79 |

Entity B:
| title                                                                                                  | category   | brand   | modelno   |   price |
|:-------------------------------------------------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| new-quartet p567t - euro frame dry-erase board porcelain steel 72 x 48 white aluminum frame - qrtp567t | radios     | quartet |           |     873 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2404
rtable_id: 18036
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 light oak veneer model b manual screen with high power fabric - 60 x 60 av format | electronics - general | da-lite |     99731 |  310.99 |

Entity B:
| title                                                                                        | category           | brand   | modelno   | price   |
|:---------------------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| heritage walnut veneer model b manual screen with high power fabric - av format size 60 x 60 | projection screens | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 787
rtable_id: 11013
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 |
|:--------------------------------------------------------|:------------|:----------|:----------|--------:|
| clickfree c2 500gb usb 3.0 portable external hard drive | hard drives | clickfree | hd527b3   |   84.98 |

Entity B:
| title                                                               | category              | brand   |   modelno | price   |
|:--------------------------------------------------------------------|:----------------------|:--------|----------:|:--------|
| iomega ego helium 320 gb usb 2.0 portable external hard drive 34943 | computers accessories | iomega  |     34943 |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2305
rtable_id: 12918
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 profit wired full size mouse | mice       | kensington | k72343us  |   19.88 |

Entity B:
| title                                                    | category   | brand      | modelno   |   price |
|:---------------------------------------------------------|:-----------|:-----------|:----------|--------:|
| kensington k72355us pro fit usb ps2 wired mid-size mouse | mice       | kensington | k72355us  |   17.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1324
rtable_id: 10838
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 |
|:---------------------------------------|:----------------|:--------|:----------|--------:|
| pyle ipod 3.5 mm stereo to rca adapter | mp3 accessories | pyle    | plipg1    |    6.54 |

Entity B:
| title                                                          | category                 | brand   | modelno   |   price |
|:---------------------------------------------------------------|:-------------------------|:--------|:----------|--------:|
| pyle plmripwg ipod mp3 waterproof 3.5 mm stereo to rca adaptor | auxiliary input adapters | pyle    | plmripwg  |    6.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1110
rtable_id: 13636
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 2 port pci superspeed usb 3.0 card adapter pciusb3s2 | hubs       | startech | pciusb3s2 |      51 |



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

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

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

Entity A:
| title                                            | category   | brand     | modelno   |   price |
|:-------------------------------------------------|:-----------|:----------|:----------|--------:|
| microsoft comfort optical mouse 3000 silver blue | mice       | microsoft | d1t00011  |   19.95 |

Entity B:
| title                                  | category   | brand     | modelno   |   price |
|:---------------------------------------|:-----------|:----------|:----------|--------:|
| microsoft comfort mouse 3000 s9j-00001 | mice       | microsoft | s9j-00001 |   12.88 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1810
rtable_id: 21438
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 clearchat style pc headset | electronics - general | logitech | 9.81000018 e8 |   16.84 |

Entity B:
| title                              | category             | brand    | modelno    |   price |
|:-----------------------------------|:---------------------|:---------|:-----------|--------:|
| logitech clearchat pro usb headset | accessories supplies | logitech | 981-000010 |   25.23 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1546
rtable_id: 4718
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 |
|:------------------------|:------------------------------|:--------|----------:|--------:|
| heavy duty 3-hole punch | stationery & office machinery | generic |       997 |       0 |

Entity B:
| title            | category   | brand   | modelno   |   price |
|:-----------------|:-----------|:--------|:----------|--------:|
| heavy-duty punch |            | sparco  |           |   19.61 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1685
rtable_id: 16790
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 medium slr camera bag | photography - general | case logic |    133827 |   47.99 |

Entity B:
| title                                                 | category   | brand      | modelno      |   price |
|:------------------------------------------------------|:-----------|:-----------|:-------------|--------:|
| case logic tbc-303 medium camera camcorder case black | cases bags | case logic | tbc-303black |    6.99 |



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

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

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

Entity A:
| title                                                                       | category              | brand   |   modelno |   price |
|:----------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-view thru-the-wall rear projection screen - 60 x 80 video format | electronics - general | da-lite |     23046 |   13998 |

Entity B:
| title                                                                       | category           | brand   |   modelno |   price |
|:----------------------------------------------------------------------------|:-------------------|:--------|----------:|--------:|
| da-lite data pro thru-the-wall rear projection screen - 52 x 92 hdtv format | projection screens | da-lite |     23181 | 15985.8 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 852
rtable_id: 6740
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 |
|:-----------------------------------------------------|:----------------|:---------------|:------------|--------:|
| ten one design pogo stylus for iphone 4 burnt orange | mp3 accessories | ten one design | t1-af25-407 |   13.49 |

Entity B:
| title                                                                     | category                        | brand          | modelno     |   price |
|:--------------------------------------------------------------------------|:--------------------------------|:---------------|:------------|--------:|
| ten one design pogo sketch stylus for ipad iphone and ipod touch hot pink | touch screen tablet accessories | ten one design | t1-ap25-104 |    7.53 |



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

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

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

Entity A:
| title                                                                       | category              | brand   |   modelno |   price |
|:----------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-view thru-the-wall rear projection screen - 60 x 80 video format | electronics - general | da-lite |     23046 |   13998 |

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



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

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

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

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

Entity B:
| title                                                                      | category                    | brand   | modelno   |   price |
|:---------------------------------------------------------------------------|:----------------------------|:--------|:----------|--------:|
| casio exilim ex-z16 12 mp digital camera with 3x zoom and 2.7-inch lcd red | point shoot digital cameras | casio   | ex-z16rd  |   71.38 |



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

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

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

Entity A:
| title                                                 | category              | brand   | modelno      |   price |
|:------------------------------------------------------|:----------------------|:--------|:-------------|--------:|
| siig 2.5 sata superspeed usb 3.0 hard drive enclosure | electronics - general | siig    | ju-sa0912-s1 |   20.39 |

Entity B:
| title                                                                                     | category              | brand    | modelno   |   price |
|:------------------------------------------------------------------------------------------|:----------------------|:---------|:----------|--------:|
| aluratek superspeed usb 3.0 2.5-inch 3.5-inch sata hard drive docking enclosure ahddu200f | computers accessories | aluratek | ahddu200f |   34.84 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1022
rtable_id: 2025
label: 0