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 |
|:------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-glas deluxe rear projection screen - 96 x 96 av format | electronics - general | da-lite |     27651 | 6128.99 |

Entity B:
| title                                                              | category           | brand   | modelno   |   price |
|:-------------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| da-glas base rear projection screen - 43 1 4 x 57 3 4 video format | projection screens | da-lite |           | 1519.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1178
rtable_id: 17203
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 |
|:---------------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| acco vinyl report cover prong clip letter 1 2 capacity 10-pack | stationery & office machinery | acco    |     26101 |   10.94 |

Entity B:
| title                                                                        | category             | brand   | modelno   | price   |
|:-----------------------------------------------------------------------------|:---------------------|:--------|:----------|:--------|
| acco 18928 - pressboard report cover spring clip letter 2 capacity earth red | cables interconnects | acco    |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1172
rtable_id: 7831
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 27578 da-plex 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: 8791
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 cat5e snagless network patch cable yellow | electronics - general | v7      | v7n3c5e-25f-ylws |    6.88 |

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



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

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

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

Entity A:
| title                                        | category        | brand   | modelno   |   price |
|:---------------------------------------------|:----------------|:--------|:----------|--------:|
| griffin ipod touch 4g screen care kit 3 pack | mp3 accessories | arkon   | gb01913   |    13.3 |

Entity B:
| title                                                                | category              | brand              | modelno   |   price |
|:---------------------------------------------------------------------|:----------------------|:-------------------|:----------|--------:|
| new-griffin gb01909 ipod nano r 6g screen care kit 3 pk - gfngb01909 | complete tripod units | griffin technology |           |      16 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 709
rtable_id: 830
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 xms2 4 gb 2 x 2 gb pc2-6400 800 mhz 240-pin ddr2 dual-channel memory kit - twin2x4096-6400c5 | memory     | corsair | twin2x4096-6400c5 |   74.82 |

Entity B:
| title                                                                                   | category   | brand   | modelno         |   price |
|:----------------------------------------------------------------------------------------|:-----------|:--------|:----------------|--------:|
| corsair cm2x2048-6400c5 xms2 2gb pc2-6400 800mhz 240-pin ddr2 cl5 desktop memory module | memory     | corsair | cm2x2048-6400c5 |    29.7 |



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

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

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

Entity A:
| title                                          | category   | brand   | modelno    |   price |
|:-----------------------------------------------|:-----------|:--------|:-----------|--------:|
| hp ce505xd black laserjet print cartridges 2pk | printers   | hp      | hp ce505xd |  258.84 |

Entity B:
| title                                                                       | category          | brand   | modelno   |   price |
|:----------------------------------------------------------------------------|:------------------|:--------|:----------|--------:|
| hp color laserjet cc530a dual pack black print cartridges cc530ad dual pack | printer ink toner | hp      | cc530ad   |  141.87 |



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

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

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

Entity A:
| title                                                                                                                               | category    | brand              | modelno       |   price |
|:------------------------------------------------------------------------------------------------------------------------------------|:------------|:-------------------|:--------------|--------:|
| buffalo technology drivestation axis 1.5 tb usb 2.0 desktop external hard drive with buffalo tools and turbo pc hd-lb1 .5 tu2 black | hard drives | buffalo technology | hd-lb1 .5 tu2 |  101.82 |

Entity B:
| title                                                                                                                     | category             | brand              | modelno         |   price |
|:--------------------------------------------------------------------------------------------------------------------------|:---------------------|:-------------------|:----------------|--------:|
| buffalo technology ministation plus 1 tb usb 3.0 portable external hard drive with shock protection hd-pnt1 .0 u3bb black | external hard drives | buffalo technology | hd-pnt1 .0 u3bb |  103.24 |



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

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

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

Entity A:
| title                                                            | category    | brand    |   modelno |   price |
|:-----------------------------------------------------------------|:------------|:---------|----------:|--------:|
| verbatim store n go superspeed usb 3.0 portable hard drive 500gb | hard drives | verbatim |     97397 |   69.98 |

