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 |
|:---------------------------------------------------------|:------------|:--------|:------------|--------:|
| iosafe rugged 250gb usb 3.0 portable external hard drive | hard drives | iosafe  | pa50250u5yr |  249.99 |

Entity B:
| title                                                                                               | category              | brand   |   modelno |   price |
|:----------------------------------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| lacie rugged all-terrain 1 tb firewire 800 firewire 400 usb 2.0 portable external hard drive 301924 | computers accessories | lacie   |    301924 |     199 |



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

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

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

Entity A:
| title                                                         | category        | brand    |   modelno |   price |
|:--------------------------------------------------------------|:----------------|:---------|----------:|--------:|
| verbatim 100-pack 16x datalifeplus shiny silver dvd-r spindle | mp3 accessories | verbatim |     97017 |   29.98 |

Entity B:
| title                                                                                                      | category    | brand    |   modelno |   price |
|:-----------------------------------------------------------------------------------------------------------|:------------|:---------|----------:|--------:|
| verbatim 97017 4.7 gb up to 16x datalifeplus shiny silver recordable disc dvd-r 100-disc spindle tape wrap | dvd-r discs | verbatim |     97017 |   29.89 |



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

Entity B:
| title                                           | category           | brand    | modelno   |   price |
|:------------------------------------------------|:-------------------|:---------|:----------|--------:|
| innovera 7970 compatible ink 800 page-yield red | inkjet printer ink | innovera |           |    19.7 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1850
rtable_id: 6903
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 unframed rear projection screen - 84 x 84 av format | electronics - general | da-lite |     27503 | 3561.99 |

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



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

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

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

Entity A:
| title                                                         | category        | brand    |   modelno |   price |
|:--------------------------------------------------------------|:----------------|:---------|----------:|--------:|
| verbatim 10-pack 50gb 6x blu-ray double layer recordable disc | mp3 accessories | verbatim |     97335 |   94.88 |

Entity B:
| title                                                                               | category    | brand    |   modelno |   price |
|:------------------------------------------------------------------------------------|:------------|:---------|----------:|--------:|
| verbatim 96577 8.5 gb 2.4x-6x double layer recordable disc dvd r dl 50-disc spindle | dvd r discs | verbatim |     96577 |   47.99 |



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

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

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

Entity A:
| title                                                             | category              | brand   |   modelno |   price |
|:------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-glas deluxe rear projection screen - 50 x 50 av format | electronics - general | da-lite |     27647 | 1919.99 |

Entity B:
| title                                                                              | category           | brand   | modelno   | price   |
|:-----------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| da-lite 27636 da-glas standard rear projection screen 50 1 2 x 67 1 4 video format | projection screens | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 576
rtable_id: 2818
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 porsche design p 9220 500 gb usb 3.0 portable external hard drive 301998 | external hard drives | case logic |    301998 |   96.88 |



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

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

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

Entity A:
| title                                                          | category              | brand     | modelno   |   price |
|:---------------------------------------------------------------|:----------------------|:----------|:----------|--------:|
| microsoft wireless laser desktop 3000 keyboard and mouse combo | electronics - general | microsoft | nud-00001 |   29.82 |

Entity B:
| title                                     | category   | brand     | modelno   |   price |
|:------------------------------------------|:-----------|:----------|:----------|--------:|
| microsoft wireless keyboard 800 2vj-00001 | keyboards  | microsoft | 2vj-00001 |   19.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 572
rtable_id: 8700
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 wn511 rangemax next wireless-n pc-card notebook adapter | networking | netgear | wn511b100nas |   58.88 |

Entity B:
| title                                               | category          | brand   | modelno       |   price |
|:----------------------------------------------------|:------------------|:--------|:--------------|--------:|
| netgear wn511b rangemax wireless-n notebook adapter | chargers adapters | netgear | wn511b-100nas |   11.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1475
rtable_id: 12654
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 |
|:--------------------------------------------|:----------------------|:--------|:----------|--------:|
| incipio smart feather for apple ipad 2 lime | electronics - general | incipio | ipad-228  |   33.25 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1983
rtable_id: 9247
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 |
|:-----------------------------------------------|:----------------|:---------|:-------------------|--------:|
| simplism leather sleeve case for ipad 2 orange | mp3 accessories | simplism | tr-lssipd2-or / en |   44.99 |

