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 |
|:----------------------------------|:-----------|:--------|:----------|--------:|
| ibm 28p2010 black toner cartridge | printers   | ibm     | 28p2010   |     425 |

Entity B:
| title                               | category            | brand   | modelno   |   price |
|:------------------------------------|:--------------------|:--------|:----------|--------:|
| brother tn330 black toner cartridge | laser printer toner | brother | tn330     |   32.47 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1405
rtable_id: 2262
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 diskgo usb 2.0 flash drive silver | usb drives | edge    | pe204198  |   10.98 |

Entity B:
| title                                                                      | category            | brand   | modelno                            |   price |
|:---------------------------------------------------------------------------|:--------------------|:--------|:-----------------------------------|--------:|
| edge diskgo secure guardian flash drive - usb flash drive - 4 gb - usb 2.0 | computer components | edge    | diskgo secure guardian flash drive |   97.11 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1661
rtable_id: 12454
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 10326 - folders 1 2 cut assorted reinforced top tab letter manila 100 box | uninterrupted power supply ups | smead   |           |         |



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

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

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

Entity A:
| title                                                                                    | category        | brand   | modelno   |   price |
|:-----------------------------------------------------------------------------------------|:----------------|:--------|:----------|--------:|
| kodak easyshare m530 red 12mp digital camera w 3x optical zoom 2.7 lcd w 50 bonus prints | digital cameras | kodak   | m530 red  |   99.54 |

Entity B:
| title                                                                                            | category                    | brand   |   modelno |   price |
|:-------------------------------------------------------------------------------------------------|:----------------------------|:--------|----------:|--------:|
| kodak easyshare m583 14 mp digital camera with 8x optical zoom and 3-inch lcd - purple new model | point shoot digital cameras | kodak   |   1596683 |  142.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 688
rtable_id: 871
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 2.5 usb 2.0 to sata hard drive enclosure | electronics - general | siig    | ju-sa0c12-s1 |   12.88 |

Entity B:
| title                                                                            | category              | brand   | modelno   |   price |
|:---------------------------------------------------------------------------------|:----------------------|:--------|:----------|--------:|
| sabrent ata 2.5-inch usb 2.0 sata premium aluminum hard drive enclosure ec-nu25k | computers accessories | sabrent | ec-nu25k  |   12.88 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1096
rtable_id: 16086
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 |
|:----------------------------------------------------------|:------------------------------|:--------|:----------|--------:|
| bic mark-it retractable permanent marker fine red 1-dozen | stationery & office machinery | bic     | pmr11-red |   12.49 |

Entity B:
| title                                                    | category          | brand   | modelno   |   price |
|:---------------------------------------------------------|:------------------|:--------|:----------|--------:|
| san36701 - permanent marker retractable fine point black | printer ink toner | sanford |           |    2.68 |



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

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

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

Entity A:
| title                                                  | category   | brand    | modelno            |   price |
|:-------------------------------------------------------|:-----------|:---------|:-------------------|--------:|
| kingston valueram 2gb ddr3 sdram desktop memory module | memory     | kingston | kvr1333d3ls4r9s/2g |   63.88 |

Entity B:
| title                                                                  | category   | brand    | modelno      |   price |
|:-----------------------------------------------------------------------|:-----------|:---------|:-------------|--------:|
| kingston valueram 1gb 533mhz pc2-4200 ddr2 desktop memory kvr533d2 1gr | memory     | kingston | kvr533d2/1gr |   12.99 |



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

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

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

Entity A:
| title                                                                    | category              | brand   |   modelno |   price |
|:-------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-plex self trimming rear projection screen - 60 x 60 av format | electronics - general | da-lite |     27575 | 2680.99 |

Entity B:
| title                                                                      | category           | brand   |   modelno |   price |
|:---------------------------------------------------------------------------|:-------------------|:--------|----------:|--------:|
| da-lite da-view thru-the-wall rear projection screen - 45 x 80 hdtv format | projection screens | da-lite |     23065 | 12909.9 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1132
rtable_id: 12781
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 gigabit ethernet switch with poe | networking | netgear | gs108pe100nas |   247.5 |

