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 |
|:-----------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| 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-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: 2504
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 |
|:-----------------------------------------------------------|:----------------------|:--------|:----------|--------:|
| cta mini battery chargers for nikon en-el9 digital cameras | electronics - general | cta     | mr-enel9  |   15.98 |

Entity B:
| title                                      | category         | brand   |   modelno |   price |
|:-------------------------------------------|:-----------------|:--------|----------:|--------:|
| kodak k7700 digital camera battery charger | battery chargers | kodak   |   1165448 |   21.74 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1340
rtable_id: 19293
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 |
|:--------------------------------------------------------------------------------------------------|:-----------|:--------|:----------------|--------:|
| corsair cm2x2048-6400c5 xms2 2gb pc2-6400 800mhz 240-pin ddr2 cl5 dual channel desktop memory kit | memory     | corsair | cm2x2048-6400c5 |   40.82 |

Entity B:
| title                                                                                                | category            | brand   | modelno           |   price |
|:-----------------------------------------------------------------------------------------------------|:--------------------|:--------|:------------------|--------:|
| corsair xms2 4 gb 2 x 2 gb pc2-6400 800 mhz 240-pin ddr2 dual-channel memory kit - twin2x4096-6400c5 | computer components | corsair | twin2x4096-6400c5 |   39.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 599
rtable_id: 21543
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 |
|:-------------------------------------------------------|:------------------------------|:--------|:----------|--------:|
| s j paper pressboard end tab classification folder red | stationery & office machinery |         | s60433    |    5.48 |

Entity B:
| title                                                                                       | category            | brand     | modelno   | price   |
|:--------------------------------------------------------------------------------------------|:--------------------|:----------|:----------|:--------|
| s j paper s59720 - mla end tab classification folder straight tab letter six-section 25 box | printer accessories | s j paper |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1647
rtable_id: 18512
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 |
|:---------------------------------------------------------|:------------|:--------|:------------|--------:|
| iosafe rugged 500gb usb 3.0 portable external hard drive | hard drives | iosafe  | pa50500u5yr |  299.98 |

Entity B:
| title                                                                                                 | category             | brand   |   modelno | price   |
|:------------------------------------------------------------------------------------------------------|:---------------------|:--------|----------:|:--------|
| lacie rugged all-terrain 500 gb firewire 800 firewire 400 usb 2.0 portable external hard drive 301371 | external hard drives | lacie   |    301371 |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1927
rtable_id: 14743
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 20 displayport cable with latches m m | electronics - general | startech | displport20l |      44 |

Entity B:
| title                                                                  | category             | brand    | modelno      |   price |
|:-----------------------------------------------------------------------|:---------------------|:---------|:-------------|--------:|
| startech.com 15-feet displayport cable with latches - m m displport15l | cables interconnects | startech | displport15l |   23.48 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1897
rtable_id: 11444
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 |
|:----------------------------------|:-----------|:--------|:----------|--------:|
| ibm 28p2010 black toner cartridge | printers   | ibm     | 28p2010   |     425 |

Entity B:
| title                           | category            | brand   | modelno   |   price |
|:--------------------------------|:--------------------|:--------|:----------|--------:|
| canon 104 black toner cartridge | laser printer toner | canon   | 0263b001a |   64.06 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1405
rtable_id: 5936
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 - 58 x 104 hdtv format | electronics - general | da-lite |     27571 | 4629.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2220
rtable_id: 14687
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 x651h11a high-yield toner 25000 page-yield black | printers   | lexmark | x651h11a  |   565.2 |

Entity B:
| title                                | category            | brand   | modelno             |   price |
|:-------------------------------------|:--------------------|:--------|:--------------------|--------:|
| cltk409s toner 1500 page-yield black | laser printer toner | samsung | samsung clx 3175n , |   49.92 |



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

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

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

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

Entity B:
| title                                                                      | category           | brand   | modelno   | price   |
|:---------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| da-lite 27660 da-glas deluxe rear projection screen - 72 x 96 video format | projection screens | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2332
rtable_id: 20429
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 |
|:----------------------------------------|:-----------|:--------|:----------|--------:|
| kingwin mobile rack storage bay adapter | networking | kingwin | kf-251-bk |   27.88 |

Entity B:
| title                                              | category         | brand   | modelno      | price   |
|:---------------------------------------------------|:-----------------|:--------|:-------------|:--------|
| kingwin kf-101-ipf-b - storage bay adapter - black | usb flash drives | kingwin | kf-101-ipf-b |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1928
rtable_id: 10795
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 |
|:----------------------------------------|:-----------|:--------|:----------|--------:|
| crown ecostep mat 36 x 60 midnight blue | home care  | crown   | et0035mb  |   59.97 |

Entity B:
| title                                         | category            | brand   | modelno   | price   |
|:----------------------------------------------|:--------------------|:--------|:----------|:--------|
| crown et0035ch - ecostep mat 36 x 60 charcoal | connectors adapters | crown   |           |         |



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

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

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

