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 |
|:--------------------------------------------------------------------|:----------------------|:--------|:----------|--------:|
| ihome app-friendly rechargeable speaker system for ipad iphone ipod | electronics - general | ihome   | id9s      |   99.99 |

Entity B:
| title                                                  | category        | brand   | modelno   |   price |
|:-------------------------------------------------------|:----------------|:--------|:----------|--------:|
| ihome ihm78 rechargeable mini speakers for ipod purple | speaker systems | ihome   | ihm78uc   |   29.99 |



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

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

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

Entity A:
| title                                                            | category              | brand   | modelno       |   price |
|:-----------------------------------------------------------------|:----------------------|:--------|:--------------|--------:|
| corsair builder series cx v2 500w 80 plus certified power supply | electronics - general | corsair | cmpsu-500cxv2 |   67.88 |

Entity B:
| title                                                                                                                              | category       | brand   | modelno       |   price |
|:-----------------------------------------------------------------------------------------------------------------------------------|:---------------|:--------|:--------------|--------:|
| corsair builder series cx600 600 watt 80 plus certified power supply compatible with intel and amd platforms atx 700 cmpsu-600cxv2 | power supplies | corsair | cmpsu-600cxv2 |   65.84 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 492
rtable_id: 12502
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-tga6645b dect 6.0 plus expandable digital cordless answering system with 5 handsets | electronics - general | panasonic | kx-tg6645b |     150 |

Entity B:
| title                                                                         | category            | brand     | modelno    | price   |
|:------------------------------------------------------------------------------|:--------------------|:----------|:-----------|:--------|
| panasonic dect 6.0 4-handset cordless phone with answering machine kx-tg6434t | cordless telephones | panasonic | kx-tg6434t |         |



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

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

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

Entity A:
| title                                                    | category   | brand     | modelno      |   price |
|:---------------------------------------------------------|:-----------|:----------|:-------------|--------:|
| birdhouse tony hawk 2gb ptero skatedrive usb flash drive | usb drives | ep memory | bh-skthpt/2g |    9.84 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1404
rtable_id: 20607
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 |
|:--------------------------------------------|:----------------------|:--------|:----------|--------:|
| st. louis cardinals ipod touch 4g hard case | electronics - general | tribeca | fva4549   |   29.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 320
rtable_id: 10473
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 honey maple veneer model b manual screen with matte white fabric - 60 x 60 diagonal video format | electronics - general | da-lite |     87184 |  167.99 |

Entity B:
| title                                                                                        | category           | brand   | modelno   | price   |
|:---------------------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| heritage walnut veneer model b manual screen with high power fabric - av format size 60 x 60 | projection screens | da-lite |           |         |



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

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

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

Entity A:
| title                                                                              | category        | brand   | modelno   |   price |
|:-----------------------------------------------------------------------------------|:----------------|:--------|:----------|--------:|
| casio exilim ex-zs10 14.1 mp digital camera blue w 5x optical zoom 2.7 lcd display | digital cameras | casio   | ex-zs10be |     120 |

Entity B:
| title                                                                                  | category                    | brand   | modelno   |   price |
|:---------------------------------------------------------------------------------------|:----------------------------|:--------|:----------|--------:|
| casio exilim ex-z800 14.1 mp digital camera with 4x optical zoom and 2.7-inch lcd blue | point shoot digital cameras | casio   | ex-z800be |  108.94 |



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

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

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

Entity A:
| title                                         | category   | brand   | modelno   |   price |
|:----------------------------------------------|:-----------|:--------|:----------|--------:|
| lexmark e450h11a toner 11000 page-yield black | printers   | lexmark | e450h11a  |  248.27 |

Entity B:
| title                                 | category            | brand    | modelno   |   price |
|:--------------------------------------|:--------------------|:---------|:----------|--------:|
| 52117101 toner 33000 page-yield black | laser printer toner | oki data |           |  151.18 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1816
rtable_id: 10405
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 |
|:-----------------------------------------------------|:-----------|:--------|:------------------|--------:|
| wintec filemate 16gb color mini usb flash drive aqua | usb drives | wintec  | 3fmsp01u2aq-16g-r |   24.84 |

