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 |
|:-------------------------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| crown industrial deck plate antifatigue vinyl mat 36 x 144 black yellow border | home care  | crown   |           |  379.97 |

Entity B:
| title                                                                                        | category            | brand   | modelno   |   price |
|:---------------------------------------------------------------------------------------------|:--------------------|:--------|:----------|--------:|
| new-crown cd0023db - industrial deck plate antifatigue mat vinyl 24 x 36 black - cwncd0023db | laminating supplies | crown   |           |      76 |



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

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

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

Entity A:
| title                                               | category              | brand   | modelno         |   price |
|:----------------------------------------------------|:----------------------|:--------|:----------------|--------:|
| v7 3 cat6 snagless molded network patch cable black | electronics - general | v7      | v7n2c6-03f-blks |    4.88 |

Entity B:
| title                                                                                         | category        | brand   | modelno          |   price |
|:----------------------------------------------------------------------------------------------|:----------------|:--------|:-----------------|--------:|
| v7 cat5e snagless molded network patch cable rj45 male to male black 14-feet v7n3c5e-14f-blks | ethernet cables | v7      | v7n3c5e-14f-blks |    2.57 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1342
rtable_id: 7322
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 q3675a image transfer kit | printers   | hp      | q3675a    |  194.84 |

Entity B:
| title                                 | category            | brand   | modelno   |   price |
|:--------------------------------------|:--------------------|:--------|:----------|--------:|
| hp c8555a - c8555a image transfer kit | printer accessories | hp      |           |  290.16 |



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

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

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

Entity A:
| title                                                                               | category              | brand   |   modelno |   price |
|:------------------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite hc cinema vision tensioned cosmopolitan electrol - av format 7 x 9 diagonal | electronics - general | da-lite |     89892 |    2240 |

Entity B:
| title                                                                         | category           | brand   | modelno   | price   |
|:------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| hc cinema vision tensioned advantage deluxe electrol - av format size 50 x 50 | projection screens | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 856
rtable_id: 19779
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 - 96 x 96 av format | electronics - general | da-lite |     27651 | 6128.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: 1178
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 |
|:-----------------------------------------------------|:----------------------|:---------|----------:|--------:|
| fellowes 91441 gel crystal mouse pad with wrist rest | electronics - general | fellowes |     91441 |   14.88 |

Entity B:
| title                                     | category   | brand       | modelno   |   price |
|:------------------------------------------|:-----------|:------------|:----------|--------:|
| hello kitty red mouse pad with wrist rest | mouse pads | hello kitty |           |   10.76 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1321
rtable_id: 19864
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 |
|:--------------------------------------------|:----------------------|:---------|----------:|--------:|
| hercules dualpix emotion hd 720p usb webcam | electronics - general | hercules |   4780655 |   47.82 |

Entity B:
| title                              | category   | brand    |   modelno |   price |
|:-----------------------------------|:-----------|:---------|----------:|--------:|
| hercules dualpix emotion hd webcam | webcams    | hercules |   4780655 |   35.99 |



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

Entity B:
| title                                     | category   | brand   | modelno   |   price |
|:------------------------------------------|:-----------|:--------|:----------|--------:|
| d-link dir-601 wireless n 150 home router | routers    | d-link  | dir-601   |   24.65 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1295
rtable_id: 12448
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 da-glas thru-the-wall rear projection screen - 90 x 120 video format | projection screens | da-lite |     23056 | 8729.48 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2504
rtable_id: 8786
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 powershot elph 100 hs blue 12.1 mp digital camera with 4x optical zoom 3.0 lcd 1080p hd video w 50 bonus prints | digital cameras | canon   | 4925b001aa |  178.54 |

Entity B:
| title                                                                    | category                    | brand   | modelno         |   price |
|:-------------------------------------------------------------------------|:----------------------------|:--------|:----------------|--------:|
| canon powershot a800 10 mp digital camera with 3.3 x optical zoom silver | point shoot digital cameras | canon   | a800 ( silver ) |      89 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1511
rtable_id: 14510
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 |
|:---------------------------------------|:---------------|:--------|:--------------|--------:|
| accell proultra 4m hdmi ethernet cable | tv accessories | accell  | b116c-013b-40 |   29.88 |

Entity B:
| title                                                                        | category    | brand   | modelno       |   price |
|:-----------------------------------------------------------------------------|:------------|:--------|:--------------|--------:|
| accell proultra supreme b116c-016b-40 high speed hdmi cable with ethernet 5m | hdmi cables | accell  | b116c-016b-40 |   29.88 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 769
rtable_id: 10398
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 - 96 x 96 video format | electronics - general | da-lite |     73263 |  446.99 |

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



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

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

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

