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 |
|:---------------------------------|:-----------|:--------|:-----------|--------:|
| sony 16gb class 4 sd memory card | usb drives | sony    | sf16n4/tqp |       0 |

Entity B:
| title                                        | category    | brand   | modelno                        |   price |
|:---------------------------------------------|:------------|:--------|:-------------------------------|--------:|
| fujifilm 4 gb class 6 sdhc flash memory card | blank media | fuji    | fujifilm 4gb sd-hc memory card |    8.98 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1853
rtable_id: 3149
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 outfit ice for ipod touch 4g red | cases      | griffin technology | gb01911   |   15.35 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 218
rtable_id: 13085
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 - 96 x 120 av format | electronics - general | da-lite |     27903 | 7799.99 |

Entity B:
| title                                                                        | category           | brand   | modelno   | price   |
|:-----------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| da-lite 27512 da-plex unframed rear projection screen - 72 x 96 video format | projection screens | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 561
rtable_id: 17837
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-view thru-the-wall rear projection screen - 57 3 4 x 77 video format | projection screens | da-lite |     23040 | 11346.1 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2504
rtable_id: 14680
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 |
|:--------------------------------------------------------|:------------|:--------|:------------|--------:|
| philips swv3474s 27 swivel high speed hdmi cable 6 feet | hdmi cables | philips | swv3474s/27 |   16.41 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2424
rtable_id: 1751
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 72 x 96 video format | electronics - general | da-lite |     27639 | 4448.99 |

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



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

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

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

Entity A:
| title                                                                 | category              | brand   |   modelno |   price |
|:----------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-glas standard rear projection screen 81 x 108 video format | electronics - general | da-lite |     27917 | 5391.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 822
rtable_id: 19283
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 |
|:------------------------------------------------------------------|:----------------------|:--------|:---------------|--------:|
| 3m 98-0440-4809-2 pf27 .0 w privacy screen filter for lcd monitor | electronics - general | 3m      | 98-0440-4809-2 |  199.88 |

Entity B:
| title                                                     | category       | brand   | modelno   |   price |
|:----------------------------------------------------------|:---------------|:--------|:----------|--------:|
| 3m privacy filter -3 m pf17 .0 monitor privacy screen 5 4 | screen filters | 3m      | pf17 .0   |   55.14 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2272
rtable_id: 10051
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 |
|:-----------------------------------------------|:-----------|:--------|:--------------|--------:|
| netgear prosafe gs716t 16-port ethernet switch | networking | netgear | gs716t-200nas |     238 |

Entity B:
| title                                             | category            | brand   | modelno       |   price |
|:--------------------------------------------------|:--------------------|:--------|:--------------|--------:|
| gs716t-200 - prosafe 16-port gigabit smart switch | networking products | netgear | gs716t-200nas |  224.37 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2089
rtable_id: 7048
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 |
|:-------------------------------------------------------------------------------------------------|:----------------|:--------|:----------|--------:|
| kodak easyshare m531 red 14mp digital camera w 3x optical zoom 2.7 lcd display w 50 bonus prints | digital cameras | kodak   | m531 red  |      89 |

Entity B:
| title                                                                                             | category                    | brand   | modelno               |   price |
|:--------------------------------------------------------------------------------------------------|:----------------------------|:--------|:----------------------|--------:|
| kodak easyshare m550 12 mp digital camera with 5x wide angle optical zoom and 2.7-inch lcd purple | point shoot digital cameras | kodak   | easyshare m550 purple |   89.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1145
rtable_id: 12848
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 ht-c6600 blu-ray home theater system | speaker systems | samsung | ht-c6600  |  299.99 |



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

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

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

Entity A:
| title                                                                      | category              | brand    | modelno     |   price |
|:---------------------------------------------------------------------------|:----------------------|:---------|:------------|--------:|
| startech esata usb to sata external hard drive docking station for 2.5 hdd | electronics - general | startech | satadocku2e |   29.84 |

Entity B:
| title                                                                     | category             | brand    | modelno     |   price |
|:--------------------------------------------------------------------------|:---------------------|:---------|:------------|--------:|
| startech esata usb 2.0 to sata standalone hard drive duplicator dock 22re | computer accessories | startech | satdock22re |   55.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1589
rtable_id: 11419
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-plex thru-the-wall rear projection screen - 78 x 139 hdtv format | projection screens | da-lite |     23077 | 9258.99 |



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

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

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

Entity A:
| title                            | category              | brand      |   modelno |   price |
|:---------------------------------|:----------------------|:-----------|----------:|--------:|
| case logic medium slr camera bag | photography - general | case logic |    133827 |   47.99 |

Entity B:
| title                                     | category   | brand      | modelno   |   price |
|:------------------------------------------|:-----------|:-----------|:----------|--------:|
| case logic dcb-308 slr camera sling black | cases bags | case logic | dcb-308   |    47.8 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 145
rtable_id: 6538
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 |
|:-----------------------------------------------------|:-----------|:---------|:-----------------|--------:|
| kingston ktd-dm8400a 1g 1gb ddr2 sdram memory module | memory     | kingston | ktd-dm8400a / 1g |   22.92 |