Entity B:
| title                                                      | category         | brand   | modelno          |   price |
|:-----------------------------------------------------------|:-----------------|:--------|:-----------------|--------:|
| wintec filemate color mini 8 gb usb 2.0 flash drive - pink | usb flash drives | wintec  | 3fmsp01u2pk-8g-r |   13.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2077
rtable_id: 21728
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 unframed rear projection screen - 57 3 4 x 77 video format | electronics - general | da-lite |     27604 | 1609.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1296
rtable_id: 4728
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 |
|:-------------------------------------------------------------------------|:-----------|:----------|:----------|--------:|
| gear head mp2300blk 3 button wireless optical wheel mouse - black silver | mice       | gear head | mp2300blk |   13.82 |

Entity B:
| title                                                                        | category   | brand     | modelno   |   price |
|:-----------------------------------------------------------------------------|:-----------|:----------|:----------|--------:|
| gear head usb 3 button wireless optical wheel mouse - purple black mp2500pur | mice       | gear head | mp2500pur |   11.99 |



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

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

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

Entity A:
| title                                                                        | category              | brand   |   modelno |   price |
|:-----------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-glas deluxe rear projection screen - 40 1 4 x 53 3 4 video format | electronics - general | da-lite |     27655 | 1752.99 |

Entity B:
| title                                                                       | category           | brand   |   modelno |   price |
|:----------------------------------------------------------------------------|:-------------------|:--------|----------:|--------:|
| da-lite da-plex thru-the-wall rear projection screen - 72 x 96 video format | projection screens | da-lite |     23049 |   10252 |



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

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

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

Entity A:
| title                                                 | category      | brand   | modelno   |   price |
|:------------------------------------------------------|:--------------|:--------|:----------|--------:|
| sony ss-cr3000 home theater speaker completer package | stereos/audio | sony    | ss-cr3000 |   99.99 |

Entity B:
| title                                                  | category   | brand   | modelno   |   price |
|:-------------------------------------------------------|:-----------|:--------|:----------|--------:|
| sony ss-cr3000 center and rear channel speaker package | speakers   | sony    | sscr3000  |   69.98 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1579
rtable_id: 11460
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 |
|:-----------------------------------------------------------------------------------------|:----------------|:--------|:----------|--------:|
| 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 m552 14 mp digital camera with 5x optical zoom and 2.7-inch lcd - bluegray new model | point shoot digital cameras | kodak   |   8145872 |   87.97 |



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

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

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

Entity A:
| title                                                               | category              | brand   |   modelno |   price |
|:--------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-plex unframed rear projection screen - 84 x 84 av format | electronics - general | da-lite |     27503 | 3561.99 |

Entity B:
| title                                                                        | category           | brand   | modelno   | price   |
|:-----------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| da-lite 27512 da-plex unframed rear projection screen - 72 x 96 video format | projection screens | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1257
rtable_id: 17837
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 |
|:-----------------------------------------------------------|:------------|:-----------------|:----------------|--------:|
| ocz technology vertex 2 90gb 2.5 sata ii solid state drive | hard drives | ocz technologies | oczssd22vtxe90g |  179.98 |

Entity B:
| title                                                                                          | category            | brand   | modelno           |   price |
|:-----------------------------------------------------------------------------------------------|:--------------------|:--------|:------------------|--------:|
| ocz technology 120 gb vertex 2 series sata ii 2.5-inch solid state drive ssd oczssd2-2vtxe120g | computer components | ocz     | oczssd2-2vtxe120g |  159.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 243
rtable_id: 3778
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 |
|:-----------------------------------------------------------------------------------------|:------------------------------|:-------------|----------:|--------:|
| wausau paper astrobrights colored paper 24lb 8-1 2 x 11 planetary purple 500 sheets ream | stationery & office machinery | wausau paper |     22621 |   10.27 |