Entity B:
| title                                                              | category   | brand   | modelno   |   price |
|:-------------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| sgp ipad ipad 2 leather case illuzion sleeve series solaris orange | cases      | sgp     |           |   59.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 922
rtable_id: 19939
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 |
|:---------------------------------------------------------|:-----------|:----------|:-------------|--------:|
| birdhouse tony hawk 2gb ptero skatedrive usb flash drive | usb drives | ep memory | bh-skthpt/2g |    9.84 |

Entity B:
| title                                                     | category         | brand   | modelno   | price   |
|:----------------------------------------------------------|:-----------------|:--------|:----------|:--------|
| birdhouse tony hawk 16gb ptero skatedrive usb flash drive | usb flash drives | action  |           |         |



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

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

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

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

Entity B:
| title                                                                                       | category        | brand   | modelno          |   price |
|:--------------------------------------------------------------------------------------------|:----------------|:--------|:-----------------|--------:|
| v7 cat5e snagless molded network patch cable rj45 male to male blue 3-feet v7n3c5e-03f-blus | ethernet cables | v7      | v7n3c5e-03f-blus |    1.43 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1342
rtable_id: 5266
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 |
|:-----------------------------------------|:-----------|:----------|:----------|--------:|
| wireless mobile mouse 6000 bluetrack red | mice       | microsoft | mhc-00019 |   29.88 |

Entity B:
| title                                            | category   | brand     | modelno   |   price |
|:-------------------------------------------------|:-----------|:----------|:----------|--------:|
| microsoft wireless mobile mouse 3500 - poppy red | mice       | microsoft | gmf-00013 |   19.99 |



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

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

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

Entity A:
| title                                    | category              | brand              | modelno   |   price |
|:-----------------------------------------|:----------------------|:-------------------|:----------|--------:|
| griffin technology powerjolt plus mobile | electronics - general | griffin technology | gc23073   |   29.99 |

Entity B:
| title                                 | category     | brand              | modelno   |   price |
|:--------------------------------------|:-------------|:-------------------|:----------|--------:|
| griffin gc23073 powerjolt plus mobile | car chargers | griffin technology | gc23073   |   11.25 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1138
rtable_id: 9085
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 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   |
|:---------------------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| heritage walnut veneer model b manual screen with high power fabric - av format size 60 x 60 | projection screens | da-lite |           |         |



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

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

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

Entity A:
| title                                                | category   | brand   | modelno   |   price |
|:-----------------------------------------------------|:-----------|:--------|:----------|--------:|
| hp color laserjet 4600 smart print cartridge magenta | printers   | hp      | c9723a    |  234.84 |

Entity B:
| title                                                        | category          | brand   | modelno   |   price |
|:-------------------------------------------------------------|:------------------|:--------|:----------|--------:|
| hp color laserjet cb390a print cartridge in retail packaging | printer ink toner | hp      | cb390a    |   49.53 |



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

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

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

Entity A:
| title                                                     | category              | brand   | modelno      |   price |
|:----------------------------------------------------------|:----------------------|:--------|:-------------|--------:|
| siig 3.5 sata superspeed usb 3.0 hard drive enclosure pro | electronics - general | siig    | ju-sa0b12-s1 |   41.39 |

Entity B:
| title                                                                                     | category              | brand    | modelno   |   price |
|:------------------------------------------------------------------------------------------|:----------------------|:---------|:----------|--------:|
| aluratek superspeed usb 3.0 2.5-inch 3.5-inch sata hard drive docking enclosure ahddu200f | computers accessories | aluratek | ahddu200f |   34.84 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1223
rtable_id: 2025
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 |
|:-------------------------------------------------|:----------------------|:--------|:----------|--------:|
| michigan wolverines iphone 4 case silicone cover | electronics - general | tribeca | fva3437   |   24.99 |

