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 |
|:--------------------------------------------------|:-----------|:----------|:----------|--------:|
| microsoft wireless mobile mouse 4000 sgkomen pink | mice       | microsoft | d5d-00052 |      20 |

Entity B:
| title                                                       | category   | brand     | modelno   |   price |
|:------------------------------------------------------------|:-----------|:----------|:----------|--------:|
| microsoft wireless mobile mouse 4000 studio series - crania | mice       | microsoft | d5d-00066 |    24.4 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 219
rtable_id: 728
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 super heavy weight sheet protector | stationery & office machinery | wilson jones |     21402 |   10.94 |

Entity B:
| title                                                                               | category                       | brand        | modelno   |   price |
|:------------------------------------------------------------------------------------|:-------------------------------|:-------------|:----------|--------:|
| new-wilson jones 21400 - super heavy weight sheet protector clear 50 box - wlj21400 | storage presentation materials | wilson jones |           |      28 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1506
rtable_id: 17249
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 |
|:------------------------------------------------|:-----------|:----------|:-----------|--------:|
| gear head wireless optical tilt-wheel mouse red | mice       | gear head | mpt3200red |   19.88 |

Entity B:
| title                                                        | category              | brand     | modelno   |   price |
|:-------------------------------------------------------------|:----------------------|:----------|:----------|--------:|
| gear head 2.4 ghz wireless desktop and optical mouse kb5150w | keyboard mouse combos | gear head | kb5150w   |   24.99 |



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

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

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

Entity A:
| title                                                                | category              | brand   |   modelno |   price |
|:---------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-plex deluxe rear projection screen - 36 x 48 video format | electronics - general | da-lite |     27559 | 1630.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1605
rtable_id: 17561
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-plex deluxe rear projection screen - 108 x 108 av format | projection screens | da-lite |           |    7950 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2430
rtable_id: 304
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 |
|:----------------------------------------------------------------------------------------------------------------------------------------------------|:------------|:-------------------|:-----------|--------:|
| buffalo technology ministation metro 1 tb usb 2.0 portable external hard drive with integrated flex cable encryption and turbopc hd-pxt1tu2 b black | hard drives | buffalo technology | hdpxt1tu2b |   99.82 |

Entity B:
| title                                                                                                                     | category             | brand              | modelno         |   price |
|:--------------------------------------------------------------------------------------------------------------------------|:---------------------|:-------------------|:----------------|--------:|
| buffalo technology ministation plus 1 tb usb 3.0 portable external hard drive with shock protection hd-pnt1 .0 u3bb black | external hard drives | buffalo technology | hd-pnt1 .0 u3bb |  103.24 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 215
rtable_id: 10597
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 61x black print cartridge in retail packaging - dual pack | laser printer toner | hp      | c8061d    |  199.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 25
rtable_id: 13010
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 hd 720p webcam c310 | electronics - general | logitech | 960-000585 |   48.88 |

Entity B:
| title                     | category   | brand    | modelno    |   price |
|:--------------------------|:-----------|:---------|:-----------|--------:|
| logitech 720p webcam c310 | webcams    | logitech | 960-000585 |   24.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 941
rtable_id: 2805
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 |
|:----------------------------------------------|:-----------|:--------|:----------|--------:|
| lexmark e450h11a toner 11000 page-yield black | printers   | lexmark | e450h11a  |  248.27 |

Entity B:
| title                                                                              | category          | brand   | modelno   |   price |
|:-----------------------------------------------------------------------------------|:------------------|:--------|:----------|--------:|
| new-lexmark 12a7462 - 12a7462 high-yield toner 21000 page-yield black - lex12a7462 | printer ink toner | lexmark |           |  191.01 |



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

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

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

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

Entity B:
| title                                                                                                                  | category          | brand            | modelno   | price   |
|:-----------------------------------------------------------------------------------------------------------------------|:------------------|:-----------------|:----------|:--------|
| ge dect 6.0 black corded base phone with caller id digital answering system and 2 cordless accessory handsets 28871fe3 | corded telephones | general electric | 28871fe3  |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 594
rtable_id: 8398
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-glas self trimming rear projection screen - 60 x 80 video format | projection screens | da-lite |           | 3095.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 822
rtable_id: 18165
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 |
|:----------------------------------------------------|:-----------|:--------|:----------|--------:|
| aoc 2236vw 22 widescreen lcd monitor in piano black | monitors   | aoc     | 2236vw    |     129 |

Entity B:
| title                                                       | category   | brand   | modelno   | price   |
|:------------------------------------------------------------|:-----------|:--------|:----------|:--------|
| samsung b2230 22-inch widescreen lcd monitor - glossy black | monitors   | samsung | b2230     |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 871
rtable_id: 6106
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 |
|:----------------------------------------------------------------|:----------------------|:--------|:----------|--------:|
| lowepro apex aw10 all-weather ultra-compact digital camera case | photography - general | lowepro | lp34977   |   17.84 |

