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 |
|:-----------------------------------------------------------------------------|:------------------------------|:--------------------|----------:|--------:|
| tops second nature subject wire notebook college rule 6 x 9-1 2 we 80 sheets | stationery & office machinery | tops business forms |     74109 |    5.54 |

Entity B:
| title                                                                                | category                       | brand   | modelno   |   price |
|:-------------------------------------------------------------------------------------|:-------------------------------|:--------|:----------|--------:|
| tops 74112 - second nature subject wirebound notebook quadrille rule ltr we 80-sheet | storage presentation materials | tops    |           |    24.3 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1455
rtable_id: 17224
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 acid-free poly folder 2 fasteners 1 3 cut top tab letter manila 24 box | stationery & office machinery |         |     10545 |   42.94 |

Entity B:
| title                                                                                      | category            | brand   | modelno   | price   |
|:-------------------------------------------------------------------------------------------|:--------------------|:--------|:----------|:--------|
| smead 10510 - tear moisture-resist poly file folders 1 3 cut top tab letter manila 12 pack | printer accessories | smead   |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1689
rtable_id: 17634
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 |
|:---------------------------------------------------------|:----------------------|:----------|:------------|--------:|
| panasonic ergofit inner ear headphones white rp-hje450-w | electronics - general | panasonic | rp-hje450-w |   43.88 |

Entity B:
| title                                                     | category   | brand     | modelno     |   price |
|:----------------------------------------------------------|:-----------|:----------|:------------|--------:|
| panasonic rp-hje350-p slimz in-ear earbud headphones pink | headphones | panasonic | rp-hje350-p |   17.19 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 253
rtable_id: 7758
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 - 36 x 48 video format | electronics - general | da-lite |     27559 | 1630.99 |

Entity B:
| title                                                                     | category           | brand   | modelno   |   price |
|:--------------------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| da-lite fast-fold deluxe screen system - projection screen - 4 3 - da-mat | projection screens | da-lite |           |  529.25 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1605
rtable_id: 8236
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 |
|:----------------------------------------------|:-----------|:----------|:---------------|--------:|
| ep 16gb usb 2.0 mobile swingdrive flash drive | usb drives | ep memory | epsw/16gb -2.0 |   29.84 |

Entity B:
| title                               | category         | brand   |   modelno |   price |
|:------------------------------------|:-----------------|:--------|----------:|--------:|
| maxell onyx 4gb usb 2.0 flash drive | usb flash drives | maxell  |    503051 |    8.88 |



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

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

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

Entity A:
| title                       | category   | brand   | modelno   |   price |
|:----------------------------|:-----------|:--------|:----------|--------:|
| canon cli-226 cyan ink tank | printers   | canon   | 4547b001  |   13.97 |

Entity B:
| title                        | category           | brand   | modelno   |   price |
|:-----------------------------|:-------------------|:--------|:----------|--------:|
| canon cli-221 ink tank black | inkjet printer ink | canon   | 2946b001  |   12.11 |



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

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

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

Entity A:
| title                                                     | category              | brand   | modelno   |   price |
|:----------------------------------------------------------|:----------------------|:--------|:----------|--------:|
| ihome portable stereo alarm clock with ipod dock gunmetal | electronics - general | ihome   | ih16g     |   49.73 |

Entity B:
| title                                                            | category        | brand   | modelno   |   price |
|:-----------------------------------------------------------------|:----------------|:--------|:----------|--------:|
| ihome ip48 portable stereo alarm clock for ipod and iphone black | speaker systems | ihome   | ip48bv    |   76.73 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 514
rtable_id: 19852
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 |
|:----------------------------------------|:----------------------|:--------|:-------------|--------:|
| mustang 92 manual screen in matte white | electronics - general | mustang | sc-m92d16 :9 |     104 |

Entity B:
| title                                                    | category           | brand          |   modelno |   price |
|:---------------------------------------------------------|:-------------------|:---------------|----------:|--------:|
| 70inx70in model b manual screen wall ceiling matte white | projection screens | da-lite screen |     40188 |   54.54 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2526
rtable_id: 15969
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 5 expansion end tab file pockets w tyvek straight letter manila 10 box | stationery & office machinery |         |     75174 |   37.94 |