Entity B:
| title                                                                            | category             | brand   |   modelno |   price |
|:---------------------------------------------------------------------------------|:---------------------|:--------|----------:|--------:|
| iomega 500gb ego portable hard drive superspeed usb 3.0 usb 2.0 ruby red - 35312 | external hard drives | iomega  |     35312 |   74.71 |



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

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

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

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

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2389
rtable_id: 820
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 |
|:--------------------------------------------|:----------------------|:------------|:----------|--------:|
| human toolz 3-in-1 netbook pad designer tan | electronics - general | human toolz | 3n1mdt    |    9.88 |

Entity B:
| title                                           | category   | brand      | modelno   |   price |
|:------------------------------------------------|:-----------|:-----------|:----------|--------:|
| human toolz usb mouse 3-in-1 netbook pad bundle | mice       | humantoolz | m3n1m100c |   17.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2263
rtable_id: 6962
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 |
|:-----------------------------------------------------------------|:----------------------|:----------|:----------|--------:|
| night owl zeus-810 16-channel h. 264 dvr kit with 1tb hard drive | electronics - general | night owl |           |  773.82 |

Entity B:
| title                                                                        | category                   | brand            | modelno   |   price |
|:-----------------------------------------------------------------------------|:---------------------------|:-----------------|:----------|--------:|
| night owl security zeus-dvr 16-channel h. 264 dvr with d1 recording and hdmi | digital security recorders | night owl optics | zeus-dvr  |  350.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2092
rtable_id: 13765
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 |
|:---------------------------------------------|:----------------------|:---------|----------:|--------:|
| fellowes office suites monitor riser 8031101 | electronics - general | fellowes |   8031101 |   38.88 |

Entity B:
| title                                                    | category            | brand    |   modelno |   price |
|:---------------------------------------------------------|:--------------------|:---------|----------:|--------:|
| fellowes smart suites corner monitor riser black 8020101 | monitor arms stands | fellowes |   8020101 |   21.33 |



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

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

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

Entity A:
| title                                             | category   | brand    |   modelno |   price |
|:--------------------------------------------------|:-----------|:---------|----------:|--------:|
| verbatim 96438 2gb store n go usb 2.0 flash drive | usb drives | verbatim |     96438 |   14.84 |

Entity B:
| title                                                  | category         | brand    |   modelno |   price |
|:-------------------------------------------------------|:-----------------|:---------|----------:|--------:|
| verbatim store n go 2 gb usb 2.0 flash drive 95183 red | usb flash drives | verbatim |     95183 |   10.39 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 547
rtable_id: 15267
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 xms2 2gb 2 x 1gb pc2-6400 800mhz 240-pin ddr2 cl5 dual channel desktop memory kit - twin2x4096-6400c5c | memory     | corsair | twin2x4096-6400c5c |   72.82 |

Entity B:
| title                                                                                      | category              | brand   | modelno       |   price |
|:-------------------------------------------------------------------------------------------|:----------------------|:--------|:--------------|--------:|
| corsair memory vs4gbkit800d2 4 gb pc2-6400 800mhz 240-pin ddr2 dual channel desktop memory | computers accessories | corsair | vs4gbkit800d2 |   44.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 324
rtable_id: 8516
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 |
|:-------------------------|:----------------|:--------|-------------:|--------:|
| marware eco-vue for ipad | mp3 accessories |         | 602956006572 |   54.99 |

Entity B:
| title                                   | category                            | brand   |      modelno |   price |
|:----------------------------------------|:------------------------------------|:--------|-------------:|--------:|
| marware sportshell convertible for ipad | laptop netbook computer accessories | marware | 602956006619 |    6.99 |



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

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

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

Entity A:
| title                                                            | category    | brand    |   modelno |   price |
|:-----------------------------------------------------------------|:------------|:---------|----------:|--------:|
| verbatim store n go superspeed usb 3.0 portable hard drive 500gb | hard drives | verbatim |     97397 |   69.98 |

