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 |
|:-----------------------------------------|:-----------|:--------|:--------------|--------:|
| hp 75 tri-color inkjet cartridge cb337wn | printers   | hp      | hp cb337wn140 |   19.47 |

Entity B:
| title                                          | category           | brand   | modelno       | price   |
|:-----------------------------------------------|:-------------------|:--------|:--------------|:--------|
| hp 75 tri-color inkjet print cartridge cb337wn | inkjet printer ink | hp      | cb337wn # 140 |         |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1194
rtable_id: 14916
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 |
|:----------------------------------------------|:----------------------|:--------|:-----------|--------:|
| xfx radeon hd6850 pcie 1gb ddr5 graphics card | electronics - general | xfx     | hd685xzndc |     195 |

Entity B:
| title                                                      | category              | brand   | modelno    | price   |
|:-----------------------------------------------------------|:----------------------|:--------|:-----------|:--------|
| xfx radeon hd 5770 1 gb ddr5 pcie graphics card hd577aznfc | computers accessories | xfx     | hd577aznfc |         |



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

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

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

Entity A:
| title                                     | category              | brand   | modelno         |   price |
|:------------------------------------------|:----------------------|:--------|:----------------|--------:|
| belkin 3 cat-5e snagless patch cable blue | electronics - general | belkin  | a3l791-03-blu-s |    4.35 |

Entity B:
| title                                           | category        | brand   | modelno         |   price |
|:------------------------------------------------|:----------------|:--------|:----------------|--------:|
| belkin cat-5e snagless patch cable blue 25 feet | ethernet cables | belkin  | a3l791-25-blu-s |     9.5 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2147
rtable_id: 14227
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 61 black tri-color combo inkjet cartridge | printers   | hp      | hp 61     |    30.5 |

Entity B:
| title                                      | category          | brand   | modelno   |   price |
|:-------------------------------------------|:------------------|:--------|:----------|--------:|
| hp 15 and 78 color and black ink cartridge | printer ink toner | hp      | c9353bn   |   59.74 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 992
rtable_id: 1329
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 |
|:---------------------------------------------------------|:----------------------|:----------|----------:|--------:|
| visontek wireless candyboard mini keyboard with touchpad | electronics - general | visiontek |    900319 |   59.82 |

Entity B:
| title                     | category   | brand   | modelno      | price   |
|:--------------------------|:-----------|:--------|:-------------|:--------|
| hp wireless mini keyboard | keyboards  | hp      | xb387aa #aba |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2253
rtable_id: 1022
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 lne1001 easy connect network ip camera | computers  | lorex   |           |  121.84 |

Entity B:
| title                                                              | category     | brand   | modelno   |   price |
|:-------------------------------------------------------------------|:-------------|:--------|:----------|--------:|
| lorex lnz4001i wireless pan tilt easy connect network camera white | dome cameras | lorex   | lnz4001i  |  283.98 |



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

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

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

Entity A:
| title                                    | category   | brand   | modelno   |   price |
|:-----------------------------------------|:-----------|:--------|:----------|--------:|
| epson t125420 yellow durabrite cartridge | printers   | epson   | t125420   |   11.88 |

Entity B:
| title                                                    | category           | brand   | modelno   |   price |
|:---------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| genuine new epson t044420 durabrite yellow ink cartridge | inkjet printer ink | epson   |           |   11.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2093
rtable_id: 21957
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 c6020b coated paper 1 roll 36-inches x 150 ft | stationery & office machinery | hp      | c6020b    |   49.88 |

Entity B:
| title                                     | category   | brand   | modelno   |   price |
|:------------------------------------------|:-----------|:--------|:----------|--------:|
| hp coated paper 36 inches x 150 feet roll | roll paper | hp      | c6020b    |   29.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 6
rtable_id: 9015
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 1382920 toner 3000 page-yield black | stationery & office machinery | lexmark |   1382920 |   270.9 |

Entity B:
| title                                           | category            | brand   | modelno   |   price |
|:------------------------------------------------|:--------------------|:--------|:----------|--------:|
| c540h1kg high-yield toner 2500 page-yield black | laser printer toner | lexmark |           |   63.51 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2216
rtable_id: 10590
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 |
|:---------------------------------------------------------------|:----------------------|:--------|:-------------|--------:|
| nzxt phantom crafted series atx full tower steel chassis black | electronics - general | nzxt    | nzxt phantom |  139.82 |

