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 |
|:---------------------------------------------|:----------------|:---------|----------:|--------:|
| verbatim 95003 3x dvd-ram double-sided media | mp3 accessories | verbatim |     95003 |   13.88 |

Entity B:
| title                                                       | category    | brand    |   modelno |   price |
|:------------------------------------------------------------|:------------|:---------|----------:|--------:|
| verbatim 2.8 gb 2x double-sided mini dvd-ram bundle 3 discs | blank media | verbatim |     95429 |    19.8 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1200
rtable_id: 3307
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 3.5 ide to usb 2.0 nexstar 3 hard drive enclosure onyx black | electronics - general | vantec  | nst-360u2-bk |   30.23 |

Entity B:
| title                                                                                                                         | category              | brand   | modelno      |   price |
|:------------------------------------------------------------------------------------------------------------------------------|:----------------------|:--------|:-------------|--------:|
| vantec nexstar mx nst-400mx-sr dual 3.5-inch sata to usb 2.0 and esata with jbod raid 0 1 external hard drive enclosure black | hard drive enclosures | vantec  | nst-400mx-sr |   91.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 793
rtable_id: 8070
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 |
|:------------------------------------------------|:----------------------|:--------|:-----------------|--------:|
| antec tricool 92mm double ball bearing case fan | electronics - general | antec   | tricool 92mm dbb |    8.25 |

Entity B:
| title                                                                      | category   | brand   | modelno          |   price |
|:---------------------------------------------------------------------------|:-----------|:--------|:-----------------|--------:|
| antec tricool 92mm dbb case fan with 3-spd switch 3 4-pin 3-pin monitoring |            | antec   | tricool 92mm dbb |    8.25 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2118
rtable_id: 20621
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 da-plex self trimming rear projection screen - 58 x 104 hdtv format | electronics - general | da-lite |     27590 | 4635.99 |

Entity B:
| title                                                       | category           | brand   | modelno   |   price |
|:------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| da-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: 1060
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 |
|:---------------------------------------------------|:----------------------|:--------|----------:|--------:|
| roocase 2-pack capacitive stylus for ipad 2 tablet | electronics - general | roocase |    218564 |   19.99 |

Entity B:
| title                                                                  | category                        | brand   | modelno         |   price |
|:-----------------------------------------------------------------------|:--------------------------------|:--------|:----------------|--------:|
| roocase capacitive silver stylus for apple ipad 1st and 2nd generation | touch screen tablet accessories | roocase | ym-capstylus-si |    8.97 |



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

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

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

Entity A:
| title                                                   | category   | brand   | modelno   |   price |
|:--------------------------------------------------------|:-----------|:--------|:----------|--------:|
| lexmark t650h11a black high-yield toner print cartridge | printers   | lexmark | t650h11a  |   565.2 |

Entity B:
| title                                    | category           | brand   | modelno   |   price |
|:-----------------------------------------|:-------------------|:--------|:----------|--------:|
| lexmark 32 print cartridge black 18c0032 | inkjet printer ink | lexmark | 18c0032   |   18.26 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1418
rtable_id: 6761
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 |
|:----------------------------------------------------|:-----------|:--------|:----------|--------:|
| filemate imagine series k2010 usb standard keyboard | computers  |         |           |   15.12 |

Entity B:
| title                                                                                                  | category   | brand   | modelno        |   price |
|:-------------------------------------------------------------------------------------------------------|:-----------|:--------|:---------------|--------:|
| wintec filemate imagine series k2210 usb standard keyboard - light pink with white keys 3fmnk2210upk-r | keyboards  | wintec  | 3fmnk2210upk-r |   15.99 |



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

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

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

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

Entity B:
| title                                                                       | category           | brand   |   modelno |   price |
|:----------------------------------------------------------------------------|:-------------------|:--------|----------:|--------:|
| da-lite da-plex thru-the-wall rear projection screen - 72 x 96 video format | projection screens | da-lite |     23049 |   10252 |



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

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

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

Entity A:
| title                                             | category                      | brand   | modelno   |   price |
|:--------------------------------------------------|:------------------------------|:--------|:----------|--------:|
| sharpie fine point permanent markers assorted 5ct | stationery & office machinery | sharpie | 30653pp   |    8.19 |