Entity A:
| title                                                                   | category              | brand   |   modelno |   price |
|:------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite matte white deluxe model b manual screen - 60 x 80 video format | electronics - general | da-lite |     74698 |  188.99 |

Entity B:
| title                                                                             | category           | brand   | modelno   |   price |
|:----------------------------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| high contrast matte white deluxe model b manual screen - hdtv format size 45 x 80 | projection screens | da-lite |           |  194.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 627
rtable_id: 10489
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-s2 dual 3.5-inch sata to usb 2.0 with jbod external hard drive enclosure black | hard drive enclosures | vantec  | nst-400mx-s2 |   44.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 793
rtable_id: 6031
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 home office series 8-outlet surge protector w coaxial protection | electronics - general | belkin  | be108230-06 |   17.88 |

Entity B:
| title                                                 | category         | brand   | modelno   |   price |
|:------------------------------------------------------|:-----------------|:--------|:----------|--------:|
| belkin surgecube surge protector 1-outlet home series | surge protectors | belkin  | f9h100-cw |    7.84 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1366
rtable_id: 21150
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 73079-01 ac power adapter for telephone headset system | prepaid wireless phones | plantronics | 73079-01  |   14.88 |

Entity B:
| title                                           | category   | brand       | modelno   |   price |
|:------------------------------------------------|:-----------|:------------|:----------|--------:|
| plantronics s12 corded telephone headset system | headsets   | plantronics | 65145-01  |   69.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 761
rtable_id: 21777
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 |
|:----------------------------------------------|:----------------------|:--------|:----------|--------:|
| san diego padres iphone 4 case silicone cover | electronics - general | tribeca | fva3959   |   24.99 |

Entity B:
| title                                                   | category              | brand   | modelno   |   price |
|:--------------------------------------------------------|:----------------------|:--------|:----------|--------:|
| west virginia mountaineers iphone 4 case silicone cover | computers accessories | tribeca |           |   17.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1502
rtable_id: 1628
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 laserjet 53x black print cartridge | printers   | hp      | q7553x    |  164.84 |

Entity B:
| title                                                     | category            | brand   | modelno   |   price |
|:----------------------------------------------------------|:--------------------|:--------|:----------|--------:|
| hp laserjet 42a black print cartridge in retail packaging | laser printer toner | hp      | q5942a    |     125 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2405
rtable_id: 1034
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 video spectra 1.5 model c manual screen - 8 x 10 av format | electronics - general | da-lite |     82967 |  725.99 |

Entity B:
| title                                                                                                       | category           | brand   | modelno           |   price |
|:------------------------------------------------------------------------------------------------------------|:-------------------|:--------|:------------------|--------:|
| da-lite deluxe model b manual wall ceiling projection screen 50 x 67 video format video spectra 1.5 surface | projection screens | da-lite | video spectra 1.5 |  165.31 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2144
rtable_id: 14686
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.com pyo3sata 4in sata power y splitter adapter cable | electronics - general | startech | pyo3sata  |    8.88 |

Entity B:
| title                    | category            | brand   | modelno            |   price |
|:-------------------------|:--------------------|:--------|:-------------------|--------:|
| sata power adapter cable | connectors adapters | molex   | atx-sata-adapter-4 |    2.96 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2319
rtable_id: 14155
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 video spectra 1.5 model b manual screen with csr - 69 x 92 video format | electronics - general | da-lite |     85322 |  429.99 |

Entity B:
| title                                                                                         | category           | brand   | modelno   |   price |
|:----------------------------------------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| da-lite manual 92 diagonal hdtv format home theater wall screen with video spectra 1.5 fabric | projection screens | da-lite |           |  254.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 665
rtable_id: 14691
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 |
|:------------------------------------------------------------------|:-----------|:----------------|:------------|--------:|
| western digital 2tb my book studio edition ii external hard drive | computers  | western digital | wdh2q20000n |     199 |

Entity B:
| title                                                                          | category             | brand           | modelno            |   price |
|:-------------------------------------------------------------------------------|:---------------------|:----------------|:-------------------|--------:|
| western digital my book essential 3 tb usb 3.0 2.0 desktop external hard drive | external hard drives | western digital | wdbacw0030hbk-nesn |  129.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 429
rtable_id: 13255
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 angels of anaheim iphone 4 case silicone cover | electronics - general | tribeca | fva3955   |   24.99 |

Entity B:
| title                                            | category              | brand   | modelno   |   price |
|:-------------------------------------------------|:----------------------|:--------|:----------|--------:|
| michigan wolverines iphone 4 case silicone cover | computers accessories | tribeca |           |   17.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 226
rtable_id: 5842
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 |
|:------------------------------------------------|:--------------|:--------|:----------|--------:|
| xantech 283tpd designer twin plug blink emitter | stereos/audio | xantech | 283tpd    |   14.88 |

Entity B:
| title                                                  | category           | brand   | modelno   |   price |
|:-------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| xantech 283dmw designer blink emitter single mini wire | office electronics | xantech | 283dmw    |   13.09 |



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

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

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