Entity B:
| title                                                           | category       | brand   | modelno     |   price |
|:----------------------------------------------------------------|:---------------|:--------|:------------|--------:|
| gamma classic series atx mid tower interior steel chassis black | computer cases | nzxt    | gamma black |   35.99 |



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

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

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

Entity A:
| title                                                                | category              | brand   |   modelno |   price |
|:---------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-glas standard rear projection screen 72 x 96 video format | electronics - general | da-lite |     27639 | 4448.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 625
rtable_id: 13427
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 3 1 2 expansion colored file pocket straight tab | stationery & office machinery | generic |     73892 |   11.94 |

Entity B:
| title                                                                                     | category   | brand   | modelno   | price   |
|:------------------------------------------------------------------------------------------|:-----------|:--------|:----------|:--------|
| smead 75114 - 1 3 4 inch expansion end tab file pockets straight tab letter manila 25 box |            | smead   |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1601
rtable_id: 14065
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 |
|:-----------------------------------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| pendaflex cutless watershed file folders 1 3 cut top tab letter manila 100 per box | stationery & office machinery |         |     48434 |   22.69 |

Entity B:
| title                                                                      | category   | brand   | modelno   | price   |
|:---------------------------------------------------------------------------|:-----------|:--------|:----------|:--------|
| smead 24127 - folders 1 2 cut top reinforced end tab letter manila 100 box |            | smead   |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1699
rtable_id: 17546
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 dodgers pink iphone 4 hard case | electronics - general | tribeca | fva4450   |   29.99 |

Entity B:
| title                                  | category              | brand   | modelno   |   price |
|:---------------------------------------|:----------------------|:--------|:----------|--------:|
| boston red sox pink iphone 4 hard case | computers accessories | tribeca |           |   23.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 184
rtable_id: 7664
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 hc cinema vision tensioned advantage electrol - av format 8 x 8 diagonal | electronics - general | da-lite |     89939 |    2595 |

Entity B:
| title                                                                               | category           | brand   | modelno   | price   |
|:------------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| da-lite 98801 hc da-mat tensioned cosmopolitan electrol - video format 210 diagonal | projection screens | da-lite |           |         |



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

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

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

Entity A:
| title                                           | category   | brand   | modelno   |   price |
|:------------------------------------------------|:-----------|:--------|:----------|--------:|
| sabrent 6-in-1 usb 2.0 flash memory card reader | usb drives | sabrent | crw-ext   |   10.98 |

Entity B:
| title                                                     | category            | brand    |   modelno |   price |
|:----------------------------------------------------------|:--------------------|:---------|----------:|--------:|
| verbatim 20-in-1 universal flash memory card reader 95343 | memory card readers | verbatim |     95343 |   22.08 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2548
rtable_id: 11273
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 electric120v screens spectrum electrol projection screen | electronics - general | elite screens | electric120v |     189 |

Entity B:
| title                                                                           | category           | brand         | modelno     |   price |
|:--------------------------------------------------------------------------------|:-------------------|:--------------|:------------|--------:|
| elite screens vmax2 electric projection screen 1 1 aspect ratio-113in max white | projection screens | elite screens | vmax113xws2 |  356.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1553
rtable_id: 9161
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 |
|:------------------------------------------------|:------------------------------|:--------|:----------|--------:|
| quartet magnetic dry-erase board mahogany frame | stationery & office machinery | quartet | 2544m     |     419 |

Entity B:
| title                                                                               | category   | brand   | modelno   | price   |
|:------------------------------------------------------------------------------------|:-----------|:--------|:----------|:--------|
| quartet m4831 - magnetic dry erase board painted steel 48 x 31 white aluminum frame | printers   | quartet |           |         |



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

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

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

Entity A:
| title                                                                             | category   | brand   | modelno   |   price |
|:----------------------------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| crown super-soaker polypropylene wiper mat with gripper bottom 45 x 67 dark brown | rugs       | crown   | ssr046db  |  139.97 |