Entity B:
| title                                                            | category                | brand   | modelno   |   price |
|:-----------------------------------------------------------------|:------------------------|:--------|:----------|--------:|
| sharpie 35074 - permanent marker extra fine point assorted 4 set | microphones accessories | sharpie |           |   22.34 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 79
rtable_id: 20224
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 |
|:--------------------------------------|:----------------------|:------------|:----------|--------:|
| plantronics h91cis encore h91 headset | electronics - general | plantronics | h91cis    |  119.88 |

Entity B:
| title                               | category             | brand       | modelno   |   price |
|:------------------------------------|:---------------------|:------------|:----------|--------:|
| plantronics hw261n binaural headset | headsets microphones | plantronics | 64339-31  |   71.37 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2283
rtable_id: 1739
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 kvr800d2n5 1g valueram 1gb ddr2-800 240-pin sdram desktop memory module | memory     | kingston | kvr800d2n5/1g |   20.92 |

Entity B:
| title                                                                                      | category   | brand    | modelno        |   price |
|:-------------------------------------------------------------------------------------------|:-----------|:---------|:---------------|--------:|
| kingston valueram 2gb kit 2x1gb modules 533mhz pc2-4200 ddr2 desktop memory kvr533d2k2 2gr | memory     | kingston | kvr533d2k2/2gr |   25.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1112
rtable_id: 8850
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 dual vision tensioned cosmopolitan electrol - av format 7 x 9 diagonal | electronics - general | da-lite |     84986 | 2346.99 |

Entity B:
| title                                                                               | category           | brand   | modelno               | price   |
|:------------------------------------------------------------------------------------|:-------------------|:--------|:----------------------|:--------|
| da-lite tensioned cosmopolitan electrol - projection screen rear motorized - da-tex | projection screens | da-lite | cosmopolitan electrol |         |



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

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

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

Entity A:
| title                                   | category              | brand   | modelno   |   price |
|:----------------------------------------|:----------------------|:--------|:----------|--------:|
| epson america powerlite d6250 projector | electronics - general | epson   | elpd6250  |    1599 |

Entity B:
| title                                      | category         | brand   | modelno    |   price |
|:-------------------------------------------|:-----------------|:--------|:-----------|--------:|
| epson powerlite 1775w projector v11h363020 | video projectors | epson   | v11h363020 | 1135.56 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1471
rtable_id: 20758
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 zx series stereo headphones white | electronics - general | sony    | mdrzx100/whi |   24.88 |

Entity B:
| title                                | category              | brand   | modelno   |   price |
|:-------------------------------------|:----------------------|:--------|:----------|--------:|
| sony mdr-sa5000 dj stereo headphones | home audio crossovers | sony    | mdrsa5000 |  344.88 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1862
rtable_id: 1500
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 - 50 x 50 av format | electronics - general | da-lite |     27628 | 1631.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: 2361
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 |
|:-----------------------------------------------------|:-----------|:------------|:----------|--------:|
| audiosource bi5 5 in-wall construction bracket mount | furniture  | audiosource | bi5       |   25.88 |

Entity B:
| title                                                                  | category                 | brand       | modelno   |   price |
|:-----------------------------------------------------------------------|:-------------------------|:------------|:----------|--------:|
| audio source bc5 new construction bracket in-ceiling 5.25 inches mount | speaker parts components | audiosource | bc5       |   20.68 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 639
rtable_id: 4097
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-tex rear tensioned advantage electrol - hdtv format 184 diagonal | electronics - general | da-lite |     35199 | 4612.99 |

Entity B:
| title                                                                                  | category   | brand   | modelno   | price   |
|:---------------------------------------------------------------------------------------|:-----------|:--------|:----------|:--------|
| da-lite 98813 hc da-mat tensioned cosmopolitan electrol - av format 10 6 x 14 diagonal |            | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 280
rtable_id: 17506
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 |
|:------------------------------------------------------------|:----------------------|:--------|:---------------|--------:|
| evga geforce 8400 gs 1gb ddr3 pci express 2.0 graphics card | electronics - general | evga    | 01g-p3-1302-lr |   44.99 |