Entity B:
| title                                                  | category   | brand   | modelno   |   price |
|:-------------------------------------------------------|:-----------|:--------|:----------|--------:|
| netgear jgs516 prosafe 16-port gigabit ethernet switch | switches   | netgear | jgs516    |  169.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1260
rtable_id: 8653
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 |
|:--------------------------------------------|:-----------------|:--------|:----------|--------:|
| lorex lw1002 live wireless security cameras | garden - general | lorex   | lw1002    |     119 |

Entity B:
| title                                                    | category              | brand   | modelno   |   price |
|:---------------------------------------------------------|:----------------------|:--------|:----------|--------:|
| lorex live sd9 wireless digital security system - lw2902 | home security systems | lorex   | lw2902    |  309.99 |



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

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

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

Entity A:
| title                                                                  | category              | brand   |   modelno |   price |
|:-----------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite matte white model c with csr manual screen - 72 x 72 av format | electronics - general | da-lite |     33403 |  563.99 |

Entity B:
| title                                                                            | category           | brand   | modelno   |   price |
|:---------------------------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| da-lite designer contour manual with csr - projection screen - 1 1 - matte white | projection screens | da-lite |           |  299.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1133
rtable_id: 6752
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 base rear projection screen - 57 3 4 x 77 video format | electronics - general | da-lite |     27528 | 2608.99 |

Entity B:
| title                                                                          | category           | brand   |   modelno |   price |
|:-------------------------------------------------------------------------------|:-------------------|:--------|----------:|--------:|
| da-lite data pro thru-the-wall rear projection screen - 401 2 x 72 hdtv format | projection screens | da-lite |     23168 | 10185.3 |



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

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

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

Entity A:
| title                                      | category              | brand   | modelno   |   price |
|:-------------------------------------------|:----------------------|:--------|:----------|--------:|
| los angeles lakers ipod touch 4g hard case | electronics - general | tribeca | fva4614   |   29.99 |

Entity B:
| title                                   | category              | brand   | modelno   |   price |
|:----------------------------------------|:----------------------|:--------|:----------|--------:|
| oakland raiders ipod touch 4g hard case | computers accessories | tribeca |           |   29.99 |



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

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

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

Entity A:
| title                                       | category                      | brand   | modelno   |   price |
|:--------------------------------------------|:------------------------------|:--------|:----------|--------:|
| s j paper mla end tab classification folder | stationery & office machinery |         | s59720    |   64.94 |

Entity B:
| title                                                                                      | category            | brand     | modelno   | price   |
|:-------------------------------------------------------------------------------------------|:--------------------|:----------|:----------|:--------|
| s j paper s59727 - six-section end tab classification folders pressboard letter red 25 box | printer accessories | s j paper |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1714
rtable_id: 16392
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 ce278a black laserjet print cartridge | printers   | hp      | hp ce278a |   69.84 |

Entity B:
| title                                                      | category            | brand   | modelno   |   price |
|:-----------------------------------------------------------|:--------------------|:--------|:----------|--------:|
| hp laserjet 05a black cartridge in retail packaging ce505a | laser printer toner | hp      | ce505a    |   68.82 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 25
rtable_id: 9007
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 kx-tg4022n dect 6.0 plus expandable cordless answering system w 2 handsets | electronics - general | panasonic | kx-tg4022n |   44.98 |

Entity B:
| title                                                                                               | category                         | brand     | modelno    | price   |
|:----------------------------------------------------------------------------------------------------|:---------------------------------|:----------|:-----------|:--------|
| panasonic kx-tg1062m dect 6.0 corded cordless phone with answering machine metallic gray 2 handsets | corded-cordless combo telephones | panasonic | kx-tg1062m |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 912
rtable_id: 9796
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 |
|:----------------------------------------------------|:------------|:--------|:-------------|--------:|
| toshiba ph3100u-1e3s 1tb usb 3.0 desktop hard drive | hard drives | toshiba | ph3100u-1e3s |      89 |

Entity B:
| title                                                               | category             | brand   | modelno      |   price |
|:--------------------------------------------------------------------|:---------------------|:--------|:-------------|--------:|
| toshiba 2 tb usb 2.0 esata desktop external hard drive ph3200u-1exb | external hard drives | toshiba | ph3200u-1exb |  134.99 |



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

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

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

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

