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 |
|:----------------------------------------------------|:-----------|:----------|:----------|--------:|
| gear head 2.4 ghz wireless optical nano mouse black | mice       | gear head | mp2800blk |   15.82 |

Entity B:
| title                                                                        | category   | brand     | modelno        |   price |
|:-----------------------------------------------------------------------------|:-----------|:----------|:---------------|--------:|
| gear head 2.4 ghz wireless optical nano mouse - red black usb mp2750red-cp10 | mice       | gear head | mp2750red-cp10 |   13.66 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1242
rtable_id: 1113
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 natural walnut veneer model b manual screen with matte white fabric - 64 x 84 diagonal video format | electronics - general | da-lite |     73197 |  261.99 |

Entity B:
| title                                                                                                          | category           | brand   | modelno   | price   |
|:---------------------------------------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| honey maple veneer model b manual screen with matte white fabric - diagonal video format size 60 x 60 diagonal | projection screens | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 92
rtable_id: 6998
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 |
|:-----------------------------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| smead acid-free poly folder 2 fasteners 1 3 cut top tab letter manila 24 box | stationery & office machinery |         |     10545 |   42.94 |

Entity B:
| title                                                                               | category            | brand   | modelno   | price   |
|:------------------------------------------------------------------------------------|:--------------------|:--------|:----------|:--------|
| smead 10540 - slash pocket poly file folders 1 3 cut top tab letter assorted 30 box | printer accessories | smead   |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1689
rtable_id: 16375
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 |
|:-----------------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| expo low-odor dry erase marker eraser cleaner chisel fine 12 set | stationery & office machinery | expo    |     80054 |   21.94 |

Entity B:
| title                                                                                   | category   | brand   | modelno   | price   |
|:----------------------------------------------------------------------------------------|:-----------|:--------|:----------|:--------|
| new-expo 83054 - dry erase marker eraser cleaner chisel fine assorted 12 set - san83054 | radios     | expo    |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 461
rtable_id: 17769
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 |
|:-----------------------------------------------------------|:------------|:-----------------|:----------------|--------:|
| ocz technology vertex 2 60gb 2.5 sata ii solid state drive | hard drives | ocz technologies | oczssd22vtxe60g |  119.98 |

Entity B:
| title                                                                                 | category            | brand   | modelno         |   price |
|:--------------------------------------------------------------------------------------|:--------------------|:--------|:----------------|--------:|
| ocz technology 30 gb vertex series sata ii solid state drive 3.0 gb-s oczssd2-1vtx30g | computer components | ocz     | oczssd2-1vtx30g |   66.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1092
rtable_id: 11799
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 holoscreen rear projection screen - 22 x 33 3 4 video format | electronics - general | da-lite |     20030 |    1600 |

Entity B:
| title                                                                          | category           | brand   | modelno   | price   |
|:-------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| da-lite 27658 da-glas deluxe 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: 626
rtable_id: 16598
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 base rear projection screen - 57 3 4 x 77 video format | electronics - general | da-lite |     27528 | 2608.99 |

Entity B:
| title                                                           | category           | brand   | modelno   |   price |
|:----------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| da-plex standard rear projection screen - 81 x 108 video format | projection screens | da-lite |           |    5115 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 53
rtable_id: 18507
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 unframed rear projection screen - 84 x 84 av format | electronics - general | da-lite |     27503 | 3561.99 |

Entity B:
| title                                                                      | category           | brand   |   modelno |   price |
|:---------------------------------------------------------------------------|:-------------------|:--------|----------:|--------:|
| da-lite da-view thru-the-wall rear projection screen - 45 x 80 hdtv format | projection screens | da-lite |     23065 | 12909.9 |



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

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

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

Entity A:
| title                                      | category   | brand   | modelno   |   price |
|:-------------------------------------------|:-----------|:--------|:----------|--------:|
| edge 8gb diskgo usb 2.0 flash drive silver | usb drives | edge    | pe204198  |   10.98 |

Entity B:
| title                                                        | category         | brand        | modelno   |   price |
|:-------------------------------------------------------------|:-----------------|:-------------|:----------|--------:|
| super talent pico-c 8 gb usb 2.0 flash drive stu8gpcs silver | usb flash drives | super talent | stu8gpcs  |   16.45 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1661
rtable_id: 21404
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 sport armband for ipod nano black | mp3 accessories | belkin  | f8z514tt064 |   18.88 |

Entity B:
| title                                                | category   | brand   | modelno    |   price |
|:-----------------------------------------------------|:-----------|:--------|:-----------|--------:|
| belkin sport armband plus case for ipod nano 3g blue | armbands   | belkin  | f8z200-mbl |   19.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1737
rtable_id: 21662
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 standard rear projection screen 81 x 108 video format | electronics - general | da-lite |     27917 | 5391.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 822
rtable_id: 18444
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 technology roadtrip hands-free | electronics - general | griffin technology | na15005   |   99.99 |