Entity B:
| title                                                                 | category   | brand   | modelno   | price   |
|:----------------------------------------------------------------------|:-----------|:--------|:----------|:--------|
| crown s1r046st - super-soaker diamond mat polypropylene 45 x 69 slate | antitheft  | crown   |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2306
rtable_id: 16792
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 10 cat6 snagless molded network patch cable gray | electronics - general | v7      | v7n2c6-10f-grys |    5.88 |

Entity B:
| title                                                                                       | category        | brand   | modelno          |   price |
|:--------------------------------------------------------------------------------------------|:----------------|:--------|:-----------------|--------:|
| v7 cat5e snagless molded network patch cable rj45 male to male blue 1-foot v7n3c5e-01f-blus | ethernet cables | v7      | v7n3c5e-01f-blus |    1.19 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 117
rtable_id: 13308
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 |
|:--------------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| avery file folder labels on mini-sheets 3-7 16 x 2 3 300 pack | stationery & office machinery | avery   |      2180 |    9.21 |

Entity B:
| title                                                                         | category   | brand   | modelno   | price   |
|:------------------------------------------------------------------------------|:-----------|:--------|:----------|:--------|
| avery 2180 - file folder labels on mini-sheets 2 3 x 3-7 16 assorted 300 pack |            | avery   |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 699
rtable_id: 4283
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 |
|:----------------------------------------------------------|:----------------------|:--------|:-----------|--------:|
| xfx ati radeon 5670 hd pci-express 1gb ddr3 graphics card | electronics - general | xfx     | hd567xznl3 |   91.88 |

Entity B:
| title                                                                                     | category              | brand   | modelno    |   price |
|:------------------------------------------------------------------------------------------|:----------------------|:--------|:-----------|--------:|
| xfx ati radeon hd 5670 512 mb ddr5 dvi hdmi displayport pci-express video card hd567xynfc | computers accessories | xfx     | hd567xynfc |   99.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1931
rtable_id: 3234
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 |
|:-----------------------------------------------------------------------|:----------------------|:-----------------|:------------|--------:|
| cables unlimited sata ii 3gbps to esata cable with straight connectors | electronics - general | cables unlimited | flt-6600-39 |    9.82 |

Entity B:
| title                                                                                             | category             | brand            | modelno      |   price |
|:--------------------------------------------------------------------------------------------------|:---------------------|:-----------------|:-------------|--------:|
| cables unlimted flt610018g 18-inch translucent green sata ii 3gbps cable with straight connectors | cables interconnects | cables unlimited | flt-6100-18g |    6.42 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2083
rtable_id: 12618
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 |
|:----------------------------------------------------|:------------------|:--------|:----------|--------:|
| midland 2-pack 22-channel camo lxt385vp3 gmrs radio | walkie-talkie/frs | midland | lxt385vp3 |   39.82 |

Entity B:
| title                                                            | category                | brand   | modelno   |   price |
|:-----------------------------------------------------------------|:------------------------|:--------|:----------|--------:|
| midland lxt380vp3 24-mile 22-channel frs gmrs two-way radio pair | gmrs-frs two-way radios | midland | lxt380vp3 |   27.84 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 334
rtable_id: 6657
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 |
|:-----------------------------------------------|:----------------|:--------|----------:|--------:|
| inland pro iphone and ipod 3-in-1 charging kit | mp3 accessories | inland  |      8521 |    9.84 |

Entity B:
| title                                            | category   | brand   |   modelno |   price |
|:-------------------------------------------------|:-----------|:--------|----------:|--------:|
| inland pro iphone and ipod 3-in-one charging kit | chargers   | inland  |      8521 |    9.84 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 303
rtable_id: 19299
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 |
|:-------------------------------------------|:----------------------|:--------|:----------|--------:|
| los angeles lakers ipod touch 4g hard case | electronics - general | tribeca | fva4614   |   29.99 |