Entity B:
| title                                    | category             | brand    |   modelno |   price |
|:-----------------------------------------|:---------------------|:---------|----------:|--------:|
| verbatim usb store n go memory drive 8gb | computer accessories | verbatim |     95507 |    15.4 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 465
rtable_id: 9293
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 3 high speed hdmi cable | electronics - general | philips | swv3431w/17 |   10.43 |

Entity B:
| title                                                     | category    | brand   | modelno     |   price |
|:----------------------------------------------------------|:------------|:--------|:------------|--------:|
| philips swivel high speed hdmi cable with ethernet 8 feet | hdmi cables | philips | sww1436u/27 |   24.98 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2424
rtable_id: 11723
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 |
|:--------------------------------------------------------------------|:-----------|:------------|:--------------|--------:|
| lexar media ljdff2gbasbna 2gb jumpdrive firefly usb 2.0 flash drive | usb drives | lexar media | ljdff2gbasbna |   13.88 |

Entity B:
| title                                                        | category             | brand   | modelno     |   price |
|:-------------------------------------------------------------|:---------------------|:--------|:------------|--------:|
| lexar jumpdrive firefly 4 gb usb 2.0 flash drive jdff4gb-431 | computer accessories | lexar   | jdff4gb-431 |    9.99 |



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

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

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

Entity A:
| title                                      | category   | brand   | modelno   |   price |
|:-------------------------------------------|:-----------|:--------|:----------|--------:|
| edge 8gb diskgo usb 2.0 flash drive silver | usb drives | edge    | pe204198  |   10.98 |

Entity B:
| title                                  | category   | brand   | modelno         |   price |
|:---------------------------------------|:-----------|:--------|:----------------|--------:|
| 32gb diskgo secure flash drive usb 2.0 |            | edge    | edgdm-214982-pe |   51.32 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1661
rtable_id: 9942
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-glas self trimming rear projection screen - 60 x 80 video format | projection screens | da-lite |           | 3095.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1257
rtable_id: 18165
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 cat5e snagless network patch cable blue | electronics - general | v7      | v7n3c5e-10f-blus |    4.88 |

Entity B:
| title                                                                                        | category        | brand   | modelno          |   price |
|:---------------------------------------------------------------------------------------------|:----------------|:--------|:-----------------|--------:|
| v7 cat5e snagless molded network patch cable rj45 male to male black 2-feet v7n3c5e-02f-blks | ethernet cables | v7      | v7n3c5e-02f-blks |    2.83 |



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

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

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

Entity A:
| title                                         | category    | brand   | modelno   |   price |
|:----------------------------------------------|:------------|:--------|:----------|--------:|
| hitachi 500gb touro mobile usb 2.0 hard drive | hard drives | hitachi | 0s03121   |   64.98 |

Entity B:
| title                                                                   | category             | brand   | modelno         |   price |
|:------------------------------------------------------------------------|:---------------------|:--------|:----------------|--------:|
| hitachi touro mobile 320 gb usb 2.0 external hard drive htolmxna3201abb | external hard drives | hitachi | htolmxna3201abb |   49.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 411
rtable_id: 20452
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 73235 - 5 1 4 inch expansion colored file pocket straight tab letter blue | blank media | smead   |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1338
rtable_id: 5497
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 |
|:---------------------------------------------|:----------------|:--------|----------:|--------:|
| amzer anti-glare screen protector for ipad 2 | mp3 accessories | amzer   |     90786 |   13.88 |

Entity B:
| title                                         | category               | brand   | modelno     |   price |
|:----------------------------------------------|:-----------------------|:--------|:------------|--------:|
| 3m natural view screen protector for ipad 9.7 | screen protector foils | 3m      | ipad 9.7 '' |   19.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 753
rtable_id: 485
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 |
|:------------------------------------------------------------|:--------------|:--------|:----------|--------:|
| xantech 100w decora-style impedance matching volume control | stereos/audio | xantech | xvcd100   |   56.88 |

