MMTU-benchmark/MMTU huggingface dataset:
Task: Entity-Matching (source dataset: BeerAdvo-RateBeer)

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:
| Beer_Name               | Brew_Factory_Name    | Style                    | ABV    |
|:------------------------|:---------------------|:-------------------------|:-------|
| Mountain City Amber Ale | Tommyknocker Brewery | American Amber / Red Ale | 5.40 % |

Entity B:
| Beer_Name                            | Brew_Factory_Name         | Style     | ABV    |
|:-------------------------------------|:--------------------------|:----------|:-------|
| Colorado Mountain Ole 59er Amber Ale | Colorado Mountain Brewery | Amber Ale | 5.20 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2115
rtable_id: 77
label: 0
Task: Entity-Matching (source dataset: BeerAdvo-RateBeer)

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:
| Beer_Name                       | Brew_Factory_Name        | Style                    | ABV    |
|:--------------------------------|:-------------------------|:-------------------------|:-------|
| Red Hopper ( Imperial Red Ale ) | Black Acre Brewing Co. . | American Amber / Red Ale | 6.20 % |

Entity B:
| Beer_Name                         | Brew_Factory_Name       | Style               | ABV    |
|:----------------------------------|:------------------------|:--------------------|:-------|
| Kinetic Infrared Imperial Red Ale | Kinetic Brewing Company | American Strong Ale | 9.30 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2026
rtable_id: 1496
label: 0
Task: Entity-Matching (source dataset: BeerAdvo-RateBeer)

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:
| Beer_Name                         | Brew_Factory_Name    | Style                    | ABV    |
|:----------------------------------|:---------------------|:-------------------------|:-------|
| Red Shedman 's Imperial Amber Ale | 57 Brew Pub & Bistro | American Amber / Red Ale | 7.60 % |

Entity B:
| Beer_Name                                               | Brew_Factory_Name       | Style               | ABV    |
|:--------------------------------------------------------|:------------------------|:--------------------|:-------|
| Rock Bottom Orland Park King of Hearts Imperial Red Ale | Rock Bottom Orland Park | American Strong Ale | 7.60 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 3402
rtable_id: 1889
label: 0
Task: Entity-Matching (source dataset: BeerAdvo-RateBeer)

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:
| Beer_Name                | Brew_Factory_Name          | Style                    | ABV    |
|:-------------------------|:---------------------------|:-------------------------|:-------|
| Barrel Aged Imperial Red | Hale 's Ales Brewery & Pub | American Amber / Red Ale | 9.00 % |

Entity B:
| Beer_Name                                              | Brew_Factory_Name            | Style               | ABV   |
|:-------------------------------------------------------|:-----------------------------|:--------------------|:------|
| Kettle House Bourbon Barrel Road Rash Imperial Red Ale | Kettle House Brewing Company | American Strong Ale | 13 %  |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1661
rtable_id: 1428
label: 0
Task: Entity-Matching (source dataset: BeerAdvo-RateBeer)

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:
| Beer_Name                                          | Brew_Factory_Name            | Style                    | ABV    |
|:---------------------------------------------------|:-----------------------------|:-------------------------|:-------|
| Starlord 's Mixtape / Groot Drank Imperial Red Ale | Charging Hippo Brewing Co. . | American Amber / Red Ale | 8.20 % |

Entity B:
| Beer_Name                  | Brew_Factory_Name                              | Style               | ABV    |
|:---------------------------|:-----------------------------------------------|:--------------------|:-------|
| Lagunitas Imperial Red Ale | Lagunitas Brewing Company &#40; Heineken &#41; | American Strong Ale | 7.80 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 3626
rtable_id: 90
label: 0
Task: Entity-Matching (source dataset: BeerAdvo-RateBeer)

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:
| Beer_Name             | Brew_Factory_Name     | Style                    | ABV    |
|:----------------------|:----------------------|:-------------------------|:-------|
| Main Street Amber Ale | Fifty West Brewing Co | American Amber / Red Ale | 4.60 % |