Entity A:
| title                                                                               | category              | brand   |   modelno |   price |
|:------------------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-plex self trimming rear projection screen - 40 1 4 x 53 3 4 video format | electronics - general | da-lite |     27580 | 1892.99 |

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: 2332
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 |
|:------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-glas deluxe rear projection screen - 96 x 96 av format | electronics - general | da-lite |     27651 | 6128.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1178
rtable_id: 806
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-glas base rear projection screen - 36 x 48 video format | projection screens | da-lite |           | 1199.99 |



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

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

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

Entity A:
| title                                             | category              | brand     | modelno   |   price |
|:--------------------------------------------------|:----------------------|:----------|:----------|--------:|
| microsoft lifecam hd-6000 usb hd webcam 7pd-00001 | electronics - general | microsoft | 7pd-00001 |   36.97 |

Entity B:
| title                                  | category   | brand     | modelno   |   price |
|:---------------------------------------|:-----------|:----------|:----------|--------:|
| microsoft lifecam vx-2000 webcam black | webcams    | microsoft | yfc-00001 |    15.8 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1611
rtable_id: 14617
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 cli-226 black ink tank | printers   | canon   | 4546b001  |   13.97 |

Entity B:
| title                                | category           | brand   | modelno   |   price |
|:-------------------------------------|:-------------------|:--------|:----------|--------:|
| canon cli-226 gray ink tank 4550b001 | inkjet printer ink | canon   | 4550b001  |   13.97 |



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

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

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

Entity A:
| title                                 | category              | brand   | modelno      |   price |
|:--------------------------------------|:----------------------|:--------|:-------------|--------:|
| siig mini displayport to hdmi adapter | electronics - general | siig    | cb-dp0b11-s1 |   19.88 |

Entity B:
| title                                                     | category               | brand            | modelno   | price   |
|:----------------------------------------------------------|:-----------------------|:-----------------|:----------|:--------|
| cables unlimited adp-8000 mini displayport to vga adapter | gps system accessories | cables unlimited |           |         |



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

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

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

Entity A:
| title                                             | category              | brand   | modelno     |   price |
|:--------------------------------------------------|:----------------------|:--------|:------------|--------:|
| targus 13.3 widescreen lcd monitor privacy screen | electronics - general | targus  | asf133w9usz |   42.07 |

Entity B:
| title                                                                | category       | brand   | modelno   |   price |
|:---------------------------------------------------------------------|:---------------|:--------|:----------|--------:|
| targus privacy filter for a 24-inch widescreen lcd monitor asf24wusz | screen filters | targus  | asf24wusz |   82.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2225
rtable_id: 1420
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 |
|:------------------------------------------------|:---------------------|:--------|:----------------------------------------|--------:|
| edge diskgo 500 gb 2.5-inch portable hard drive | external hard drives | edge    | 2.5 '' backup ultra portable hard drive |   78.07 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 266
rtable_id: 15128
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 |
|:---------------------------------------|:----------------------|:---------|----------:|--------:|
| innovera softskin gel wrist rest black | electronics - general | innovera |     51452 |   11.25 |

Entity B:
| title                                  | category    | brand    | modelno   |   price |
|:---------------------------------------|:------------|:---------|:----------|--------:|
| innovera softskin gel wrist rest black | wrist rests | innovera |           |   13.17 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1345
rtable_id: 20145
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 |
|:---------------------------------------------------|:-----------|:-------------|----------:|--------:|
| pc treasures wireless optical mouse 2.4 ghz purple | mice       | pc treasures |      7227 |   17.82 |

Entity B:
| title                                         | category   | brand   | modelno      |   price |
|:----------------------------------------------|:-----------|:--------|:-------------|--------:|
| hp 2.4 ghz wireless optical mobile mouse gray | mice       | hp      | vk481aa #aba |    5.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1560
rtable_id: 20737
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 |
|:------------------------------------|:-----------|:--------|:----------|--------:|
| brother tn360 black toner cartridge | printers   | brother | tn360     |   45.54 |

Entity B:
| title                              | category           | brand   | modelno   |   price |
|:-----------------------------------|:-------------------|:--------|:----------|--------:|
| brother lc41bk black ink cartridge | inkjet printer ink | brother | lc-41bk   |   16.35 |



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

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

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

Entity A:
| title                         | category   | brand   | modelno   |   price |
|:------------------------------|:-----------|:--------|:----------|--------:|
| kodak 10c color ink cartridge | printers   | kodak   | 10c       |   19.97 |

Entity B:
| title                                  | category           | brand   |   modelno |   price |
|:---------------------------------------|:-------------------|:--------|----------:|--------:|
| kodak black ink cartridge 10xl 8237216 | inkjet printer ink | kodak   |   8237216 |   16.97 |



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

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

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

Entity A:
| title                                           | category              | brand   | modelno          |   price |
|:------------------------------------------------|:----------------------|:--------|:-----------------|--------:|
| v7 25 cat5e snagless network patch cable yellow | electronics - general | v7      | v7n3c5e-25f-ylws |    6.88 |