Entity B:
| title                                                                      | category       | brand   | modelno        |   price |
|:---------------------------------------------------------------------------|:---------------|:--------|:---------------|--------:|
| evga geforce gt 430 1 gb ddr3 pci-express 2.0 graphics card 01g-p3-1430-lr | graphics cards | evga    | 01g-p3-1430-lr |   55.65 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1893
rtable_id: 13149
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 cosmopolitan electrol - av format 9 x 9 diagonal | electronics - general | da-lite |     81108 | 2500.99 |

Entity B:
| title                                                                              | category           | brand   | modelno   | price   |
|:-----------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| hc cinema perf tensioned cosmopolitan electrol - wide format size wide 94 diagonal | projection screens | da-lite |           |         |



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

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

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

Entity A:
| title                                                         | category                         | brand   |   modelno |   price |
|:--------------------------------------------------------------|:---------------------------------|:--------|----------:|--------:|
| sigma 18-250mm zoom lens for nikon digital slr cameras 880306 | camera and camcorder accessories | sigma   |    880306 |     478 |

Entity B:
| title                                                                    | category      | brand   | modelno   | price   |
|:-------------------------------------------------------------------------|:--------------|:--------|:----------|:--------|
| nikon 35mm f 1.4 g af-s fx swm nikkor lens for nikon digital slr cameras | camera lenses | nikon   | af-s 35mm |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1910
rtable_id: 59
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-tex rear tensioned advantage electrol - hdtv format 184 diagonal | electronics - general | da-lite |     35199 | 4612.99 |

Entity B:
| title                                                                        | category           | brand   | modelno   | price   |
|:-----------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| da-tex rear tensioned advantage electrol - wide format size wide 94 diagonal | projection screens | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 280
rtable_id: 5349
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 |
|:--------------------------------------------------------------|:-----------|:---------|----------:|--------:|
| guardian air step antifatigue polypropylene mat 36 x 60 black | home care  | guardian |  24030502 |   50.97 |

Entity B:
| title                                                                           | category            | brand    | modelno   | price   |
|:--------------------------------------------------------------------------------|:--------------------|:---------|:----------|:--------|
| guardian 24020300 - flexstep rubber antifatigue mat polypropylene 24 x 36 black | printer accessories | guardian |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2433
rtable_id: 16332
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 |
|:------------------------------------------|:-----------|:---------|:-------------|--------:|
| duracell 16gb class 10 high-speed sd card | usb drives | duracell | du-sd1016g-c |   46.88 |

Entity B:
| title                                                              | category    | brand     | modelno      |   price |
|:-------------------------------------------------------------------|:------------|:----------|:-------------|--------:|
| duracell high speed 8 gb class 10 secure digital card du-sd1008g-c | blank media | dane-elec | du-sd1008g-c |    16.9 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 474
rtable_id: 1225
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 |
|:---------------------------------|:----------------------|:--------|:----------|--------:|
| ilive iphone alarm clock speaker | electronics - general | ilive   | isp191b   |   42.88 |

Entity B:
| title                                                                 | category        | brand   | modelno   |   price |
|:----------------------------------------------------------------------|:----------------|:--------|:----------|--------:|
| ilive isp191b app-enhanced speaker with rotating dock for iphone ipod | speaker systems | ilive   | isp191b   |   31.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 426
rtable_id: 14868
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 |
|:-------------------------------------------------|:----------------------|:--------|:----------|--------:|
| bic round stic grip ball pen blue 1 dozen 3-pack | electronics - general |         |           |    4.53 |

Entity B:
| title                                                              | category                | brand   | modelno   |   price |
|:-------------------------------------------------------------------|:------------------------|:--------|:----------|--------:|
| bic corp. round stic grip ballpoint stick pen black ink fine dozen | audio video accessories | bic     |           |    6.06 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 969
rtable_id: 21637
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 color laserjet 4600 smart print cartridge magenta | printers   | hp      | c9723a    |  234.84 |

Entity B:
| title                                        | category            | brand   | modelno   |   price |
|:---------------------------------------------|:--------------------|:--------|:----------|--------:|
| hp laserjet 36a black print cartridge cb436a | laser printer toner | hp      | cb436a    |    54.2 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2002
rtable_id: 4966
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 - 50 x 50 av format | electronics - general | da-lite |     27628 | 1631.99 |

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



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

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

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