Entity B:
| Beer_Name                                   | Brew_Factory_Name    | Style     | ABV    |
|:--------------------------------------------|:---------------------|:----------|:-------|
| Thorn Street Smugglers Cove Agave Amber Ale | Thorn Street Brewery | Amber Ale | 6.20 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1900
rtable_id: 333
label: 0
Task: Entity-Matching (source dataset: BeerAdvo-RateBeer)

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:
| Beer_Name       | Brew_Factory_Name          | Style                    | ABV    |
|:----------------|:---------------------------|:-------------------------|:-------|
| Honey Amber Ale | RJ Rockers Brewing Company | American Amber / Red Ale | 5.80 % |

Entity B:
| Beer_Name                                                | Brew_Factory_Name          | Style     | ABV    |
|:---------------------------------------------------------|:---------------------------|:----------|:-------|
| Heavy Seas Desert Island Series American Honey Amber Ale | Heavy Seas Brewing Company | Amber Ale | 4.90 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 507
rtable_id: 716
label: 0
Task: Entity-Matching (source dataset: BeerAdvo-RateBeer)

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:
| Beer_Name                      | Brew_Factory_Name        | Style                    | ABV    |
|:-------------------------------|:-------------------------|:-------------------------|:-------|
| Double Dragon Imperial Red Ale | Phillips Brewing Company | American Amber / Red Ale | 8.20 % |

Entity B:
| Beer_Name                               | Brew_Factory_Name         | Style               | ABV    |
|:----------------------------------------|:--------------------------|:--------------------|:-------|
| Scuttlebutt Mateo Loco Imperial Red Ale | Scuttlebutt Brewing Co. . | American Strong Ale | 7.10 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 492
rtable_id: 1635
label: 0
Task: Entity-Matching (source dataset: BeerAdvo-RateBeer)

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:
| Beer_Name                                          | Brew_Factory_Name            | Style                    | ABV    |
|:---------------------------------------------------|:-----------------------------|:-------------------------|:-------|
| Starlord 's Mixtape / Groot Drank Imperial Red Ale | Charging Hippo Brewing Co. . | American Amber / Red Ale | 8.20 % |

Entity B:
| Beer_Name            | Brew_Factory_Name   | Style               | ABV    |
|:---------------------|:--------------------|:--------------------|:-------|
| 406 Imperial Red Ale | 406 Brewing Company | American Strong Ale | 9.20 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 3626
rtable_id: 646
label: 0
Task: Entity-Matching (source dataset: BeerAdvo-RateBeer)

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:
| Beer_Name         | Brew_Factory_Name          | Style                    | ABV    |
|:------------------|:---------------------------|:-------------------------|:-------|
| Honey Basil Amber | Rude Hippo Brewing Company | American Amber / Red Ale | 7.40 % |

Entity B:
| Beer_Name                    | Brew_Factory_Name   | Style     | ABV    |
|:-----------------------------|:--------------------|:----------|:-------|
| Rude Hippo Honey Basil Amber | 18th Street Brewery | Amber Ale | 7.40 % |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 3917
rtable_id: 2224
label: 1
Task: Entity-Matching (source dataset: BeerAdvo-RateBeer)

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:
| Beer_Name                                | Brew_Factory_Name          | Style                    | ABV    |
|:-----------------------------------------|:---------------------------|:-------------------------|:-------|
| Smuttynose Kindest Find Imperial Red Ale | Smuttynose Brewing Company | American Amber / Red Ale | 8.50 % |

Entity B:
| Beer_Name                                               | Brew_Factory_Name       | Style               | ABV    |
|:--------------------------------------------------------|:------------------------|:--------------------|:-------|
| Rock Bottom Orland Park King of Hearts Imperial Red Ale | Rock Bottom Orland Park | American Strong Ale | 7.60 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 184
rtable_id: 1889
label: 0
Task: Entity-Matching (source dataset: BeerAdvo-RateBeer)

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:
| Beer_Name                  | Brew_Factory_Name   | Style                    | ABV    |
|:---------------------------|:--------------------|:-------------------------|:-------|
| Imperial Moustache Red Ale | Salty Nut Brewery   | American Amber / Red Ale | 6.00 % |