Entity B:
| title                                                                           | category   | brand   | modelno   |   price |
|:--------------------------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| wausau paper 32542 - exact colored paper 20lb 8-1 2 x 14 yellow 500 sheets ream |            | wausau  |           |   11.63 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1530
rtable_id: 7273
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 m580 14 mp digital camera with 8x wide angle optical zoom and 3.0-inch lcd purple | point shoot digital cameras | kodak   | easyshare m580 purple |  169.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 688
rtable_id: 18670
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 |
|:------------------------------------------------------------|:----------------------|:--------|:---------------|--------:|
| evga geforce 8400 gs 1gb ddr3 pci express 2.0 graphics card | electronics - general | evga    | 01g-p3-1302-lr |   44.99 |

Entity B:
| title                                                            | category              | brand   | modelno     | price   |
|:-----------------------------------------------------------------|:----------------------|:--------|:------------|:--------|
| msi geforce 210 512 mb ddr2 pci-express 2.0 graphics card md512h | computers accessories | msi     | n210-md512h |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1893
rtable_id: 4602
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 |
|:-----------------------------------------------------|:----------------|:---------------|:------------|--------:|
| ten one design pogo stylus for iphone 4 burnt orange | mp3 accessories | ten one design | t1-af25-407 |   13.49 |

Entity B:
| title                                                                   | category   | brand   | modelno     |   price |
|:------------------------------------------------------------------------|:-----------|:--------|:------------|--------:|
| ten one design pogo sketch stylus for ipad iphone and ipod touch silver | styli      | ten     | t1-ap25-102 |   11.12 |



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

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

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

Entity A:
| title                                                    | category              | brand     | modelno     |   price |
|:---------------------------------------------------------|:----------------------|:----------|:------------|--------:|
| panasonic ergofit inner ear headphones white rp-hje450-w | electronics - general | panasonic | rp-hje450-w |   43.88 |

Entity B:
| title                                                               | category   | brand     | modelno     | price   |
|:--------------------------------------------------------------------|:-----------|:----------|:------------|:--------|
| panasonic rp-hje270-k in-ear earbud ergo-fit design headphone black | headphones | panasonic | rp-hje270-k |         |



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

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

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

Entity A:
| title                                                                        | category                      | brand   |   modelno |   price |
|:-----------------------------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| smead 5 expansion end tab file pockets w tyvek straight letter manila 10 box | stationery & office machinery |         |     75174 |   37.94 |

Entity B:
| title                                                                         | category   | brand   | modelno   |   price |
|:------------------------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| smead 10300 - file folders straight cut one-ply top tab letter manila 100 box |            | smead   |           |   22.11 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1338
rtable_id: 13499
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 q1421a universal semi-gloss photo paper | stationery & office machinery | hp      | q1421a    |   94.88 |

Entity B:
| title                          | category            | brand   | modelno   |   price |
|:-------------------------------|:--------------------|:--------|:----------|--------:|
| hp q1398a universal bond paper | printer accessories | hp      |           |   45.99 |



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

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

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

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

Entity B:
| title                                                                           | category              | brand   | modelno      |   price |
|:--------------------------------------------------------------------------------|:----------------------|:--------|:-------------|--------:|
| xfx ati radeon hd 5570 1 gb ddr2 vga dvi hdmi pci-express video card hd557xzhf2 | computers accessories | xfx     | hd-557x-zhf2 |   68.61 |



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

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

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

Entity A:
| title                                                             | category              | brand   |   modelno |   price |
|:------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-glas deluxe rear projection screen - 84 x 84 av format | electronics - general | da-lite |     27650 | 4958.99 |

Entity B:
| title                                                       | category           | brand   | modelno   |   price |
|:------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| da-plex deluxe rear projection screen - 108 x 108 av format | projection screens | da-lite |           |    7950 |



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

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

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