Entity B:
| title                                                                                | category   | brand   | modelno   |   price |
|:-------------------------------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| smead 73502 - expansion drop front file pockets straight tab poly letter green 4 box |            | smead   |           |   19.44 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1338
rtable_id: 11524
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 studio lx 1 tb firewire 800 usb 2.0 desktop external hard drive aluminum | external hard drives | western digital | wdbach0010hal-nesn |  119.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 429
rtable_id: 3275
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 drivestation axis 1.5 tb usb 2.0 desktop external hard drive with buffalo tools and turbo pc hd-lb1 .5 tu2 black | hard drives | buffalo technology | hd-lb1 .5 tu2 |  101.82 |

Entity B:
| title                                                                                                   | category             | brand              | modelno        |   price |
|:--------------------------------------------------------------------------------------------------------|:---------------------|:-------------------|:---------------|--------:|
| buffalo technology drivestation datavault 1 tb usb 2.0 desktop external hard drive hd-cxt1 .0 tu2 black | external hard drives | buffalo technology | hd-cxt1 .0 tu2 |      91 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1129
rtable_id: 20078
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 |
|:---------------------|:----------------|:--------|:----------|--------:|
| rca cassette adapter | mp3 accessories | rca     | ah760r    |   12.88 |

Entity B:
| title                             | category    | brand   | modelno   | price   |
|:----------------------------------|:------------|:--------|:----------|:--------|
| rca vca115 vhs-c cassette adapter | blank media | rca     | vca115    |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2488
rtable_id: 11658
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 4.7 gb 16x dvd-r whilte inkjet printable 50 packs spindle disc | mp3 accessories | verbatim |     95079 |   16.14 |

Entity B:
| title                                                                                    | category    | brand    |   modelno |   price |
|:-----------------------------------------------------------------------------------------|:------------|:---------|----------:|--------:|
| verbatim dvd-r 4.7 gb 8x datalifeplus white thermal printable hub printable 50pk spindle | dvd r discs | verbatim |     94853 |      19 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2237
rtable_id: 13278
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 |
|:------------------------------------------------------|:----------------------|:--------|:---------------------|--------:|
| asus radeon hd5570 1gb ddr5 pci express graphics card | electronics - general | asus    | eah5770 cucore/g/2di |  180.41 |

Entity B:
| title                                                                       | category       | brand              | modelno   |   price |
|:----------------------------------------------------------------------------|:---------------|:-------------------|:----------|--------:|
| diamond amd radeon hd 6670 1gb gddr5 pci-express graphics card dvi hdmi vga | graphics cards | diamond multimedia | 6670pe51g |   122.5 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2475
rtable_id: 14392
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 |
|:-------------------------------------------|:------------|:--------|:----------|--------:|
| atrend-bbox a361-12cp b box series speaker | car stereos | atrend  | a361-12cp |   56.88 |

Entity B:
| title                                                                                             | category         | brand       | modelno   |   price |
|:--------------------------------------------------------------------------------------------------|:-----------------|:------------|:----------|--------:|
| atrend-bbox a362-12cp b box series dual speakers for ford f150 super crew cab 2009 and up 12-inch | coaxial speakers | atrend-bbox | a362-12cp |   88.85 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 614
rtable_id: 5969
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 |
|:---------------------------------------|:----------------------|:--------|------------:|--------:|
| genius luxemate t810 wireless keyboard | electronics - general | genius  | 31340145100 |   89.99 |

Entity B:
| title                                         | category              | brand   |     modelno |   price |
|:----------------------------------------------|:----------------------|:--------|------------:|--------:|
| genius luxemate i200 compact stylish keyboard | keyboard mouse combos | genius  | 31310042101 |   18.86 |



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

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

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

Entity A:
| title                                                                            | category              | brand   |   modelno |   price |
|:---------------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite dual vision tensioned cosmopolitan electrol - av format 10 x 10 diagonal | electronics - general | da-lite |     84992 | 2735.99 |

Entity B:
| title                                                                                     | category           | brand   | modelno               | price   |
|:------------------------------------------------------------------------------------------|:-------------------|:--------|:----------------------|:--------|
| da-lite tensioned cosmopolitan electrol - projection screen motorized - 1 1 - dual vision | projection screens | da-lite | cosmopolitan electrol |         |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 932
rtable_id: 2813
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 |
|:--------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| lexmark extra high yield return pgm print cartridge - magenta | printers   | lexmark | c782u1mg  |  214.88 |