Entity B:
| title                                                                                                        | category   | brand    | modelno          |   price |
|:-------------------------------------------------------------------------------------------------------------|:-----------|:---------|:-----------------|--------:|
| kingston 4 gb ddr2 sdram memory module 4 gb 2 x 2 gb 667mhz ddr2667 pc25400 ddr2 sdram 200pin kta-mb667k2 4g | memory     | kingston | kta-mb667k2 / 4g |   49.99 |



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

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

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

Entity A:
| title                                                                | category              | brand   |   modelno |   price |
|:---------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite holoscreen rear projection screen - 22 x 33 3 4 video format | electronics - general | da-lite |     20030 |    1600 |

Entity B:
| title                                                                          | category           | brand   | modelno   | price   |
|:-------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| da-lite 27514 da-plex unframed rear projection screen - 108 x 144 video format | projection screens | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 626
rtable_id: 13427
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 ec-st65zzbpu indigo blue 14.2 mp digital camera w 5x optical digital camera 2.7 lcd display w 50 bonus prints | digital cameras | samsung | ec-st65zzbpu |      84 |

Entity B:
| title                                                                     | category                    | brand   | modelno        | price   |
|:--------------------------------------------------------------------------|:----------------------------|:--------|:---------------|:--------|
| samsung ec-st65 digital camera with 14 mp and 5x optical zoom indigo blue | point shoot digital cameras | samsung | ec-st65zzbpuus |         |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2441
rtable_id: 21373
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 |
|:-------------------------------------------|:----------------------|:--------|:----------|--------:|
| los angeles lakers ipod touch 4g hard case | electronics - general | tribeca | fva4614   |   29.99 |

Entity B:
| title                                        | category              | brand   | modelno   |   price |
|:---------------------------------------------|:----------------------|:--------|:----------|--------:|
| los angeles dodgers ipod touch silicone skin | computers accessories | tribeca |           |    9.99 |



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

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

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

Entity A:
| title                                                                                     | category              | brand   | modelno      |   price |
|:------------------------------------------------------------------------------------------|:----------------------|:--------|:-------------|--------:|
| vantec nexstar3 2.5 sata to usb 2.0 and esata external hard drive enclosure midnight blue | electronics - general | vantec  | nst-260su-bl |      23 |

Entity B:
| title                                                                                       | category              | brand   | modelno      |   price |
|:--------------------------------------------------------------------------------------------|:----------------------|:--------|:-------------|--------:|
| vantec nexstar cx nst-200s2-bk 2.5-inch sata to usb 2.0 external hard drive enclosure black | hard drive enclosures | vantec  | nst-200s2-bk |   10.15 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 532
rtable_id: 2074
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 |
|:--------------------------------|:-----------|:--------|:----------|--------:|
| xerox 108r00579 transfer roller | printers   | xerox   | 108r00579 |  199.88 |

Entity B:
| title                                                    | category                 | brand   | modelno   |   price |
|:---------------------------------------------------------|:-------------------------|:--------|:----------|--------:|
| xerox printers transfer roller for phaser 6250 108r00592 | printer transfer rollers | xerox   | 108r00592 |   50.34 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 148
rtable_id: 21842
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 3.5 sata superspeed usb 3.0 hard drive enclosure pro | electronics - general | siig    | ju-sa0b12-s1 |   41.39 |

Entity B:
| title                                                   | category             | brand   | modelno      |   price |
|:--------------------------------------------------------|:---------------------|:--------|:-------------|--------:|
| superspeed usb 3.0 to sata 3gb s 2.5 in drive enclosure | cables interconnects | siig    | ju-sa0312-s1 |   29.89 |



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

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

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

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

Entity B:
| title                                      | category   | brand   | modelno    |   price |
|:-------------------------------------------|:-----------|:--------|:-----------|--------:|
| canon pidhv printing calculator 9493a001ac | printing   | canon   | 9493a001ac |   17.54 |



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

Entity B:
| title                                                                                                             | category           | brand   | modelno   | price   |
|:------------------------------------------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| da-lite manual 72 x 96 diagonal square format office wall screen with mahogany veneer case and matte white fabric | projection screens | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1571
rtable_id: 10747
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 |
|:-----------------------------------------------------------|:----------------------|:--------|:-------------|--------:|
| zotac geforce gt430 1gb ddr3 pci-express 2.0 graphics card | electronics - general | zotac   | zt-40604-10l |   88.88 |

Entity B:
| title                                                                                | category       | brand   | modelno        |   price |
|:-------------------------------------------------------------------------------------|:---------------|:--------|:---------------|--------:|
| evga geforce 210 512 mb ddr3 pci-express 2.0 graphics card video card 512-p3-1310-lr | graphics cards | evga    | 512-p3-1310-lr |   34.88 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 621
rtable_id: 13148
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 |
|:--------------------------------------------------|:-----------|:---------|----------:|--------:|
| verbatim 96438 2gb store n go usb 2.0 flash drive | usb drives | verbatim |     96438 |   14.84 |