Entity B:
| title                                              | category   | brand              | modelno   |   price |
|:---------------------------------------------------|:-----------|:-------------------|:----------|--------:|
| griffin technology gc17090 handsfree mic aux cable | headsets   | griffin technology | gc17090   |    16.5 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 375
rtable_id: 7052
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-tga660b dect 6.0 plus digital cordless handset black | phones     | panasonic | kx-tga660b |   40.88 |

Entity B:
| title                                                                              | category            | brand     | modelno    |   price |
|:-----------------------------------------------------------------------------------|:--------------------|:----------|:-----------|--------:|
| panasonic kx-tg6643b dect 6.0 cordless phone with anwering system black 3 handsets | cordless telephones | panasonic | kx-tg6643b |   99.87 |



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

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

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

Entity A:
| title                                       | category    | brand   |   modelno |   price |
|:--------------------------------------------|:------------|:--------|----------:|--------:|
| iomega ego 500gb helium portable hard drive | hard drives | iomega  |     34945 |   78.98 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 266
rtable_id: 14829
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 |
|:--------------------------|:------------|:--------|:----------|--------:|
| rca 9 portable dvd player | dvd players | rca     | drc99392  |       0 |

Entity B:
| title                                   | category             | brand   | modelno   |   price |
|:----------------------------------------|:---------------------|:--------|:----------|--------:|
| gpx pdl805 8.5 inch portable dvd player | portable dvd players | gpx     | pdl805    |   69.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 819
rtable_id: 3860
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 cherry veneer model b manual screen with matte white fabric - 60 x 60 diagonal video format | electronics - general | da-lite |     73179 |  167.99 |

Entity B:
| title                                                                                    | category           | brand   | modelno   | price   |
|:-----------------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| honey maple 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: 2082
rtable_id: 14949
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

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

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

Entity A:
| title                                                                     | category              | brand   |   modelno |   price |
|:--------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-glas self trimming rear projection screen - 96 x 120 av format | electronics - general | da-lite |     27915 | 7443.99 |

Entity B:
| title                                                                      | category           | brand   |   modelno |   price |
|:---------------------------------------------------------------------------|:-------------------|:--------|----------:|--------:|
| da-lite da-plex standard rear projection screen - 94 1 2 x 168 hdtv format | projection screens | da-lite |     27149 |    7864 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2472
rtable_id: 2819
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 - 58 x 104 hdtv format | electronics - general | da-lite |     27590 | 4635.99 |

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



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

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

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

Entity A:
| title                                 | category                      | brand        | modelno   |   price |
|:--------------------------------------|:------------------------------|:-------------|:----------|--------:|
| wilson jones d-ring vinyl view binder | stationery & office machinery | wilson jones | 38544b    |    16.4 |

Entity B:
| title                                                            | category   | brand        | modelno   | price   |
|:-----------------------------------------------------------------|:-----------|:-------------|:----------|:--------|
| wilson jones 38349b - basic vinyl d-ring binder 3 capacity black |            | wilson jones |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 51
rtable_id: 19902
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 compactflash memory card | usb drives | wintec  | 3fmcf4gb-r |   15.98 |

Entity B:
| title                                                | category     | brand   | modelno    |   price |
|:-----------------------------------------------------|:-------------|:--------|:-----------|--------:|
| sandisk 4gb ultra ii compactflash memory card 15mb s | memory cards | sandisk | sdcfh-4096 |   17.96 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2018
rtable_id: 9602
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 extra high yield return pgm print cartridge - magenta | printers   | lexmark | c782u1mg  |  214.88 |

Entity B:
| title                                                         | category           | brand   | modelno   |   price |
|:--------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| lexmark x644e x646e high yield return program print cartridge | inkjet printer ink | lexmark | x644h11a  |  316.45 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 495
rtable_id: 4750
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 m85xws1 screens manual pull down projection screen | electronics - general | elite screens | m85xws1   |   60.84 |

Entity B:
| title                                                                                | category   | brand   | modelno   |   price |
|:-------------------------------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| elite screens manual pull down projection screen 16 9 aspect ratio-120in matte white |            | elite   | m120xwh   |  133.94 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2251
rtable_id: 1195
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 |
|:-------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| mohawk color copy gloss paper ream of 500 sheets | stationery & office machinery | mohawk  |     36101 |   12.94 |

Entity B:
| title                                                                                     | category           | brand   | modelno   | price   |
|:------------------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| mohawk 36101 - color copy gloss paper 96 brightness 32lb 8-1 2 x 11 white 500 sheets ream | projection screens | mohawk  |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2468
rtable_id: 10813
label: 1
Task: Entity-Matching (source dataset: Walmart-Amazon)

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

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