Entity B:
| title                                 | category              | brand   | modelno   |   price |
|:--------------------------------------|:----------------------|:--------|:----------|--------:|
| los angeles lakers iphone 3g duo case | computers accessories | tribeca |           |    9.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1365
rtable_id: 8391
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 hc cinema vision tensioned advantage electrol - av format 8 x 8 diagonal | electronics - general | da-lite |     89939 |    2595 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 278
rtable_id: 19567
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 high power model b manual screen with csr - 84 x 84 av format | electronics - general | da-lite |     85303 |  372.99 |

Entity B:
| title                                                                              | category           | brand   | modelno   |   price |
|:-----------------------------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| da-lite advantage manual with csr - projection screen - 133 in - 16 9 - high power | home audio theater | da-lite |           |  904.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2115
rtable_id: 8789
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 |
|:--------------------------------|:-----------|:--------|:-------------|--------:|
| philips gogear ariaz mp3 player | mp3        | philips | sa3ara08k/37 |   78.88 |

Entity B:
| title                                           | category    | brand   | modelno      |   price |
|:------------------------------------------------|:------------|:--------|:-------------|--------:|
| philips gogear raga 4gb mp3 player sa3rga04k 37 | mp3 players | philips | sa3rga04k/37 |   39.02 |



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

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

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

Entity A:
| title                                          | category              | brand      | modelno      |   price |
|:-----------------------------------------------|:----------------------|:-----------|:-------------|--------:|
| case logic 13.3 black neoprene notebook sleeve | electronics - general | case logic | pls-13 black |      20 |

Entity B:
| title                                                       | category                            | brand      | modelno      |   price |
|:------------------------------------------------------------|:------------------------------------|:-----------|:-------------|--------:|
| case logic pls-15 15.4-16 inch neoprene laptop sleeve black | laptop netbook computer accessories | case logic | pls-15 black |   18.54 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2392
rtable_id: 17643
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 1tb my passport essential se usb 3.0 portable external hard drive | hard drives | western digital | wdbacx0010bbksn |   98.92 |

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



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

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

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

Entity A:
| title                                                | category              | brand               | modelno         |   price |
|:-----------------------------------------------------|:----------------------|:--------------------|:----------------|--------:|
| green onions supply 10.1 anti-glare screen protector | electronics - general | green onions supply | rt-spfg101w / m |   22.88 |

Entity B:
| title                                                                                                                 | category   | brand   | modelno         |   price |
|:----------------------------------------------------------------------------------------------------------------------|:-----------|:--------|:----------------|--------:|
| green onions supply rt-spf1017w m anti-glare screen protector for 17-inch wide laptop lcd screen -1 piece transparent | bags cases | green   | rt-spf1017w / m |   29.54 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2341
rtable_id: 11884
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 |
|:----------------------------------------------------|:----------------------|:-----------|:----------|--------:|
| tripp lite 10 usb 2.0 a to micro-usb b device cable | electronics - general | tripp lite | u050-010  |    6.88 |

Entity B:
| title                                                                               | category   | brand      | modelno   |   price |
|:------------------------------------------------------------------------------------|:-----------|:-----------|:----------|--------:|
| tripp lite u326-006 usb 3.0 super speed 5gbps a to micro b device cable 6 feet blue | usb cables | tripp lite | u326-006  |    9.59 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 510
rtable_id: 15321
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 |
|:--------------------------------|:-----------|:--------|:------------|--------:|
| coby 8gb video mp3 player black | mp3        | coby    | mp727-8gblk |   59.88 |

Entity B:
| title                            | category    | brand   | modelno           |   price |
|:---------------------------------|:------------|:--------|:------------------|--------:|
| sansa fuze 8 gb mp3 player black | mp3 players | sandisk | sdmx20r-008gk-a57 |   63.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 557
rtable_id: 9599
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 black ink tank | printers   | canon   | 4546b001  |   13.97 |

Entity B:
| title                                | category           | brand   | modelno   |   price |
|:-------------------------------------|:-------------------|:--------|:----------|--------:|
| canon cli-226 cyan ink tank 4547b001 | inkjet printer ink | canon   | 4547b001  |   11.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2365
rtable_id: 19514
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 yellow 10-feet v7n3c5e-10f-ylws | ethernet cables | v7      | v7n3c5e-10f-ylws |    8.25 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1284
rtable_id: 1337
label: 0