Entity A:
| title                             | category              | brand      | modelno       |   price |
|:----------------------------------|:----------------------|:-----------|:--------------|--------:|
| case logic 10 tablet sleeve black | electronics - general | case logic | lapst110black |      16 |

Entity B:
| title                                                    | category   | brand      | modelno       |   price |
|:---------------------------------------------------------|:-----------|:-----------|:--------------|--------:|
| case logic laps-117 17 - 17.3 - inch laptop sleeve black | bags cases | case logic | laps-117black |   19.44 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 507
rtable_id: 12600
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 |
|:---------------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| universal pressboard classification folder legal box of 10 red | stationery & office machinery |         |     82007 |   47.84 |

Entity B:
| title                                                                                                 | category            | brand   | modelno   |   price |
|:------------------------------------------------------------------------------------------------------|:--------------------|:--------|:----------|--------:|
| new-smead 19075 - pressboard classification folders wself tab legal six-section red 10 box - smd19075 | laminating supplies | smead   |           |      76 |



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

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

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

Entity A:
| title                                    | category        | brand   | modelno     |   price |
|:-----------------------------------------|:----------------|:--------|:------------|--------:|
| belkin sport armband for ipod nano black | mp3 accessories | belkin  | f8z514tt064 |   18.88 |

Entity B:
| title                                          | category   | brand   | modelno   | price   |
|:-----------------------------------------------|:-----------|:--------|:----------|:--------|
| belkin dual-fit armband for ipod nano 4g black | armbands   | belkin  | f8z377-kg |         |



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

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

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

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

Entity B:
| title                                      | category           | brand   | modelno   |   price |
|:-------------------------------------------|:-------------------|:--------|:----------|--------:|
| epson t009201 stylus photo color cartridge | inkjet printer ink | epson   | t009201   |   25.87 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 65
rtable_id: 9141
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 16gb class 4 sd memory card | usb drives | sony    | sf16n4/tqp |       0 |

Entity B:
| title                                             | category     | brand   | modelno        |   price |
|:--------------------------------------------------|:-------------|:--------|:---------------|--------:|
| wintec filemate 16 gb class 4 microsd memory card | memory cards | wintec  | 3fmusdck16gb-r |   34.65 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1853
rtable_id: 20767
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 |
|:-----------------------------------------------------------------|:----------------|:--------|:----------|--------:|
| scosche fptm mirrored screen protector kit for ipod touch 4g 2pk | mp3 accessories | scosche | fptm      |   21.88 |

Entity B:
| title                                                                         | category   | brand   | modelno   |   price |
|:------------------------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| scosche metallikase case and mirror screen protector for ipod touch 4g chrome | cases      | scosche | it4mc     |    5.66 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2091
rtable_id: 9592
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 |
|:--------------------------------------|:----------------------|:--------|:----------|--------:|
| los angeles lakers iphone 3g duo case | electronics - general | tribeca | fva4005   |   24.99 |

Entity B:
| title                                       | category              | brand   | modelno   |   price |
|:--------------------------------------------|:----------------------|:--------|:----------|--------:|
| los angeles dodgers pink iphone 4 hard case | computers accessories | tribeca |           |   29.99 |



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

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

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

Entity A:
| title                                               | category   | brand     | modelno   |   price |
|:----------------------------------------------------|:-----------|:----------|:----------|--------:|
| gear head 2.4 ghz wireless optical nano mouse black | mice       | gear head | mp2800blk |   15.82 |

Entity B:
| title                                                | category   | brand     | modelno   |   price |
|:-----------------------------------------------------|:-----------|:----------|:----------|--------:|
| gear head 2.4 ghz wireless touch nano mouse mp3500wt | mice       | gear head | mp3500wt  |   28.23 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1242
rtable_id: 15031
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 4gb sd card class 6 high capacity sdhc 4 gb | usb drives | v7      | vasdh4gcl6r-1n |    7.98 |

Entity B:
| title                                                        | category     | brand   | modelno        |   price |
|:-------------------------------------------------------------|:-------------|:--------|:---------------|--------:|
| v7 4gb sd card secure digital high capacity 4 gb memory card | memory cards | v7      | vasdh4gcl4r-1n |    9.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1297
rtable_id: 5268
label: 0