Entity B:
| title                                                          | category                | brand   | modelno   |   price |
|:---------------------------------------------------------------|:------------------------|:--------|:----------|--------:|
| xantech xvcd100 decora style impedance matching volume control | audio video accessories | xantech | xvcd100   |   46.38 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 114
rtable_id: 9223
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 |
|:-----------------------------------------------|:----------------------|:-----------|:-------------|--------:|
| 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 lneo-12 12.1-inch neoprene netbook sleeve black | laptop netbook computer accessories | case logic | lneo-12black |   14.42 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2392
rtable_id: 14495
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 |
|:-----------------------------------------|:----------------------|:--------|----------:|--------:|
| allsop clingo universal hands free mount | electronics - general | allsop  |     30272 |   34.99 |

Entity B:
| title                                                                                            | category   | brand   |   modelno |   price |
|:-------------------------------------------------------------------------------------------------|:-----------|:--------|----------:|--------:|
| clingo universal hands-free car mount for iphone 4 3g 3gs and all cell phones and mobile devices | mounts     | allsop  |     30272 |   20.07 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1305
rtable_id: 2558
label: 1
Task: Entity-Matching (source dataset: Walmart-Amazon)

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

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

Entity A:
| title                                                                | category              | brand   |   modelno |   price |
|:---------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-plex deluxe rear projection screen - 36 x 48 video format | electronics - general | da-lite |     27559 | 1630.99 |

Entity B:
| title                                                                      | category           | brand   | modelno   |   price |
|:---------------------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| da-lite fast-fold deluxe screen system - projection screen - 16 9 - da-mat | projection screens | da-lite |           |  754.85 |



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

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

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

Entity A:
| title                                                                                                                 | category        | brand   | modelno    |   price |
|:----------------------------------------------------------------------------------------------------------------------|:----------------|:--------|:-----------|--------:|
| canon powershot elph 100 hs blue 12.1 mp digital camera with 4x optical zoom 3.0 lcd 1080p hd video w 50 bonus prints | digital cameras | canon   | 4925b001aa |  178.54 |

Entity B:
| title                                                                                     | category                    | brand   | modelno   |   price |
|:------------------------------------------------------------------------------------------|:----------------------------|:--------|:----------|--------:|
| canon powershot a495 10.0 mp digital camera with 3.3 x optical zoom and 2.5-inch lcd blue | point shoot digital cameras | canon   | a495 blue |      69 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1511
rtable_id: 21146
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 cherry veneer model b manual screen with matte white fabric - 96 x 96 video format | electronics - general | da-lite |     73263 |  446.99 |

Entity B:
| title                                                                                   | category           | brand   | modelno   | price   |
|:----------------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| medium oak 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: 1135
rtable_id: 21933
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 |
|:------------------------------------------------------------------|:---------------|:--------------|:----------|--------:|
| comprehensive 1 4 standard phone plug to 3-pin xlr jack set of 10 | tv accessories | comprehensive | spp-xlrj  |    79.9 |

Entity B:
| title                                                         | category   | brand         | modelno   | price   |
|:--------------------------------------------------------------|:-----------|:--------------|:----------|:--------|
| comprehensive spp 1 4 standard phone plug cable end set of 25 |            | comprehensive |           |         |



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

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

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

Entity A:
| title                                                                     | category              | brand   |   modelno |   price |
|:--------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-plex self trimming rear projection screen - 96 x 120 av format | electronics - general | da-lite |     27903 | 7799.99 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 561
rtable_id: 20429
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 cat5e snagless network patch cable blue | electronics - general | v7      | v7n3c5e-10f-blus |    4.88 |

Entity B:
| title                                                       | category             | brand   | modelno         |   price |
|:------------------------------------------------------------|:---------------------|:--------|:----------------|--------:|
| v7 cat5e snagless patch cable rj45 male to male gray 3 feet | cables interconnects | v7      | v7-c5e-03-gry-s |    4.24 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 305
rtable_id: 21847
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 t020201 color ink cartridge | printers   | epson   | t020201   |      27 |

Entity B:
| title                                | category           | brand   | modelno   |   price |
|:-------------------------------------|:-------------------|:--------|:----------|--------:|
| epson t001011 color inkjet cartridge | inkjet printer ink | epson   | t001011   |   26.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 65
rtable_id: 3882
label: 0