Entity B:
| title                                                           | category   | brand   |   modelno |   price |
|:----------------------------------------------------------------|:-----------|:--------|----------:|--------:|
| lowepro slingshot 100 all-weather digital camera backpack black | cases bags | lowepro |     34736 |      44 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 955
rtable_id: 21901
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 100 gb vertex limited edition 2.5-inch sataii solid state drive ssd oczssd2-1vtxle100g | computers accessories | ocz     | oczssd2-1vtxle100g |  314.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1092
rtable_id: 9841
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 |
|:----------------------------------------------------------|:------------|:--------|:-----------------|--------:|
| samsung s2 640gb usb 3.0 portable external hard drive red | hard drives | samsung | hx-mta64da / g42 |   78.88 |

Entity B:
| title                                                        | category              | brand   |   modelno |   price |
|:-------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| iomega ego 500 gb usb 2.0 portable external hard drive 34945 | computers accessories | iomega  |     34945 |   74.84 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 896
rtable_id: 2949
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 |
|:-----------------------------------------------------------------------------------------------------|:-----------|:-------------------|:-----------|--------:|
| buffalo technology linkstation duo dual-bay 1.0 tb 1 x 1tb network attatched storage ls-wx1 .0 tl 1d | networking | buffalo technology | lswx10tl1d |  179.82 |

Entity B:
| title                                                                                                     | category              | brand              | modelno         |   price |
|:----------------------------------------------------------------------------------------------------------|:----------------------|:-------------------|:----------------|--------:|
| buffalo technology linkstation pro quad 4 tb 4 x 1 tb raid network attached storage ls-qv4 .0 tl r5 black | computers accessories | buffalo technology | ls-qv4 .0 tl/r5 |  488.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1348
rtable_id: 2669
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 16 value laptop briefcase black | computers  | case logic | vnci116black |      22 |

Entity B:
| title                                                  | category                            | brand      | modelno      |   price |
|:-------------------------------------------------------|:------------------------------------|:-----------|:-------------|--------:|
| case logic vnb-217 value 17-inch laptop backpack black | laptop netbook computer accessories | case logic | vnb-217black |   26.24 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 144
rtable_id: 9985
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 61 black tri-color combo inkjet cartridge | printers   | hp      | hp 61     |    30.5 |

Entity B:
| title                          | category           | brand   | modelno       |   price |
|:-------------------------------|:-------------------|:--------|:--------------|--------:|
| hp 61 ink cartridge combo pack | inkjet printer ink | hp      | cr259fn # 140 |    28.2 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 992
rtable_id: 19592
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 |
|:---------------------------------------------------------------|:----------------------|:----------|:----------|--------:|
| microsoft wireless laser desktop 3000 keyboard and mouse combo | electronics - general | microsoft | nud-00001 |   29.82 |

Entity B:
| title                                                     | category   | brand     | modelno   |   price |
|:----------------------------------------------------------|:-----------|:----------|:----------|--------:|
| microsoft wireless laser mouse 6000 v2 .0 mac windows usb | mice       | microsoft | qva-00001 |   19.55 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 572
rtable_id: 113
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 |
|:------------------------------------------------------------------------------------------------------------------------------------|:------------|:-------------------|:--------------|--------:|
| buffalo technology drivestation axis 1.5 tb usb 2.0 desktop external hard drive with buffalo tools and turbo pc hd-lb1 .5 tu2 black | hard drives | buffalo technology | hd-lb1 .5 tu2 |  101.82 |

Entity B:
| title                                                                                                                 | category             | brand              | modelno      |   price |
|:----------------------------------------------------------------------------------------------------------------------|:---------------------|:-------------------|:-------------|--------:|
| buffalo technology drivestation combo4 1.0 tb desktop external hard drive usb 2.0 firewire 800 400 esata hd-hs1 .0 tq | external hard drives | buffalo technology | hd-hs1 .0 tq |  121.21 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1129
rtable_id: 18962
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 |
|:-----------------------------------------------------------------------------------------|:------------------------------|:-------------|----------:|--------:|
| wausau paper astrobrights colored paper 24lb 8-1 2 x 11 planetary purple 500 sheets ream | stationery & office machinery | wausau paper |     22621 |   10.27 |

Entity B:
| title                                                                     | category   | brand   | modelno   |   price |
|:--------------------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| fireworx colored paper 20lb 8-1 2 x 14 bottle rocket blue 500 sheets ream |            | boise   |           |    9.93 |



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