Entity A:
| title                                                                        | category              | brand   |   modelno |   price |
|:-----------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-plex deluxe rear projection screen - 50 1 2 x 67 1 4 video format | electronics - general | da-lite |     27562 | 2544.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 700
rtable_id: 18153
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 self trimming rear projection screen - 96 x 120 av format | electronics - general | da-lite |     27915 | 7443.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: 2472
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 |
|:-----------------------------------------|:-----------|:----------------|----------:|--------:|
| mortimer beckett time paradox jewel case | software   | encore software |     10958 |    7.82 |

Entity B:
| title                                    | category              | brand   |   modelno |   price |
|:-----------------------------------------|:----------------------|:--------|----------:|--------:|
| mortimer beckett and the time paradox sb | computers accessories | encore  |     10951 |   26.74 |



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

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

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

Entity A:
| title                                                  | category   | brand   | modelno   |   price |
|:-------------------------------------------------------|:-----------|:--------|:----------|--------:|
| lexmark 12a8425 black high-yield toner print cartridge | printers   | lexmark | 12a8425   |   302.4 |

Entity B:
| title                                          | category           | brand   | modelno   |   price |
|:-----------------------------------------------|:-------------------|:--------|:----------|--------:|
| lexmark 12a1975 high-yield black ink cartridge | inkjet printer ink | lexmark | 12a1975   |   14.95 |



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

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

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

Entity A:
| title                                                    | category    | brand   | modelno     |   price |
|:---------------------------------------------------------|:------------|:--------|:------------|--------:|
| iosafe rugged 750gb usb 3.0 portable external hard drive | hard drives | iosafe  | pa70750u1yr |  139.98 |

Entity B:
| title                                                                   | category             | brand    |   modelno | price   |
|:------------------------------------------------------------------------|:---------------------|:---------|----------:|:--------|
| verbatim 320 gb usb 2.0 firewire 400 portable external hard drive 96527 | external hard drives | verbatim |     96527 |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 176
rtable_id: 158
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 |
|:------------------------------------------------|:----------------------|:--------|----------:|--------:|
| manhattan 150705 superspeed usb to sata adapter | electronics - general |         |    150705 |   47.84 |

Entity B:
| title                                           | category             | brand     | modelno   | price   |
|:------------------------------------------------|:---------------------|:----------|:----------|:--------|
| manhattan 150705 superspeed usb to sata adapter | cables interconnects | manhattan |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 784
rtable_id: 21196
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 |
|:-----------------------------|:-----------|:--------|:----------|--------:|
| canon cli-226 black ink tank | printers   | canon   |           |       0 |

Entity B:
| title                         | category           | brand   | modelno   |   price |
|:------------------------------|:-------------------|:--------|:----------|--------:|
| canon cli-221 ink tank yellow | inkjet printer ink | canon   | 2949b001  |   12.99 |



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

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

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

Entity A:
| title                                                     | category              | brand   | modelno         |   price |
|:----------------------------------------------------------|:----------------------|:--------|:----------------|--------:|
| asus us radeon 1gb gddr5 hd6870 pci express graphics card | electronics - general | asus    | eah6870d2di2s1g |  199.82 |

Entity B:
| title                                                                            | category       | brand     |   modelno |   price |
|:---------------------------------------------------------------------------------|:---------------|:----------|----------:|--------:|
| visiontek radeon 6670 1 gb gddr5 pci express dvi-d hdmi vga graphics card 900369 | graphics cards | visiontek |    900369 |  109.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 172
rtable_id: 19352
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 |
|:---------------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| universal pressboard classification folder legal box of 10 red | stationery & office machinery |         |     82007 |   47.84 |

Entity B:
| title                                                                                | category              | brand     | modelno   |   price |
|:-------------------------------------------------------------------------------------|:----------------------|:----------|:----------|--------:|
| pendaflex 17172 - pressboard classification folders letter four-section green 10 box | computers accessories | pendaflex |           |   88.95 |



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

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

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

Entity A:
| title                                                                | category              | brand   |   modelno |   price |
|:---------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-plex deluxe rear projection screen - 78 x 139 hdtv format | electronics - general | da-lite |     27573 | 7452.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1959
rtable_id: 20125
label: 0