Entity B:
| title                                       | category              | brand   | modelno   |   price |
|:--------------------------------------------|:----------------------|:--------|:----------|--------:|
| minnesota wild iphone 4 case silicone cover | computers accessories | tribeca |           |   16.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1229
rtable_id: 10821
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 ce505xd black laserjet print cartridges 2pk | printers   | hp      | hp ce505xd |  258.84 |

Entity B:
| title                                                              | category            | brand   | modelno   |   price |
|:-------------------------------------------------------------------|:--------------------|:--------|:----------|--------:|
| hp color laserjet q6470a black print cartridge in retail packaging | laser printer toner | hp      | q6470a    |  115.71 |



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

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

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

Entity A:
| title                                                        | category   | brand   | modelno    |   price |
|:-------------------------------------------------------------|:-----------|:--------|:-----------|--------:|
| edge 8gb 4x2gb pc38500 ecc unbuffered 240 pin ddr3 kit apple | memory     | edge    | pe22177504 |  139.82 |

Entity B:
| title                                           | category            | brand   | modelno   |   price |
|:------------------------------------------------|:--------------------|:--------|:----------|--------:|
| 2gb kit 2x1gb pc3200 ecc unbuffered 184 pin ddr | computer components | edge    | x8006a-pe |  115.05 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 482
rtable_id: 19229
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 |
|:------------------------------------------------|:------------------|:--------|:----------|--------:|
| cobra 16-mile range 22-channel gmrs 2-way radio | walkie-talkie/frs | cobra   | cx-105    |   29.98 |

Entity B:
| title                                                                | category                | brand    | modelno   |   price |
|:---------------------------------------------------------------------|:------------------------|:---------|:----------|--------:|
| motorola mr350r 35-mile range 22-channel frs gmrs two-way radio pair | gmrs-frs two-way radios | motorola | mr350r    |   50.99 |



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

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

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

Entity A:
| title                                                              | category    | brand   |   modelno |   price |
|:-------------------------------------------------------------------|:------------|:--------|----------:|--------:|
| iomega 1tb ego desktop usb 2.0 portable hard drive - midnight blue | hard drives | iomega  |     34837 |   89.98 |

Entity B:
| title                                                                    | category              | brand   |   modelno |   price |
|:-------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| iomega ego helium 1 tb usb 2.0 portable external hard drive 34820 silver | computers accessories | iomega  |     34820 |  124.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1979
rtable_id: 14826
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 |
|:------------------------------------------|:-----------|:--------|:-------------|--------:|
| oki 43502001 type 9 black toner cartridge | printers   | oki     | 4.3502001 e7 |      98 |

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: 925
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 |
|:--------------------------------------------------------|:------------|:----------|:----------|--------:|
| clickfree c2 500gb usb 3.0 portable external hard drive | hard drives | clickfree | hd527b3   |   84.98 |

Entity B:
| title                                                            | category              | brand   | modelno            |   price |
|:-----------------------------------------------------------------|:----------------------|:--------|:-------------------|--------:|
| hewlett packard hp portable 1 tb usb 3.0 2.0 external hard drive | external data storage | hp      | wdbacz0010bbk-nesn |   89.99 |



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

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

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

Entity A:
| title                                                     | category    | brand   | modelno          |   price |
|:----------------------------------------------------------|:------------|:--------|:-----------------|--------:|
| samsung s2 640gb usb 3.0 portable external hard drive red | hard drives | samsung | hx-mta64da / g42 |   78.88 |

Entity B:
| title                                                                           | category             | brand   | modelno           |   price |
|:--------------------------------------------------------------------------------|:---------------------|:--------|:------------------|--------:|
| seagate expansion 250 gb usb 2.0 portable external hard drive st902504exa101-rk | external hard drives | seagate | st902504exa101-rk |   44.99 |



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

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

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

Entity A:
| title                                                                        | category              | brand   | modelno      |   price |
|:-----------------------------------------------------------------------------|:----------------------|:--------|:-------------|--------:|
| vantec nexstar3 superspeed 2.5 sata to usb 3.0 external hard drive enclosure | electronics - general | vantec  | nst-280s3-bk |   26.62 |