Entity A:
| title                               | category   | brand   | modelno   |   price |
|:------------------------------------|:-----------|:--------|:----------|--------:|
| brother tn360 black toner cartridge | printers   | brother | tn360     |   45.54 |

Entity B:
| title                                          | category            | brand   | modelno   |   price |
|:-----------------------------------------------|:--------------------|:--------|:----------|--------:|
| brother tn360 high yield black toner cartridge | laser printer toner | brother | tn360     |   45.54 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 944
rtable_id: 14177
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 |
|:-----------------------------------------------|:------------------|:--------|:-------------|--------:|
| igo ps00291-0001 keyjuice micro mini usb cable | phone accessories | igo     | ps00291-0001 |    7.88 |

Entity B:
| title                                                | category   | brand   | modelno      |   price |
|:-----------------------------------------------------|:-----------|:--------|:-------------|--------:|
| igo ps00291-0001 keyjuice charger for micro mini usb | chargers   | igo     | ps00291-0001 |    9.12 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 999
rtable_id: 4923
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 |
|:--------------------------------------------------------------------------------------|:----------------------|:--------|:----------|--------:|
| vtech ds6151 2-line expandable cordless phone with digital answering system caller id | electronics - general | vtech   | ds6151    |   62.51 |

Entity B:
| title                                                                                  | category            | brand   | modelno   | price   |
|:---------------------------------------------------------------------------------------|:--------------------|:--------|:----------|:--------|
| vtech ls6425-3 dect 6.0 digital three handset cordless answering system with caller id | cordless telephones | vtech   | ls6425-3  |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 195
rtable_id: 3283
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 |
|:---------------------------------------------------------------------------------------------------------------|:-----------|:--------|:-------------------|--------:|
| corsair xms2 2gb 2 x 1gb pc2-6400 800mhz 240-pin ddr2 cl5 dual channel desktop memory kit - twin2x4096-6400c5c | memory     | corsair | twin2x4096-6400c5c |   72.82 |

Entity B:
| title                                                                                       | category              | brand   | modelno         |   price |
|:--------------------------------------------------------------------------------------------|:----------------------|:--------|:----------------|--------:|
| corsair memory vs8gsdskit800d2 8 gb 2 x 4 gb pc2-6400 800mhz 200-pin ddr2 laptop memory kit | computers accessories | corsair | vs8gsdskit800d2 |  129.99 |



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

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

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

Entity A:
| title                                                                                                       | category              | brand   |   modelno |   price |
|:------------------------------------------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite natural walnut veneer model b manual screen with matte white fabric - 64 x 84 diagonal video format | electronics - general | da-lite |     73197 |  261.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 92
rtable_id: 4739
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 |
|:----------------------------------------------------------|:-----------|:-----------------|:-----------|--------:|
| tp-link network tl-sg1024d 24 port gigabit desktop switch | networking | global marketing | tl-sg1024d |     116 |

Entity B:
| title                                                      | category   | brand   | modelno    |   price |
|:-----------------------------------------------------------|:-----------|:--------|:-----------|--------:|
| tp-link tl-sg1005d 5-port unmanaged gigabit desktop switch | switches   | tp-link | tl-sg1005d |   20.33 |



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

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

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

Entity A:
| title                                                                                            | category        | brand   | modelno   |   price |
|:-------------------------------------------------------------------------------------------------|:----------------|:--------|:----------|--------:|
| kodak 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 m580 14 mp digital camera with 8x wide angle optical zoom and 3.0-inch lcd pink | point shoot digital cameras | kodak   | easyshare m580 pink |  102.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1145
rtable_id: 12847
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 62mm front lens cap | photography - general | sony    | alc-f62a  |       9 |

Entity B:
| title                                 | category   | brand   | modelno   |   price |
|:--------------------------------------|:-----------|:--------|:----------|--------:|
| tamron flc62 62mm front lens cap c1fd | adapters   | tamron  | flc62     |    6.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 265
rtable_id: 21986
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 |
|:-----------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| maccase premium leather 17 macbook pro flight jacket w backpack option | electronics - general | maccase |    155623 |  191.96 |

Entity B:
| title                                                                         | category      | brand   | modelno      |   price |
|:------------------------------------------------------------------------------|:--------------|:--------|:-------------|--------:|
| maccase premium leather ipad ipad 2 flight jacket w backpack option - vintage | cases sleeves | maccase | lpadfj-vn-bp |  199.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 208
rtable_id: 6711
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 wireless router for video and gaming | networking | netgear | wndr37av-100nas |     129 |

Entity B:
| title                                           | category   | brand   | modelno   | price   |
|:------------------------------------------------|:-----------|:--------|:----------|:--------|
| netgear n600 wireless dual band router wndr3400 | routers    | netgear | wndr3400  |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 239
rtable_id: 684
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 27250 - folders straight cut single-ply extended end tab legal manila 100 box | connectors adapters | smead   |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1695
rtable_id: 14272
label: 0