Entity B:
| title                                                        | category          | brand   | modelno          |   price |
|:-------------------------------------------------------------|:------------------|:--------|:-----------------|--------:|
| ag2 anti-glare screen protector for 10.1 widescreen netbooks | screen protectors | green   | rt-spf10101w / m |    8.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 753
rtable_id: 13967
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 optical mouse 3000 | mice       | microsoft | d1t-00002 |    9.09 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1810
rtable_id: 6172
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 exilim ex-z800 14.1 mp digital camera with 4x optical zoom and 2.7-inch lcd pink | point shoot digital cameras | casio   | ex-z800pk |  149.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1827
rtable_id: 12584
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 |
|:------------------------------------------------|:-----------|:--------|:----------|--------:|
| sabrent 6-in-1 usb 2.0 flash memory card reader | usb drives | sabrent | crw-ext   |   10.98 |

Entity B:
| title                                                                | category            | brand     | modelno   |   price |
|:---------------------------------------------------------------------|:--------------------|:----------|:----------|--------:|
| transcend p8 15-in-1 usb 2.0 flash memory card reader ts-rdp8k black | memory card readers | transcend | ts-rdp8k  |    12.1 |



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

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

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

Entity A:
| title                                                            | category                      | brand   |   modelno |   price |
|:-----------------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| sharpie retractable permanent markers fine point set of 12 black | stationery & office machinery | sharpie |     32701 |   13.64 |

Entity B:
| title                                                   | category          | brand   | modelno   |   price |
|:--------------------------------------------------------|:------------------|:--------|:----------|--------:|
| san36703 - permanent marker retractable fine point blue | printer ink toner | sanford |           |    2.39 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1241
rtable_id: 14346
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 |
|:-----------------------------------|:----------------------|:--------|----------:|--------:|
| allsop clingo universal vent mount | electronics - general | allsop  |     30329 |   19.99 |

Entity B:
| title                                  | category       | brand   |   modelno |   price |
|:---------------------------------------|:---------------|:--------|----------:|--------:|
| navgear 14027 universal gps vent mount | vehicle mounts | navgear |     14027 |    3.07 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 937
rtable_id: 13300
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 |
|:--------------------------------|:----------------------|:--------|:------------|--------:|
| philips 3 high speed hdmi cable | electronics - general | philips | swv3431w/17 |   10.43 |

Entity B:
| title                                                       | category     | brand   | modelno      |   price |
|:------------------------------------------------------------|:-------------|:--------|:-------------|--------:|
| 1m microhd high quality high speed hdmi to hdmi micro cable | audio cables | siig    | cb-hd0012-s1 |    6.69 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2424
rtable_id: 6675
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 black | point shoot digital cameras | casio   | ex-z16bk  |      98 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2395
rtable_id: 18644
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 |
|:--------------------------------------------------|:----------------------|:--------|:----------|--------:|
| incipio smart feather for apple ipad 2 light blue | electronics - general | incipio | ipad-227  |   33.25 |

Entity B:
| title                                                                                            | category   | brand      | modelno   |   price |
|:-------------------------------------------------------------------------------------------------|:-----------|:-----------|:----------|--------:|
| pink oem incipio smart feather ultra thin case ipad-230 for apple ipad 2 use w apple smart cover |            | karendeals |           |   29.95 |



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

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

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

Entity A:
| title                                                | category   | brand       | modelno   |   price |
|:-----------------------------------------------------|:-----------|:------------|:----------|--------:|
| audiosource bi5 5 in-wall construction bracket mount | furniture  | audiosource | bi5       |   25.88 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 639
rtable_id: 18263
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 |
|:------------------------------------------|:-----------|:---------|:---------------|--------:|
| sylvania 4gb touch video mp3 player black | mp3        | sylvania | smpk4230-black |      35 |

Entity B:
| title                             | category    | brand   | modelno   |   price |
|:----------------------------------|:------------|:--------|:----------|--------:|
| zune 16 gb video mp3 player black | mp3 players | zune    | wha-00001 |  249.95 |



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

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

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

Entity A:
| title                                                                        | category              | brand   |   modelno |   price |
|:-----------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-plex deluxe rear projection screen - 50 1 2 x 67 1 4 video format | electronics - general | da-lite |     27562 | 2544.99 |

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



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

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

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

Entity A:
| title                                                                       | category              | brand   |   modelno |   price |
|:----------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite pearlescent tensioned advantage electrol - av format 6 x 8 diagonal | electronics - general | da-lite |     84381 | 2532.99 |

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



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

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

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

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

Entity B:
| title                             | category           | brand   | modelno   |   price |
|:----------------------------------|:-------------------|:--------|:----------|--------:|
| epson s189108 black ink cartridge | inkjet printer ink | epson   | s189108   |   18.69 |



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