Entity B:
| title                                                                            | category         | brand    |   modelno |   price |
|:---------------------------------------------------------------------------------|:-----------------|:---------|----------:|--------:|
| verbatim store n go blazedrive 8 gb usb 2.0 flash drive 97196 metallic gun metal | usb flash drives | verbatim |     97196 |   22.64 |



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

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

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

Entity A:
| title                                                                         | category                      | brand   |   modelno |   price |
|:------------------------------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| smead recycled end tab fastener folders straight cut 11pt legal manila 50 box | stationery & office machinery |         |     37160 |   41.18 |

Entity B:
| title                                                                                 | category                       | brand   | modelno   |   price |
|:--------------------------------------------------------------------------------------|:-------------------------------|:--------|:----------|--------:|
| smead 14813 - kraft k style fastener folders straight cut top tab letter brown 50 box | storage presentation materials | smead   |           |   39.59 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1695
rtable_id: 5498
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 - 78 x 139 hdtv format | electronics - general | da-lite |     23077 |   11386 |

Entity B:
| title                                                                        | category           | brand   |   modelno |   price |
|:-----------------------------------------------------------------------------|:-------------------|:--------|----------:|--------:|
| da-lite da-plex thru-the-wall rear projection screen - 90 x 120 video format | projection screens | da-lite |     23055 |   12222 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2471
rtable_id: 805
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 q1413a universal heavyweight coated paper | stationery & office machinery | hp      | q1413a    |   58.78 |

Entity B:
| title                          | category            | brand   | modelno   |   price |
|:-------------------------------|:--------------------|:--------|:----------|--------:|
| hp q1396a universal bond paper | printer accessories | hp      |           |   42.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1522
rtable_id: 18458
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 |
|:--------------------------------------------------------------------------|:-----------|:-----------|:----------|--------:|
| flip ultra u1120 white camcorder 2 hour recording time 4gb 2nd generation | camcorders | flip video | u1120w    |     109 |

Entity B:
| title                                                                 | category   | brand      | modelno   |   price |
|:----------------------------------------------------------------------|:-----------|:-----------|:----------|--------:|
| flip ultra video camera - white 4 gb 2 hours 2nd generation old model | camcorders | flip video | u1120w    |   69.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2007
rtable_id: 20461
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 |
|:------------------------------------------------------------------------|:---------------|:--------|:----------|--------:|
| ihome rechargeable collapsible portable mini multimedia speakers silver | portable audio | ihome   | ihm79sc   |   47.55 |

Entity B:
| title                                         | category               | brand   | modelno   |   price |
|:----------------------------------------------|:-----------------------|:--------|:----------|--------:|
| ihome ihm78px rechargeable mini speakers pink | mp3 player accessories | ihome   | ihm78px   |      24 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1302
rtable_id: 8965
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 |
|:-----------------------------------|:-----------|:--------|:----------|--------:|
| ihome wireless optical mouse black | mice       | ihome   | ih-m821wb |   25.56 |

Entity B:
| title                                                       | category   | brand    |   modelno |   price |
|:------------------------------------------------------------|:-----------|:---------|----------:|--------:|
| verbatim 96781 nano wireless notebook optical mouse - black | mice       | verbatim |     96781 |   19.44 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 582
rtable_id: 9301
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 7653 compatible ink 8000 page-yield red | printers   | innovera |      7653 |    54.1 |

Entity B:
| title                                                                                | category        | brand    | modelno   | price   |
|:-------------------------------------------------------------------------------------|:----------------|:---------|:----------|:--------|
| innovera m4640 - m4640 compatible remanufactured high-yield ink 484 page-yield black | hard drive bags | innovera |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1850
rtable_id: 16916
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 cl-470 ipad screen protector 2pk clear | mp3 accessories | incipio | cl-470    |      19 |

Entity B:
| title                                                     | category          | brand   | modelno   |   price |
|:----------------------------------------------------------|:------------------|:--------|:----------|--------:|
| incipio cl-470 screen protector for ipad 2 clear - 2 pack | screen protectors | incipio | cl-470    |   17.61 |



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

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

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

Entity A:
| title                                                           | category              | brand   |   modelno |   price |
|:----------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite 40184 model b manual wall and ceiling projection screen | electronics - general | da-lite |     40184 |   47.84 |

Entity B:
| title                                                                      | category              | brand          | modelno   |   price |
|:---------------------------------------------------------------------------|:----------------------|:---------------|:----------|--------:|
| dalite manual wall and ceiling screen accessory pull rod projection screen | projector accessories | da-lite screen |           |    9.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 327
rtable_id: 14404
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 |
|:-------------------------------------------|:------------|:--------|:----------|--------:|
| sony dlc-he50p round high speed hdmi cable | hdmi cables | sony    | dlche50p  |   50.93 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2424
rtable_id: 9516
label: 0