Entity B:
| title                                                        | category             | brand   | modelno         |   price |
|:-------------------------------------------------------------|:---------------------|:--------|:----------------|--------:|
| v7 cat5e snagless patch cable rj45 male to male gray 25 feet | cables interconnects | v7      | v7-c5e-25-gry-s |    6.48 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 458
rtable_id: 3322
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 |
|:----------------------------------------------|:----------------------|:--------|:-----------|--------:|
| xfx amd radeon hd 6950 1gb ddr5 graphics card | electronics - general | xfx     | hd695xzndc |  269.82 |

Entity B:
| title                                                      | category              | brand   | modelno    | price   |
|:-----------------------------------------------------------|:----------------------|:--------|:-----------|:--------|
| xfx radeon hd 5770 1 gb ddr5 pcie graphics card hd577aznfc | computers accessories | xfx     | hd577aznfc |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 673
rtable_id: 15182
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 |
|:----------------------------------------------------------------------------|:-----------------|:--------|:-----------------------------------|--------:|
| edge diskgo secure guardian flash drive - usb flash drive - 16 gb - usb 2.0 | usb flash drives | edge    | diskgo secure guardian flash drive |   42.89 |



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

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

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

Entity A:
| title                            | category   | brand   | modelno   |   price |
|:---------------------------------|:-----------|:--------|:----------|--------:|
| sony 4gb flash memory card black | usb drives | sony    | sf4n4/tq  |   10.88 |

Entity B:
| title                                                   | category     | brand   | modelno      |   price |
|:--------------------------------------------------------|:-------------|:--------|:-------------|--------:|
| sony 8 gb memory stick pro duo flash memory card msmt8g | memory cards | sony    | msmt8g / / k |   24.03 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 84
rtable_id: 3490
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 outfit gloss ipod touch 4g black | mp3 accessories | griffin technology | gb01967   |   24.99 |

Entity B:
| title                                                    | category   | brand              | modelno   |   price |
|:---------------------------------------------------------|:-----------|:-------------------|:----------|--------:|
| griffin technology formfit for ipod touch 4g black clear | cases      | griffin technology | gb01957   |     7.4 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 218
rtable_id: 5038
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 gray carpeted picture king w keystone eliminator - hdtv format 92 diagonal | electronics - general | da-lite |     87062 |  343.99 |

Entity B:
| title                                                                                                               | category           | brand   | modelno   |   price |
|:--------------------------------------------------------------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| da-lite picture king hdtv format tripod screen with black carpeted housing 52 x 92 106 diagonal matte white surface | projection screens | da-lite |           |  324.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2223
rtable_id: 6744
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 |
|:-------------------------------------------------------------------------------------|:----------------------------|:--------|:----------|--------:|
| sanyo vpc-e1600tpbl 14mp digital camera w 5x optical zoom 3 lcd display - blue color | point shoot digital cameras | sanyo   |           |  117.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2395
rtable_id: 15534
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 |
|:--------------------------------------|:-----------|:--------|:----------|--------:|
| brother tn110bk black toner cartridge | printers   | brother | tn110bk   |   49.88 |

Entity B:
| title                               | category            | brand   | modelno   |   price |
|:------------------------------------|:--------------------|:--------|:----------|--------:|
| brother tn330 black toner cartridge | laser printer toner | brother | tn330     |   32.47 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2349
rtable_id: 2262
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 |
|:--------------------------------------|:----------------|:--------|:------------|--------:|
| ifrogz backbone case for ipad 2 black | mp3 accessories | ifrogz  | ipad2bakblk |   34.99 |

Entity B:
| title                         | category   | brand   | modelno        |   price |
|:------------------------------|:-----------|:--------|:---------------|--------:|
| ifrogz wrapz for iphone black | cases      | ifrogz  | iphonewrapz-17 |   19.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 900
rtable_id: 12980
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 electrol - wide format size wide 94 diagonal | projection screens | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1067
rtable_id: 21955
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 ht-d5300 3d wi-fi ready home theater system | home theater | samsung | ht-d5300  |     298 |

Entity B:
| title                                            | category         | brand   | modelno   | price   |
|:-------------------------------------------------|:-----------------|:--------|:----------|:--------|
| samsung electronics ht-d5300 home theater system | dvd home theater | samsung | htd5300   |         |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2054
rtable_id: 7601
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 |
|:----------------------------------------------------|:-----------|:--------|:----------|--------:|
| kanguru defender 1gb v2 kdv2-1g usb 2.0 flash drive | usb drives | kanguru | kdv2-1g   |   39.82 |

Entity B:
| title                                                  | category         | brand             | modelno   |   price |
|:-------------------------------------------------------|:-----------------|:------------------|:----------|--------:|
| kanguru defender 32 gb usb 2.0 flash drive v2 kdv2-32g | usb flash drives | kanguru solutions | kdv2-32g  |  122.36 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2296
rtable_id: 4823
label: 0