Entity B:
| title                                                                               | category            | brand   | modelno   |   price |
|:------------------------------------------------------------------------------------|:--------------------|:--------|:----------|--------:|
| lexmark c544x1mg magenta toner cartridge extra high yield return prog for c544 x544 | laser printer toner | lexmark | c544x1mg  |  121.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 495
rtable_id: 8804
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 |
|:----------------------------------------------|:------------|:--------|:----------|--------:|
| hitachi 500gb touro mobile usb 2.0 hard drive | hard drives | hitachi | 0s03121   |   64.98 |

Entity B:
| title                                                                  | category             | brand   | modelno         |   price |
|:-----------------------------------------------------------------------|:---------------------|:--------|:----------------|--------:|
| hitachi touro mobile750 gb usb 2.0 external hard drive htolmxna7501abb | external hard drives | hitachi | htolmxna7501abb |   69.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 411
rtable_id: 19599
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 |
|:------------------------------------|:-----------|:--------|:----------|--------:|
| logitech wireless mouse m310 bundle | computers  |         |           |   29.88 |

Entity B:
| title                                                | category   | brand    | modelno    |   price |
|:-----------------------------------------------------|:-----------|:---------|:-----------|--------:|
| logitech wireless mouse m305 vivid violet 910-002469 | mice       | logitech | 910-002469 |   19.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 889
rtable_id: 14668
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 - 84 x 84 av format | electronics - general | da-lite |     27650 | 4958.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2389
rtable_id: 20125
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 750gb usb 3.0 portable external hard drive | hard drives | iosafe  | pa70750u1yr |  139.98 |

Entity B:
| title                                                                  | category   | brand    |   modelno |   price |
|:-----------------------------------------------------------------------|:-----------|:---------|----------:|--------:|
| verbatim acclaim 500 gb usb 2.0 portable external hard drive 97184 red |            | verbatim |     97184 |   69.24 |



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

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

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

Entity A:
| title                                       | category   | brand   | modelno      |   price |
|:--------------------------------------------|:-----------|:--------|:-------------|--------:|
| netgear prosafe plus 8-port ethernet switch | networking | netgear | gs108e100nas |   78.88 |

Entity B:
| title                                                   | category   | brand   | modelno   |   price |
|:--------------------------------------------------------|:-----------|:--------|:----------|--------:|
| netgear jfs516 16-port fast ethernet switch 10 100 mbps | switches   | netgear | jfs516na  |   72.16 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2119
rtable_id: 2684
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 |
|:-----------------------------------------------|:------------------------------|:-------------|:----------|--------:|
| wilson jones wallet file letter recycled kraft | stationery & office machinery | wilson jones |           |    6.09 |

Entity B:
| title                                                      | category   | brand        | modelno   | price   |
|:-----------------------------------------------------------|:-----------|:-------------|:----------|:--------|
| wilson jones wcc7204rk - wallet file letter recycled kraft |            | wilson jones |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1417
rtable_id: 7248
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 |
|:------------------------|:-----------|:---------|----------:|--------:|
| lyoto machida mouse pad | mice       | wincraft |  86210010 |   16.99 |

Entity B:
| title                                          | category   | brand    |   modelno |   price |
|:-----------------------------------------------|:-----------|:---------|----------:|--------:|
| ufc mixed martial arts lyoto machida mouse pad | mouse pads | wincraft |  86210010 |    9.06 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2266
rtable_id: 13318
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 silver matte model c manual screen - 6 x 8 av format | electronics - general | da-lite |     90543 |  420.45 |

Entity B:
| title                                                                         | category           | brand   | modelno   |   price |
|:------------------------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| video spectra 1.5 model c manual screen - av format - 6 x8 - 8 x10 size 6 x 8 | projection screens | da-lite |           |  293.95 |



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

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

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

Entity A:
| title                                                                       | category              | brand   |   modelno |   price |
|:----------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite pearlescent tensioned advantage electrol - av format 6 x 8 diagonal | electronics - general | da-lite |     84381 | 2532.99 |