Entity B:
| title                                                                                                 | category              | brand   | modelno      |   price |
|:------------------------------------------------------------------------------------------------------|:----------------------|:--------|:-------------|--------:|
| vantec nexstar sx nst-285u2-bk 2.5-inch ide to usb 2.0 external hard drive enclosure onyx black black | hard drive enclosures | vantec  | nst-285u2-bk |   14.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2255
rtable_id: 10077
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 dvidsmm20 20ft dvi-d digital video cable | electronics - general | startech | dvidsmm20 |   27.88 |

Entity B:
| title                                                          | category    | brand    | modelno   |   price |
|:---------------------------------------------------------------|:------------|:---------|:----------|--------:|
| startech.com hdmimm30 30 feet hdmi to hdmi digital video cable | hdmi cables | startech | hdmimm30  |   43.24 |



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

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

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

Entity A:
| title                                                                                       | category   | brand              | modelno    |   price |
|:--------------------------------------------------------------------------------------------|:-----------|:-------------------|:-----------|--------:|
| buffalo technology linkstation duo 1 tb 2 x 500 gb network attached storage ls-wx1 .0 tl r1 | networking | buffalo technology | lswx10tlr1 |  192.63 |

Entity B:
| title                                                                                         | category                 | brand              | modelno      |   price |
|:----------------------------------------------------------------------------------------------|:-------------------------|:-------------------|:-------------|--------:|
| buffalo technology linkstation live 1.0 tb shared network attached storage ls-ch1 .0 tl black | network attached storage | buffalo technology | ls-ch1 .0 tl |   99.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1761
rtable_id: 4578
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 stainless steel permanent marker fine tip black | stationery & office machinery | sharpie |   1747388 |    7.94 |

Entity B:
| title                                                              | category   | brand   | modelno   |   price |
|:-------------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| sharpie 1735792 - retractable ultra fine tip permanent marker blue | headphones | sharpie |           |   20.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1453
rtable_id: 16633
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 - 96 x 96 av format | electronics - general | da-lite |     27557 | 6426.99 |

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



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

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

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

Entity A:
| title                                            | category                      | brand   | modelno   |   price |
|:-------------------------------------------------|:------------------------------|:--------|:----------|--------:|
| 3m dry-erase board porcelain 8 x4 aluminum frame | stationery & office machinery | 3m      |           |  707.59 |

Entity B:
| title                                                                                        | category   | brand   | modelno   |   price |
|:---------------------------------------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| new-quartet 2544 - magnetic dry-erase board porcelain 48 x 36 white aluminum frame - qrt2544 | radios     | quartet |           |     371 |



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

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

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

Entity A:
| title                                     | category              | brand   | modelno   |   price |
|:------------------------------------------|:----------------------|:--------|:----------|--------:|
| sabrent 32 usb 2.0 active extension cable | electronics - general | sabrent | cb-usbxt  |   13.88 |

Entity B:
| title                                                                                | category   | brand   | modelno   |   price |
|:-------------------------------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| sabrent cb-usbxt usb 2.0 type a male to type a female active extension cable 32 feet | usb cables | sabrent | cb-usbxt  |   16.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1653
rtable_id: 1649
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 thru-the-wall rear projection screen - 81 x 108 video format | electronics - general | da-lite |     23096 |   10049 |

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



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

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

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

Entity A:
| title                                                     | category              | brand   | modelno    |   price |
|:----------------------------------------------------------|:----------------------|:--------|:-----------|--------:|
| xfx ati radeon 5670 hd pci-express 1gb ddr3 graphics card | electronics - general | xfx     | hd567xznl3 |   91.88 |

Entity B:
| title                                                                                   | category              | brand   | modelno    |   price |
|:----------------------------------------------------------------------------------------|:----------------------|:--------|:-----------|--------:|
| xfx ati radeon hd 5670 1 gb ddr5 dvi hdmi displayport pci-express video card hd567xznf3 | computers accessories | xfx     | hd567xznf3 |   79.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1931
rtable_id: 1258
label: 0