Entity B:
| title                             | category          | brand   | modelno   |   price |
|:----------------------------------|:------------------|:--------|:----------|--------:|
| black toner cartridge phaser 7760 | printer ink toner | xerox   | 106r01163 |     129 |



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

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

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

Entity A:
| title                                 | category              | brand   | modelno   |   price |
|:--------------------------------------|:----------------------|:--------|:----------|--------:|
| los angeles lakers iphone 3g duo case | electronics - general | tribeca | fva4005   |   24.99 |

Entity B:
| title                                | category              | brand   | modelno   |   price |
|:-------------------------------------|:----------------------|:--------|:----------|--------:|
| san antonio spurs iphone 3g duo case | computers accessories | tribeca |           |    9.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 64
rtable_id: 14347
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 powershot sx130-is black 12.1 mp digital camera w 12x optical zoom 3.0 lcd display w 50 bonus prints | digital cameras | canon   | sx130     |  191.99 |

Entity B:
| title                                                                    | category                    | brand   | modelno         |   price |
|:-------------------------------------------------------------------------|:----------------------------|:--------|:----------------|--------:|
| canon powershot a800 10 mp digital camera with 3.3 x optical zoom silver | point shoot digital cameras | canon   | a800 ( silver ) |      89 |



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

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

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

Entity A:
| title                                                                                    | category        | brand   | modelno   |   price |
|:-----------------------------------------------------------------------------------------|:----------------|:--------|:----------|--------:|
| kodak easyshare m530 red 12mp digital camera w 3x optical zoom 2.7 lcd w 50 bonus prints | digital cameras | kodak   | m530 red  |   99.54 |

Entity B:
| title                                                                                             | category                    | brand   |   modelno |   price |
|:--------------------------------------------------------------------------------------------------|:----------------------------|:--------|----------:|--------:|
| kodak easyshare m532 14 mp digital camera with 4x optical zoom and 2.7-inch lcd - green new model | point shoot digital cameras | kodak   |   8790750 |   85.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 688
rtable_id: 6800
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 |
|:-----------------------------------------------------------------------------------------|:----------------------|:--------|:----------|--------:|
| apc battery backup 750va back-ups es 120v 10 outlet power supply power-saving ups be750g | electronics - general | apc     | be750g    |   95.88 |

Entity B:
| title                                                                 | category                       | brand   | modelno   |   price |
|:----------------------------------------------------------------------|:-------------------------------|:--------|:----------|--------:|
| apc be450g back-ups es 8-outlet 450va 120v uninterrupted power supply | batteries chargers accessories | apc     | be450g    |   55.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1543
rtable_id: 10366
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 1 hdmi to hdmi digital video cable | electronics - general | startech | hdmimm1   |   10.73 |

Entity B:
| title                                                          | category    | brand    | modelno   |   price |
|:---------------------------------------------------------------|:------------|:---------|:----------|--------:|
| startech.com hdmimm15 15 feet hdmi to hdmi digital video cable | hdmi cables | startech | hdmimm15  |    5.68 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 125
rtable_id: 1477
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 2.5 sata superspeed usb 3.0 hard drive enclosure | electronics - general | siig    | ju-sa0912-s1 |   20.39 |

Entity B:
| title                                                                                               | category              | brand   | modelno      |   price |
|:----------------------------------------------------------------------------------------------------|:----------------------|:--------|:-------------|--------:|
| vantec nexstar superspeed 2.5-inch sata to usb 3.0 external hard drive enclosure nst-280s3-bk black | computers accessories | vantec  | nst-280s3-bk |   26.62 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1022
rtable_id: 14015
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 |
|:---------------------------------|:-----------|:--------|:----------|--------:|
| iogear miniview micro kvm switch | networking | iogear  | gcs62     |   25.88 |