Entity B:
| title                                                                                           | category           | brand   | modelno            | price   |
|:------------------------------------------------------------------------------------------------|:-------------------|:--------|:-------------------|:--------|
| da-lite tensioned advantage electrol - projection screen motorized - 92 in - 16 9 - pearlescent | projection screens | da-lite | advantage electrol |         |



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

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

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

Entity A:
| title                                                               | category              | brand   | modelno   |   price |
|:--------------------------------------------------------------------|:----------------------|:--------|:----------|--------:|
| ihome app-friendly rechargeable speaker system for ipad iphone ipod | electronics - general | ihome   | id9s      |   99.99 |

Entity B:
| title                                                                                   | category        | brand   | modelno   |   price |
|:----------------------------------------------------------------------------------------|:----------------|:--------|:----------|--------:|
| ihome idm12bc rechargeable portable bluetooth speaker system for ipod ipad iphone black | speaker systems | ihome   | idm12bc   |   62.12 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1155
rtable_id: 4919
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 12a8425 black high-yield toner print cartridge | printers   | lexmark | 12a8425   |   302.4 |

Entity B:
| title                                                                    | category            | brand    | modelno   |   price |
|:-------------------------------------------------------------------------|:--------------------|:---------|:----------|--------:|
| ld compatible high yield black laser toner cartridge for lexmark 12a5845 | laser printer toner | 4inkjets |           |   74.99 |



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

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

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

Entity A:
| title                                                   | category              | brand   | modelno   |   price |
|:--------------------------------------------------------|:----------------------|:--------|:----------|--------:|
| targus zierra case for blackberry playbook tablet black | electronics - general | targus  | thz053us  |   55.88 |

Entity B:
| title                                  | category   | brand      | modelno       |   price |
|:---------------------------------------|:-----------|:-----------|:--------------|--------:|
| blackberry playbook 7-inch tablet 32gb | tablets    | blackberry | prd-38548-002 |     532 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 182
rtable_id: 15919
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 |
|:------------------------------------------------------|:----------------------|:--------|:-------------|--------:|
| msi ati radeon hd6670 1gb ddr5 pci-express video card | electronics - general | msi     | r6670-md1gd5 |     107 |

Entity B:
| title                                                                                      | category       | brand   | modelno    |   price |
|:-------------------------------------------------------------------------------------------|:---------------|:--------|:-----------|--------:|
| xfx ati radeon hd4350 1 gb ddr2 vga dvi hdmi low profile pci-express video card hd435xznh2 | graphics cards | xfx     | hd435xznh2 |   46.24 |



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

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

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

Entity A:
| title                                              | category              | brand   | modelno         |   price |
|:---------------------------------------------------|:----------------------|:--------|:----------------|--------:|
| v7 25 cat6 snagless molded network patch cable red | electronics - general | v7      | v7n2c6-25f-reds |    9.76 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1284
rtable_id: 9323
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 |
|:---------------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| c-line top-load poly sheet protectors heavy gauge letter 200ct | stationery & office machinery |         |     62097 |   28.94 |

Entity B:
| title                                                                               | category                       | brand   | modelno   | price   |
|:------------------------------------------------------------------------------------|:-------------------------------|:--------|:----------|:--------|
| avery 74171 - multi-page top-load sheet protectors heavy gauge letter clear 25 pack | storage presentation materials | avery   |           |         |



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

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

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

Entity A:
| title                                                            | category                      | brand    | modelno   |   price |
|:-----------------------------------------------------------------|:------------------------------|:---------|:----------|--------:|
| innovera d3010 black compatible high-yield toner print cartridge | stationery & office machinery | innovera | d3010     |   68.35 |

Entity B:
| title                                                                 | category           | brand   | modelno   |   price |
|:----------------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| compatible dell 1815dn laser printer high yield black toner cartridge | inkjet printer ink | dell    |           |   26.82 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 337
rtable_id: 20654
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 screen care kit for ipad | mp3 accessories | griffin technology | gb01595   |   24.56 |

Entity B:
| title                                 | category                        | brand              | modelno   |   price |
|:--------------------------------------|:--------------------------------|:-------------------|:----------|--------:|
| griffin technology wavestand for ipad | touch screen tablet accessories | griffin technology | gc16043   |   11.78 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1010
rtable_id: 1087
label: 0