Entity B:
| Beer_Name                               | Brew_Factory_Name      | Style               | ABV    |
|:----------------------------------------|:-----------------------|:--------------------|:-------|
| Phillips Double Dragon Imperial Red Ale | Phillips Brewing Co. . | American Strong Ale | 8.20 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2972
rtable_id: 218
label: 0
Task: Entity-Matching (source dataset: BeerAdvo-RateBeer)

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:
| Beer_Name                              | Brew_Factory_Name               | Style                    | ABV     |
|:---------------------------------------|:--------------------------------|:-------------------------|:--------|
| Bourbon Barrel Aged Horus Imperial Red | Elevator Brewery & Draught Haus | American Amber / Red Ale | 12.00 % |

Entity B:
| Beer_Name                                 | Brew_Factory_Name   | Style       | ABV    |
|:------------------------------------------|:--------------------|:------------|:-------|
| Lompoc Bourbon Barrel Aged Old Tavern Rat | Lompoc Brewing      | Barley Wine | 9.70 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1218
rtable_id: 2463
label: 0
Task: Entity-Matching (source dataset: BeerAdvo-RateBeer)

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:
| Beer_Name                  | Brew_Factory_Name   | Style                    | ABV    |
|:---------------------------|:--------------------|:-------------------------|:-------|
| Red Dread Imperial Red Ale | Bitter Root Brewing | American Amber / Red Ale | 8.24 % |

Entity B:
| Beer_Name                             | Brew_Factory_Name            | Style               | ABV    |
|:--------------------------------------|:-----------------------------|:--------------------|:-------|
| Two Brothers Revelry Imperial Red Ale | Two Brothers Brewing Company | American Strong Ale | 9.50 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 652
rtable_id: 1534
label: 0
Task: Entity-Matching (source dataset: BeerAdvo-RateBeer)

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:
| Beer_Name                    | Brew_Factory_Name         | Style                    | ABV    |
|:-----------------------------|:--------------------------|:-------------------------|:-------|
| Green Flash Hop Head Red Ale | Green Flash Brewing Co. . | American Amber / Red Ale | 8.10 % |

Entity B:
| Beer_Name              | Brew_Factory_Name   | Style     | ABV    |
|:-----------------------|:--------------------|:----------|:-------|
| Bagby Hop Crop Red Ale | Bagby Beer Company  | Amber Ale | 5.90 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 3
rtable_id: 439
label: 0
Task: Entity-Matching (source dataset: BeerAdvo-RateBeer)

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:
| Beer_Name         | Brew_Factory_Name                 | Style                    | ABV    |
|:------------------|:----------------------------------|:-------------------------|:-------|
| Arrow Point Amber | Bainbridge Island Brewing Company | American Amber / Red Ale | 5.40 % |

Entity B:
| Beer_Name                           | Brew_Factory_Name                 | Style     | ABV    |
|:------------------------------------|:----------------------------------|:----------|:-------|
| Bainbridge Island Arrow Point Amber | Bainbridge Island Brewing Company | Amber Ale | 5.40 % |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2558
rtable_id: 1284
label: 1
Task: Entity-Matching (source dataset: BeerAdvo-RateBeer)

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:
| Beer_Name                            | Brew_Factory_Name    | Style                    | ABV    |
|:-------------------------------------|:---------------------|:-------------------------|:-------|
| Imperial Red Ale ( Spring Seasonal ) | Edge Brewing Company | American Amber / Red Ale | 8.50 % |

Entity B:
| Beer_Name                                     | Brew_Factory_Name             | Style               | ABV   |
|:----------------------------------------------|:------------------------------|:--------------------|:------|
| Ballast Point Tongue Buckler Imperial Red Ale | Ballast Point Brewing Company | American Strong Ale | 10 %  |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 3098
rtable_id: 1638
label: 0
Task: Entity-Matching (source dataset: BeerAdvo-RateBeer)

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:
| Beer_Name               | Brew_Factory_Name   | Style                    | ABV    |
|:------------------------|:--------------------|:-------------------------|:-------|
| Green Lakes Organic Ale | Deschutes Brewery   | American Amber / Red Ale | 5.20 % |