Entity B:
| title                                                            | category     | brand   | modelno   |   price |
|:-----------------------------------------------------------------|:-------------|:--------|:----------|--------:|
| iogear 2-port miniview micro ps 2 kvm switch with 2 cables gcs62 | kvm switches | iogear  | gcs62     |   18.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1102
rtable_id: 7853
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 |
|:--------------------------------------------|:------------|:--------|----------:|--------:|
| iomega ego 500gb helium portable hard drive | hard drives | iomega  |     34945 |   78.98 |

Entity B:
| title                                                                             | category             | brand   |   modelno |   price |
|:----------------------------------------------------------------------------------|:---------------------|:--------|----------:|--------:|
| iomega 500gb ego blackbelt portable hard drive superspeed usb 3.0 usb 2.0 - 35314 | external hard drives | iomega  |     35314 |   75.72 |



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

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

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

Entity A:
| title                                                     | category              | brand   |   modelno |   price |
|:----------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite matte white scenic roller manual screen - 30 x 30 | electronics - general | da-lite |     40353 | 4077.99 |

Entity B:
| title                                                         | category           | brand   | modelno   |   price |
|:--------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| da-lite scenic roller - projection screen - 4 3 - matte white | projection screens | da-lite |           | 1795.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 744
rtable_id: 16162
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 |
|:-----------------------------------------|:-----------|:----------|:----------|--------:|
| energizer er-p240 cordless phone battery | computers  | energizer |           |   11.88 |

Entity B:
| title                          | category         | brand     | modelno   |   price |
|:-------------------------------|:-----------------|:----------|:----------|--------:|
| energizer 2l76bp photo battery | camera batteries | energizer | 2l76bp    |    3.73 |



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

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

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

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

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



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

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

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

Entity A:
| title                                                    | category              | brand         | modelno   |   price |
|:---------------------------------------------------------|:----------------------|:--------------|:----------|--------:|
| elite m85xws1 screens manual pull down projection screen | electronics - general | elite screens | m85xws1   |   60.84 |

Entity B:
| title                                                                            | category           | brand         | modelno   |   price |
|:---------------------------------------------------------------------------------|:-------------------|:--------------|:----------|--------:|
| elite screens manual pull down projection screen 16 9 aspect ratio-120in - black | projection screens | elite screens | m120uwh   |  157.12 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2251
rtable_id: 9945
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 eos digital rebel xs black 10.1 mp digital slr 18-55-is lens and 2.5 tripod value bundle | digital cameras | canon   |           |     639 |

Entity B:
| title                                                                                           | category            | brand   | modelno        |   price |
|:------------------------------------------------------------------------------------------------|:--------------------|:--------|:---------------|--------:|
| canon eos rebel t3 12.2 mp cmos digital slr with 18-55mm is ii lens and eos hd movie mode black | digital slr cameras | canon   | rebel t3 black |  548.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2206
rtable_id: 1979
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-285s2-bk 2.5-inch sata to usb 2.0 external hard drive enclosure onyx black | hard drive enclosures | vantec  | nst-285s2-bk |   18.06 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2255
rtable_id: 4044
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 ministation cobalt 640 gb usb 2.0 portable hard drive with turbopc hd-pet640u2 b black | external hard drives | buffalo technology | hd-pet640u2 / b |  128.24 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1129
rtable_id: 10598
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 kx-tg4022n dect 6.0 plus expandable cordless answering system w 2 handsets | electronics - general | panasonic | kx-tg4022n |   44.98 |

Entity B:
| title                                                                                                 | category            | brand     | modelno   |   price |
|:------------------------------------------------------------------------------------------------------|:--------------------|:----------|:----------|--------:|
| panasonic dect 6.0 expandable cordless phone with talking caller id answering system - 4 handset pack | cordless telephones | panasonic |           |  132.68 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 912
rtable_id: 17637
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 |
|:------------------------------------------------------------------|:---------------------------|:--------|:----------|--------:|
| pilot begreen b2p roller ball retractable gel ink pen red 5 count | electronics-inflexible kit |         |           |     7.5 |

Entity B:
| title                                                                                  | category     | brand   | modelno   | price   |
|:---------------------------------------------------------------------------------------|:-------------|:--------|:----------|:--------|
| pilot 31605 - begreen b2p bottle roller ball retractable gel pen black ink fine 2 pack | distribution | pilot   |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 333
rtable_id: 3710
label: 0