Entity A:
| title                                                       | category              | brand   |   modelno |   price |
|:------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite high power model c manual screen - 9 x 12 av format | electronics - general | da-lite |     83210 |  935.99 |

Entity B:
| title                                                                                   | category           | brand   | modelno   | price   |
|:----------------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| medium oak 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: 1061
rtable_id: 21933
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 |
|:-------------------------------------------------|:-----------|:--------|----------:|--------:|
| balt flipper rectangular training table top teak | furniture  | balt    |     89775 |     359 |

Entity B:
| title                                                                             | category   | brand   | modelno   | price   |
|:----------------------------------------------------------------------------------|:-----------|:--------|:----------|:--------|
| new-balt 89863 - flipper training table top rectangular 72w x 24d teak - blt89863 | turntables | balt    |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1886
rtable_id: 17807
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 |
|:--------------------------------------------------------------------------------------|:----------------|:--------|:----------|--------:|
| nikon coolpix s70 brown 12.1 mp digital camera with 5x optical zoom w 50 bonus prints | digital cameras | nikon   | s70 brown |  299.95 |

Entity B:
| title                                                                 | category                    | brand   |   modelno |   price |
|:----------------------------------------------------------------------|:----------------------------|:--------|----------:|--------:|
| nikon coolpix s550 10mp digital camera with 5x optical zoom cool blue | point shoot digital cameras | nikon   |     26109 |  229.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 683
rtable_id: 10207
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 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: 967
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 |
|:-------------------------|:-----------|:--------|:--------------------|--------:|
| pny 4gb mini flash drive | usb drives | pny     | p-fd4gb / mini-efm1 |   12.88 |

Entity B:
| title                                | category         | brand   | modelno   |   price |
|:-------------------------------------|:-----------------|:--------|:----------|--------:|
| pink hello kitty 4gb usb flash drive | usb flash drives | sanrio  |           |   14.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1423
rtable_id: 6134
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 |
|:--------------------------------------------------------------|:---------------------------------|:--------|----------:|--------:|
| sigma 18-250mm zoom lens for nikon digital slr cameras 880306 | camera and camcorder accessories | sigma   |    880306 |     478 |

Entity B:
| title                                                               | category    | brand   | modelno    | price   |
|:--------------------------------------------------------------------|:------------|:--------|:-----------|:--------|
| sigma 10-20mm f 4-5 .6 ex dc hsm lens for canon digital slr cameras | accessories | sigma   | b0007u00x0 |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1910
rtable_id: 9559
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 concord designer manual screen - 70 x 70 av format | electronics - general | da-lite |     76454 |  923.99 |

Entity B:
| title                                                                                | category           | brand   | modelno   | price   |
|:-------------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| high power concord designer manual screen - 100 diagonal av format size 120 diagonal | projection screens | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 853
rtable_id: 20542
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 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: 2504
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 |
|:------------------------------------------------|:----------------------|:----------|----------:|--------:|
| visiontek radeon hd6770 1gb gddr5 graphics card | electronics - general | visiontek |    900368 |     145 |

Entity B:
| title                                                                | category       | brand     |   modelno |   price |
|:---------------------------------------------------------------------|:---------------|:----------|----------:|--------:|
| visiontek radeon hd6770 1 gb gddr5 hdmi dvi vga graphics card 900368 | graphics cards | visiontek |    900368 |  130.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1498
rtable_id: 5234
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 |
|:-----------------------------------------------|:----------------------|:--------|:----------|--------:|
| dell switch by design studio lids fire red 17r | electronics - general | dell    | 8cmcy     |      24 |

Entity B:
| title                                                                   | category        | brand   | modelno                                   |   price |
|:------------------------------------------------------------------------|:----------------|:--------|:------------------------------------------|--------:|
| dell switch by design studio lid for inspiron r series laptop - sangeet | cleaning repair | dell    | switch by design studio , sangeet - 15 '' |   49.99 |



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

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

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

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

Entity B:
| title                                                                               | category   | brand   | modelno   |   price |
|:------------------------------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| canon mp41dhii 14-digit gloview lcd two-color printing desktop calculator black red | printing   | canon   | mp41dhii  |   58.08 |



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

Entity B:
| title                                                                                           | category       | brand   | modelno           |   price |
|:------------------------------------------------------------------------------------------------|:---------------|:--------|:------------------|--------:|
| msi ati radeon hd6570 1 gb ddr3 vga dvi hdmi low profile pci-express video card r6570-md1gd3 lp | graphics cards | msi     | r6570-md1gd3 / lp |   74.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2422
rtable_id: 12663
label: 0