Entity B:
| Beer_Name                             | Brew_Factory_Name   | Style     | ABV    |
|:--------------------------------------|:--------------------|:----------|:-------|
| Deschutes Green Lakes Non-Organic Ale | Deschutes Brewery   | Amber Ale | 6.40 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 76
rtable_id: 2831
label: 0
Task: Entity-Matching (source dataset: BeerAdvo-RateBeer)

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:
| Beer_Name                | Brew_Factory_Name      | Style               | ABV     |
|:-------------------------|:-----------------------|:--------------------|:--------|
| Lower De Boom Barleywine | 21st Amendment Brewery | American Barleywine | 11.50 % |

Entity B:
| Beer_Name                                              | Brew_Factory_Name      | Style       | ABV    |
|:-------------------------------------------------------|:-----------------------|:------------|:-------|
| 21st Amendment Bourbon Barrel Lower da Boom Barleywine | 21st Amendment Brewery | Barley Wine | 9.50 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 4027
rtable_id: 2510
label: 0
Task: Entity-Matching (source dataset: BeerAdvo-RateBeer)

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:
| Beer_Name             | Brew_Factory_Name        | Style                    | ABV    |
|:----------------------|:-------------------------|:-------------------------|:-------|
| Red Rock Opie Red Ale | Red Rock Brewing Company | American Amber / Red Ale | 4.00 % |

Entity B:
| Beer_Name                          | Brew_Factory_Name    | Style     | ABV   |
|:-----------------------------------|:---------------------|:----------|:------|
| Council Rock Sleeping Lion Red Ale | Council Rock Brewery | Irish Ale | 6 %   |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2572
rtable_id: 221
label: 0
Task: Entity-Matching (source dataset: iTunes-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:
| Song_Name                    | Artist_Name   | Album_Name   | Genre                                                  | Price   | CopyRight                                                                                                                                                                                | Time   | Released   |
|:-----------------------------|:--------------|:-------------|:-------------------------------------------------------|:--------|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:-------|:-----------|
| The Whisperer ( feat . Sia ) | David Guetta  | Listen       | Dance , Music , Electronic , House , Rock , French Pop | $ 1.29  | 2014 What A Music Ltd. under exclusive license to Parlophone/Warner Music France , under exclusive license to Atlantic Recording Corporation for the United States . All rights reserved | 3:54   | 24-Nov-14  |

Entity B:
| Song_Name                            | Artist_Name   | Album_Name   | Genre              | Price   | CopyRight                | Time   | Released           |
|:-------------------------------------|:--------------|:-------------|:-------------------|:--------|:-------------------------|:-------|:-------------------|
| Goodbye Friend ( feat . The Script ) | David Guetta  | Listen       | Dance & Electronic | $ 1.29  | 2015 If Moving Your Mine | 3:49   | November 24 , 2014 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1195
rtable_id: 28061
label: 0
Task: Entity-Matching (source dataset: iTunes-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:
| Song_Name                            | Artist_Name                               | Album_Name                              | Genre                      | Price   | CopyRight                                                                                                             | Time   | Released   |
|:-------------------------------------|:------------------------------------------|:----------------------------------------|:---------------------------|:--------|:----------------------------------------------------------------------------------------------------------------------|:-------|:-----------|
| Make It Bun Dem ( Alvin Risk Remix ) | Skrillex & Damian `` Jr. . Gong '' Marley | Make It Bun Dem After Hours ( Remixes ) | Dance , Music , Electronic | $ 1.29  | 2012 OWSLA and Big Beat Records for the United States and WEA International for the world outside the United States . | 3:58   | 28-Aug-12  |

Entity B:
| Song_Name                                  | Artist_Name                            | Album_Name                     | Genre              | Price   | CopyRight   | Time   | Released         |
|:-------------------------------------------|:---------------------------------------|:-------------------------------|:-------------------|:--------|:------------|:-------|:-----------------|
| Make It Bun Dem ( David Heartbreak Remix ) | Skrillex & Damian Jr Gong '' Marley '' | Make It Bun Dem After Hours EP | Dance & Electronic | $ 1.29  | 2015 RGK    | 3:29   | August 28 , 2012 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 4698
rtable_id: 30404
label: 0
Task: Entity-Matching (source dataset: iTunes-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:
| Song_Name   | Artist_Name   | Album_Name     | Genre                                                     | Price   | CopyRight                                                                                                                       | Time   | Released   |
|:------------|:--------------|:---------------|:----------------------------------------------------------|:--------|:--------------------------------------------------------------------------------------------------------------------------------|:-------|:-----------|
| Cameras     | Wiz Khalifa   | Rolling Papers | Hip-Hop/Rap , Music , Rap , East Coast Rap , Hardcore Rap | $ 1.29  | 2011 Atlantic Recording Corporation for the United States and WEA International Inc. for the world outside of the United States | 4:29   | 28-Mar-11  |

Entity B:
| Song_Name         | Artist_Name   | Album_Name               | Genre         | Price   | CopyRight                                                                                                                       | Time   | Released        |
|:------------------|:--------------|:-------------------------|:--------------|:--------|:--------------------------------------------------------------------------------------------------------------------------------|:-------|:----------------|
| Cameras [ Clean ] | Wiz Khalifa   | Rolling Papers [ Clean ] | Rap & Hip-Hop | $ 1.29  | 2011 Atlantic Recording Corporation for the United States and WEA International Inc. for the world outside of the United States | 4:29   | March 28 , 2011 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 3356
rtable_id: 39335
label: 1
Task: Entity-Matching (source dataset: iTunes-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:
| Song_Name                | Artist_Name   | Album_Name           | Genre                     | Price      | CopyRight                              | Time   | Released   |
|:-------------------------|:--------------|:---------------------|:--------------------------|:-----------|:---------------------------------------|:-------|:-----------|
| Whateva ( feat . Monty ) | Fetty Wap     | Fetty Wap ( Deluxe ) | Hip-Hop/Rap , Music , Rap | Album Only | 2015 300 Entertainment/RGF Productions | 5:11   |            |

Entity B:
| Song_Name                         | Artist_Name   | Album_Name                     | Genre         | Price   | CopyRight                                                                           | Time   | Released            |
|:----------------------------------|:--------------|:-------------------------------|:--------------|:--------|:------------------------------------------------------------------------------------|:-------|:--------------------|
| Rewind ( feat . Monty ) [ Clean ] | Fetty Wap     | Fetty Wap ( Deluxe ) [ Clean ] | Rap & Hip-Hop | $ 1.29  | ( C ) 2000 Mute Records Ltd. , a BMG Company , under exclusive license to INgrooves | 5:36   | September 25 , 2015 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2748
rtable_id: 17158
label: 0
Task: Entity-Matching (source dataset: iTunes-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:
| Song_Name                                 | Artist_Name   | Album_Name     | Genre                                   | Price   | CopyRight                                                                                                                       | Time   | Released   |
|:------------------------------------------|:--------------|:---------------|:----------------------------------------|:--------|:--------------------------------------------------------------------------------------------------------------------------------|:-------|:-----------|
| Money Right ( feat . Rick Ross & Brisco ) | Flo Rida      | Mail On Sunday | Hip-Hop/Rap , Music , Pop , Dirty South | $ 1.29  | 2008 Atlantic Recording Corporation for the United States and WEA International Inc. for the world outside of the United States | 3:16   | 18-Mar-08  |

Entity B:
| Song_Name                               | Artist_Name   | Album_Name               | Genre                                  | Price   | CopyRight                        | Time   | Released        |
|:----------------------------------------|:--------------|:-------------------------|:---------------------------------------|:--------|:---------------------------------|:-------|:----------------|
| Roll ( feat . Sean Kingston ) [ Clean ] | Flo Rida      | Mail On Sunday [ Clean ] | Rap & Hip-Hop , Southern Rap , Pop Rap | $ 1.29  | 2013 Warner Bros. . Records Inc. | 3:59   | March 18 , 2008 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 3610
rtable_id: 30322
label: 0
Task: Entity-Matching (source dataset: iTunes-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:
| Song_Name                           | Artist_Name   | Album_Name   | Genre                                                                       | Price   | CopyRight                                                                     | Time   | Released   |
|:------------------------------------|:--------------|:-------------|:----------------------------------------------------------------------------|:--------|:------------------------------------------------------------------------------|:-------|:-----------|
| Epilogue ( feat . George the Poet ) | Naughty Boy   | Hotel Cabana | Pop , Music , R&B / Soul , Contemporary R&B , Hip-Hop/Rap , Pop/Rock , Rock | $ 1.29  | 2014 Naughty Boy Recordings Ltd under exclusive licence to Virgin Records Ltd | 1:28   | 6-May-14   |

Entity B:
| Song_Name                       | Artist_Name   | Album_Name                | Genre   | Price   | CopyRight                                                                           | Time   | Released     |
|:--------------------------------|:--------------|:--------------------------|:--------|:--------|:------------------------------------------------------------------------------------|:-------|:-------------|
| Lifted [ feat . Emeli SandÌ © ] | Naughty Boy   | Hotel Cabana [ Explicit ] | Pop     | $ 1.29  | ( C ) 2014 Naughty Boy Recordings Ltd under exclusive licence to Virgin Records Ltd | 3:17   | May 6 , 2014 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 313
rtable_id: 22314
label: 0
Task: Entity-Matching (source dataset: iTunes-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:
| Song_Name                                 | Artist_Name   | Album_Name     | Genre                                   | Price   | CopyRight                                                                                                                       | Time   | Released   |
|:------------------------------------------|:--------------|:---------------|:----------------------------------------|:--------|:--------------------------------------------------------------------------------------------------------------------------------|:-------|:-----------|
| Money Right ( feat . Rick Ross & Brisco ) | Flo Rida      | Mail On Sunday | Hip-Hop/Rap , Music , Pop , Dirty South | $ 1.29  | 2008 Atlantic Recording Corporation for the United States and WEA International Inc. for the world outside of the United States | 3:16   | 18-Mar-08  |

Entity B:
| Song_Name                                            | Artist_Name   | Album_Name                  | Genre         | Price   | CopyRight                        | Time   | Released        |
|:-----------------------------------------------------|:--------------|:----------------------------|:--------------|:--------|:---------------------------------|:-------|:----------------|
| American Superstar ( feat . Lil Wayne ) [ Explicit ] | Flo Rida      | Mail On Sunday [ Explicit ] | Rap & Hip-Hop | $ 1.29  | 2013 Warner Bros. . Records Inc. | 3:42   | March 17 , 2008 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 3611
rtable_id: 30333
label: 0
Task: Entity-Matching (source dataset: iTunes-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:
| Song_Name       | Artist_Name   | Album_Name          | Genre                                                                                | Price   | CopyRight                                                                                                                | Time   | Released   |
|:----------------|:--------------|:--------------------|:-------------------------------------------------------------------------------------|:--------|:-------------------------------------------------------------------------------------------------------------------------|:-------|:-----------|
| Rashi ( Outro ) | Mark Ronson   | Here Comes the Fuzz | Dance,Music,Hip-Hop / Rap , Alternative Rap,Hip-Hop , R&B / Soul , Soul , Electronic | $ 0.99  | 2003 Elektra Entertainment for the United States and WEA International Inc. for the world outside of the United States . | 2:01   | 29-Aug-03  |

Entity B:
| Song_Name       | Artist_Name   | Album_Name                       | Genre              | Price   | CopyRight                 | Time   | Released         |
|:----------------|:--------------|:---------------------------------|:-------------------|:--------|:--------------------------|:-------|:-----------------|
| Rashi ( Outro ) | Mark Ronson   | Here Comes The Fuzz [ Explicit ] | Dance & Electronic | $ 0.99  | ( c ) 2015 Karaoke Freaks | 2:01   | August 29 , 2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2913
rtable_id: 21458
label: 1
Task: Entity-Matching (source dataset: iTunes-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:
| Song_Name              | Artist_Name    | Album_Name   | Genre                                                                     | Price   | CopyRight                                                                                                                                                      | Time   | Released   |
|:-----------------------|:---------------|:-------------|:--------------------------------------------------------------------------|:--------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------|:-------|:-----------|
| Going Away For a While | Brett Eldredge | Illinois     | Country , Music , Contemporary Country , Honky Tonk , Traditional Country | $ 1.29  | 2015 Atlantic Recording Corporation for the United States and WEA International Inc. for the world outside of the United States . A Warner Music Group Company | 3:13   | 11-Sep-15  |

Entity B:
| Song_Name              | Artist_Name    | Album_Name   | Genre   | Price   | CopyRight       | Time   | Released            |
|:-----------------------|:---------------|:-------------|:--------|:--------|:----------------|:-------|:--------------------|
| Going Away For A While | Brett Eldredge | Illinois     | Country | $ 1.29  | ( c ) Phonotype | 3:15   | September 11 , 2015 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 3870
rtable_id: 23889
label: 1
Task: Entity-Matching (source dataset: iTunes-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:
| Song_Name          | Artist_Name    | Album_Name                          | Genre               | Price   | CopyRight                | Time   | Released   |
|:-------------------|:---------------|:------------------------------------|:--------------------|:--------|:-------------------------|:-------|:-----------|
| Lights ( RAC Mix ) | Ellie Goulding | Lights , Pt. 2 ( The Remixes ) - EP | Dance , Music , Pop | $ 1.29  | 2011 Polydor Ltd. ( UK ) | 5:44   | 19-Jul-11  |

Entity B:
| Song_Name                 | Artist_Name    | Album_Name                                                | Genre   | Price   | CopyRight                      | Time   | Released       |
|:--------------------------|:---------------|:----------------------------------------------------------|:--------|:--------|:-------------------------------|:-------|:---------------|
| Lights ( Single Version ) | Ellie Goulding | Lights ( Amazon Exclusive Version ) [ + Digital Booklet ] | Pop     | $ 1.29  | ( C ) 2011 Polydor Ltd. ( UK ) | 3:32   | March 8 , 2011 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 4206
rtable_id: 27799
label: 0
Task: Entity-Matching (source dataset: iTunes-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:
| Song_Name                    | Artist_Name   | Album_Name   | Genre                                                  | Price   | CopyRight                                                                                                                                                                                | Time   | Released   |
|:-----------------------------|:--------------|:-------------|:-------------------------------------------------------|:--------|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:-------|:-----------|
| The Whisperer ( feat . Sia ) | David Guetta  | Listen       | Dance , Music , Electronic , House , Rock , French Pop | $ 1.29  | 2014 What A Music Ltd. under exclusive license to Parlophone/Warner Music France , under exclusive license to Atlantic Recording Corporation for the United States . All rights reserved | 3:54   | 24-Nov-14  |

Entity B:
| Song_Name                   | Artist_Name   | Album_Name        | Genre              | Price   | CopyRight                | Time   | Released           |
|:----------------------------|:--------------|:------------------|:-------------------|:--------|:-------------------------|:-------|:-------------------|
| Rise ( feat . Skylar Grey ) | David Guetta  | Listen ( Deluxe ) | Dance & Electronic | $ 1.29  | 2015 If Moving Your Mine | 3:55   | November 24 , 2014 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1199
rtable_id: 27992
label: 0
Task: Entity-Matching (source dataset: iTunes-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:
| Song_Name                          | Artist_Name   | Album_Name                    | Genre                                                     | Price   | CopyRight                                                                                                                       | Time   | Released   |
|:-----------------------------------|:--------------|:------------------------------|:----------------------------------------------------------|:--------|:--------------------------------------------------------------------------------------------------------------------------------|:-------|:-----------|
| Remember You ( feat . The Weeknd ) | Wiz Khalifa   | O.N.I.F.C. ( Deluxe Version ) | Hip-Hop/Rap , Music , East Coast Rap , Hardcore Rap , Rap | $ 1.99  | 2012 Atlantic Recording Corporation for the United States and WEA International Inc. for the world outside of the United States | 5:20   | 4-Dec-12   |

Entity B:
| Song_Name                                      | Artist_Name   | Album_Name              | Genre         | Price   | CopyRight                                                                                                                       | Time   | Released          |
|:-----------------------------------------------|:--------------|:------------------------|:--------------|:--------|:--------------------------------------------------------------------------------------------------------------------------------|:-------|:------------------|
| Initiation ( feat . Lola Monroe ) [ Explicit ] | Wiz Khalifa   | O.N.I.F.C. [ Explicit ] | Rap & Hip-Hop | $ 1.29  | 2012 Atlantic Recording Corporation for the United States and WEA International Inc. for the world outside of the United States | 4:29   | December 4 , 2012 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 3313
rtable_id: 34333
label: 0