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    |
|:--------------------------------------------|:--------------------------|:--------------------|:-------|
| Frost Quake Bourbon Barrel Aged Barley Wine | Wellington County Brewery | American Barleywine | 9.80 % |

Entity B:
| Beer_Name                                      | Brew_Factory_Name   | Style     | ABV    |
|:-----------------------------------------------|:--------------------|:----------|:-------|
| Lompoc Bourbon Barrel Aged Proletariat Red Ale | Lompoc Brewing      | Amber Ale | 6.40 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 4256
rtable_id: 1825
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   |
|:------------------------|:------------------------|:-------------------------|:------|
| Twisted Stick Amber Ale | Portneuf Valley Brewing | American Amber / Red Ale | -     |

Entity B:
| Beer_Name                                | Brew_Factory_Name              | Style     | ABV    |
|:-----------------------------------------|:-------------------------------|:----------|:-------|
| Sick N Twisted Pleasure Victim Amber Ale | Sick N Twisted Brewing Company | Amber Ale | 5.50 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1479
rtable_id: 1563
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    |
|:-------------------------------|:------------------------------------|:-------------------------|:-------|
| Buck And Ball Double Amber Ale | Natty Greene 's Pub & Brewing Co. . | American Amber / Red Ale | 6.80 % |

Entity B:
| Beer_Name                       | Brew_Factory_Name    | Style     | ABV    |
|:--------------------------------|:---------------------|:----------|:-------|
| Fox and Hound Red Fox Amber Ale | Anheuser-Busch InBev | Amber Ale | 5.10 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2444
rtable_id: 1348
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   |
|:-------------------------|:--------------------------|:-------------------------|:------|
| Ulysses Imperial Red Ale | Barley 's Brewing Company | American Amber / Red Ale | -     |

Entity B:
| Beer_Name                                 | Brew_Factory_Name        | Style               | ABV    |
|:------------------------------------------|:-------------------------|:--------------------|:-------|
| Renegade Scarlett Letter Imperial Red Ale | Renegade Brewing Company | American Strong Ale | 8.50 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 3130
rtable_id: 1414
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    |
|:-----------------------------|:---------------------------------|:-------------------------|:-------|
| Blue Bridge Amber Dry Hopped | Galveston Island Brewing Company | American Amber / Red Ale | 6.00 % |

Entity B:
| Beer_Name                        | Brew_Factory_Name        | Style     | ABV   |
|:---------------------------------|:-------------------------|:----------|:------|
| Winthrop Double Dry Hopped Amber | Winthrop Brewing Company | Amber Ale | -     |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2633
rtable_id: 2143
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     |
|:----------------------------------------------------------|:--------------------|:--------------------|:--------|
| Old Guardian Barley Wine Style Ale - Red Wine Barrel Aged | Stone Brewing Co. . | American Barleywine | 11.20 % |

Entity B:
| Beer_Name                                                 | Brew_Factory_Name   | Style     | ABV   |
|:----------------------------------------------------------|:--------------------|:----------|:------|
| Brew Bus Detour Series : Rollin Dirty Red Ale - Wood Aged | Cigar City Brewing  | Irish Ale | 5 %   |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 4117
rtable_id: 838
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 Headed Slut Amber Ale | Twisted K-8 Brewing Company | American Amber / Red Ale | 6.50 % |

Entity B:
| Beer_Name                   | Brew_Factory_Name   | Style              | ABV    |
|:----------------------------|:--------------------|:-------------------|:-------|
| Blue Cat Red Toad Amber Ale | Blue Cat Brew Pub   | Premium Bitter/ESB | 5.70 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 3842
rtable_id: 1853
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    |
|:-----------------------------|:------------------------------------------------------|:-------------------------|:-------|
| Good Medicine Strong Red Ale | Great Northern Brewing Co. / Black Star Draught House | American Amber / Red Ale | 7.50 % |

Entity B:
| Beer_Name                                   | Brew_Factory_Name           | Style                          | ABV    |
|:--------------------------------------------|:----------------------------|:-------------------------------|:-------|
| Good People Stepchild Belgian India Red Ale | Good People Brewing Company | India Pale Ale &#40; IPA &#41; | 7.80 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 501
rtable_id: 216
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    |
|:---------------------------------------|:-------------------------------------|:-------------------------|:-------|
| Brewmaster 's Reserve Imperial Red Ale | BJ 's Chicago Pizza & Brewery Inc. . | American Amber / Red Ale | 9.20 % |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1178
rtable_id: 1255
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    |
|:----------------------------------------------|:------------------------------|:--------------------|:-------|
| Three Sheets Barleywine ( Syrah Barrel Aged ) | Ballast Point Brewing Company | American Barleywine | 9.00 % |

Entity B:
| Beer_Name                                     | Brew_Factory_Name         | Style       | ABV     |
|:----------------------------------------------|:--------------------------|:------------|:--------|
| Tighthead Barrel Aged Old Kaya Dog Barleywine | Tighthead Brewing Company | Barley Wine | 10.30 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 4203
rtable_id: 2425
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     |
|:-------------------------------------------|:-------------------------|:--------------------|:--------|
| Inception Series - Runnin ' With The Devil | Nebraska Brewing Company | American Barleywine | 11.90 % |

Entity B:
| Beer_Name                                | Brew_Factory_Name   | Style        | ABV    |
|:-----------------------------------------|:--------------------|:-------------|:-------|
| 18th Street Deal With the Devil Pale Ale | 18th Street Brewery | Imperial IPA | 8.50 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 4181
rtable_id: 2300
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    |
|:------------------------|:---------------------|:-------------------------|:-------|
| Clifford 's Big Red Ale | Funky Buddha Brewery | American Amber / Red Ale | 9.70 % |

Entity B:
| Beer_Name                | Brew_Factory_Name   | Style               | ABV    |
|:-------------------------|:--------------------|:--------------------|:-------|
| Big Island Red Giant Ale | Big Island Brewhaus | American Strong Ale | 6.50 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2155
rtable_id: 2948
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    |
|:------------------------|:---------------------|:-------------------------|:-------|
| Mountain City Amber Ale | Tommyknocker Brewery | American Amber / Red Ale | 5.40 % |

Entity B:
| Beer_Name                   | Brew_Factory_Name        | Style     | ABV    |
|:----------------------------|:-------------------------|:----------|:-------|
| Fin City Jackspot Amber Ale | Fin City Brewing Company | Amber Ale | 5.80 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2115
rtable_id: 2673
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    |
|:--------------------------------------|:--------------------------|:--------------------|:-------|
| Brannon_s Deputation Imperial Red Ale | Brannon_s Pub and Brewery | American Strong Ale | 8.79 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2026
rtable_id: 1679
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    |
|:--------------------|:---------------------------------|:-------------------------|:-------|
| Rock Bottom Red Ale | Rock Bottom Restaurant & Brewery | American Amber / Red Ale | 5.60 % |

Entity B:
| Beer_Name                           | Brew_Factory_Name    | Style     | ABV    |
|:------------------------------------|:---------------------|:----------|:-------|
| Rock Bottom La Jolla Ragtop Red Ale | Rock Bottom La Jolla | Amber Ale | 5.40 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 200
rtable_id: 559
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    |
|:------------------------|:--------------------|:-------------------------|:-------|
| Jazz Beer Tarraco Amber | Tarraco Beer        | American Amber / Red Ale | 6.90 % |

Entity B:
| Beer_Name               | Brew_Factory_Name             | Style     | ABV    |
|:------------------------|:------------------------------|:----------|:-------|
| Jazz Beer Tarraco Amber | Ca l_Arenys - Cervezas Guineu | Amber Ale | 6.90 % |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1780
rtable_id: 685
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     |
|:---------------------------------------|:------------------------------|:-------------------------|:--------|
| Tongue Buckler ( Bourbon Barrel Aged ) | Ballast Point Brewing Company | American Amber / Red Ale | 10.00 % |

Entity B:
| Beer_Name                                   | Brew_Factory_Name   | Style           | ABV   |
|:--------------------------------------------|:--------------------|:----------------|:------|
| 23rd Street Pumpkin Ale Bourbon Barrel Aged | 23rd Street Brewery | Specialty Grain | -     |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 406
rtable_id: 2071
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    |
|:---------------------------------|:-----------------------------|:-------------------------|:-------|
| Legends Of The Bay Giant 's Tomb | Hockley Valley Brewing Co. . | American Amber / Red Ale | 5.00 % |

Entity B:
| Beer_Name                       | Brew_Factory_Name                        | Style     | ABV   |
|:--------------------------------|:-----------------------------------------|:----------|:------|
| Legends of the Bay Giant_s Tomb | Hockley Valley Brewing & Malting Company | Amber Ale | 5 %   |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1042
rtable_id: 55
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    |
|:------------------------------|:----------------------|:-------------------------|:-------|
| Amber Ale With Spanish Orange | Dangerous Man Brewing | American Amber / Red Ale | 6.00 % |

Entity B:
| Beer_Name                                  | Brew_Factory_Name         | Style      | ABV    |
|:-------------------------------------------|:--------------------------|:-----------|:-------|
| Big Bear Mountain Orange Blossom Amber Ale | Big Bear Mountain Brewery | Fruit Beer | 4.50 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 3959
rtable_id: 447
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    |
|:------------------------|:--------------------|:-------------------------|:-------|
| Rabbit Mountain Red Ale | 300 Suns Brewing    | American Amber / Red Ale | 6.80 % |

Entity B:
| Beer_Name                                                  | Brew_Factory_Name         | Style               | ABV   |
|:-----------------------------------------------------------|:--------------------------|:--------------------|:------|
| Figueroa Mountain / Pizza Port Shark Lips Imperial Red Ale | Figueroa Mountain Brewing | American Strong Ale | 8 %   |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2215
rtable_id: 1120
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 Fox Amber Ale | Rogue Ales          | American Amber / Red Ale | -     |

Entity B:
| Beer_Name                     | Brew_Factory_Name   | Style     | ABV    |
|:------------------------------|:--------------------|:----------|:-------|
| Big Texan Texas Red Amber Ale | Big Texan Brewery   | Amber Ale | 4.50 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 262
rtable_id: 419
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    |
|:----------------------------|:----------------------|:-------------------------|:-------|
| Hop Around Imperial Red Ale | Big Bay Brewing Co. . | American Amber / Red Ale | 9.00 % |

Entity B:
| Beer_Name                                | Brew_Factory_Name   | Style               | ABV   |
|:-----------------------------------------|:--------------------|:--------------------|:------|
| Kern River Dirty Hippie Imperial Red Ale | Kern River Brewing  | American Strong Ale | 8 %   |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 3963
rtable_id: 980
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    |
|:----------------------|:--------------------|:-------------------------|:-------|
| Ruby Red American Ale | Fat Bottom Brewing  | American Amber / Red Ale | 6.10 % |

Entity B:
| Beer_Name                          | Brew_Factory_Name           | Style               | ABV    |
|:-----------------------------------|:----------------------------|:--------------------|:-------|
| Black Shirt American India Red Ale | Black Shirt Brewing Company | American Strong Ale | 7.09 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 309
rtable_id: 2621
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     |
|:----------------------------------|:------------------------------|:-------------------------|:--------|
| Tongue Buckler - Imperial Red Ale | Ballast Point Brewing Company | American Amber / Red Ale | 10.00 % |

Entity B:
| Beer_Name                        | Brew_Factory_Name      | Style               | ABV   |
|:---------------------------------|:-----------------------|:--------------------|:------|
| Worthy Eruption Imperial Red Ale | Worthy Brewing Company | American Strong Ale | 8 %   |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 29
rtable_id: 2582
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     |
|:---------------------------------------------|:--------------------------------|:--------------------|:--------|
| Elevator Barrel Aged Barley Wine ( Bar Bar ) | Elevator Brewery & Draught Haus | American Barleywine | 11.00 % |

Entity B:
| Beer_Name                                        | Brew_Factory_Name      | Style       | ABV    |
|:-------------------------------------------------|:-----------------------|:------------|:-------|
| Hopworks Bourbon Aged Noggin Floggin Barley Wine | Hopworks Urban Brewery | Barley Wine | 9.50 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 4168
rtable_id: 2381
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    |
|:-------------------------|:--------------------|:-------------------------|:-------|
| Aqula American Amber Ale | Bier Kaffee Aqula   | American Amber / Red Ale | 4.50 % |

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: 3309
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    |
|:------------------|:------------------------------|:-------------------------|:-------|
| Red Ale Priprioca | Cervejaria AmazÃ ´ nia Ltda . | American Amber / Red Ale | 6.00 % |

Entity B:
| Beer_Name                     | Brew_Factory_Name   | Style     | ABV   |
|:------------------------------|:--------------------|:----------|:------|
| Amazon Beer Priprioca Red Ale | Amazon Beer         | Amber Ale | 6 %   |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 862
rtable_id: 2906
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    |
|:------------------------------|:--------------------------|:-------------------------|:-------|
| Sledgehammer Imperial Red Ale | Cambridge Brewing Company | American Amber / Red Ale | 7.75 % |

Entity B:
| Beer_Name                  | Brew_Factory_Name               | Style               | ABV    |
|:---------------------------|:--------------------------------|:--------------------|:-------|
| Ale Mania Imperial Red Ale | Ale Mania &#40; Fritz Ale &#41; | American Strong Ale | 9.50 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 3185
rtable_id: 1551
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    |
|:-----------------------------------------|:---------------------------|:-------------------------|:-------|
| Smuttynose Kindest Find Imperial Red Ale | Smuttynose Brewing Company | American Amber / Red Ale | 8.50 % |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 184
rtable_id: 1255
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    |
|:--------------------|:----------------------|:-------------------------|:-------|
| Rocky Point Red Ale | Revival Brewing Co. . | American Amber / Red Ale | 5.50 % |

Entity B:
| Beer_Name                                                        | Brew_Factory_Name         | Style     | ABV   |
|:-----------------------------------------------------------------|:--------------------------|:----------|:------|
| Alley Kat Rocky Mountain Red Ale &#40; The Cheesecake Cafe &#41; | Alley Kat Brewing Company | Irish Ale | -     |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1904
rtable_id: 2681
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    |
|:----------------------|:--------------------------|:-------------------------|:-------|
| Brass Ale Honey Amber | Great Storm Brewing Co. . | American Amber / Red Ale | 5.30 % |

Entity B:
| Beer_Name                                | Brew_Factory_Name   | Style     | ABV    |
|:-----------------------------------------|:--------------------|:----------|:-------|
| Salty Nut Bee Transfixed Honey Amber Ale | Salty Nut Brewery   | Amber Ale | 5.50 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2596
rtable_id: 2124
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    |
|:-------------------------------------|:-------------------------------|:--------------------|:-------|
| Riverbend Barrel Aged Right Said Red | Riverbend Brewing & Sports Pub | American Strong Ale | 9.20 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1218
rtable_id: 1445
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    |
|:-------------------------------|:---------------------------------|:-------------------------|:-------|
| Three Beavers Imperial Red Ale | Howe Sound Inn & Brewing Company | American Amber / Red Ale | 7.50 % |

Entity B:
| Beer_Name                               | Brew_Factory_Name      | Style               | ABV    |
|:----------------------------------------|:-----------------------|:--------------------|:-------|
| Lavery Imperial Red Ale &#40; IRA &#41; | Lavery Brewing Company | American Strong Ale | 8.20 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 487
rtable_id: 1519
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    |
|:-----------------|:---------------------------------|:-------------------------|:-------|
| Sierra Amber Ale | Silver Peak Restaurant & Brewery | American Amber / Red Ale | 4.50 % |

Entity B:
| Beer_Name                        | Brew_Factory_Name   | Style     | ABV    |
|:---------------------------------|:--------------------|:----------|:-------|
| Sierra Andina Alpamayo Amber Ale | Sierra Andina       | Amber Ale | 5.80 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1030
rtable_id: 679
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    |
|:----------------------------------|:--------------------|:-------------------------|:-------|
| Buffalo Soul Jah Imperial Red Ale | Three Heads Brewing | American Amber / Red Ale | 9.20 % |

Entity B:
| Beer_Name                                | Brew_Factory_Name                  | Style               | ABV    |
|:-----------------------------------------|:-----------------------------------|:--------------------|:-------|
| Pizza Port Rhino Chaser Imperial Red Ale | Pizza Port &#40; Ocean Beach &#41; | American Strong Ale | 9.50 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 833
rtable_id: 2728
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    |
|:--------------|:--------------------------|:-------------------------|:-------|
| Big Red Balls | Hillcrest Brewing Company | American Amber / Red Ale | 8.00 % |

Entity B:
| Beer_Name               | Brew_Factory_Name         | Style        | ABV   |
|:------------------------|:--------------------------|:-------------|:------|
| Hillcrest Big Red Balls | Hillcrest Brewing Company | Imperial IPA | 8 %   |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2242
rtable_id: 1048
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    |
|:---------------------|:--------------------------------|:-------------------------|:-------|
| Red Rocket Amber Ale | Third Base Sports Bar & Brewery | American Amber / Red Ale | 6.40 % |

Entity B:
| Beer_Name                          | Brew_Factory_Name              | Style     | ABV    |
|:-----------------------------------|:-------------------------------|:----------|:-------|
| Liberty Street Red Glare Amber Ale | Liberty Street Brewing Company | Amber Ale | 5.20 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1621
rtable_id: 2601
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    |
|:----------------------|:----------------------------|:-------------------------|:-------|
| Bushfire American Red | Granite Falls Brewing Co. . | American Amber / Red Ale | 5.00 % |

Entity B:
| Beer_Name                               | Brew_Factory_Name             | Style     | ABV   |
|:----------------------------------------|:------------------------------|:----------|:------|
| Granite Falls Bushfire American Red Ale | Granite Falls Brewing Company | Amber Ale | 5 %   |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2007
rtable_id: 203
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    |
|:--------------------------|:-----------------------|:-------------------------|:-------|
| Red Dirt Imperial Red Ale | Wiley Roots Brewing Co | American Amber / Red Ale | 8.20 % |

Entity B:
| Beer_Name                                              | Brew_Factory_Name        | Style               | ABV    |
|:-------------------------------------------------------|:-------------------------|:--------------------|:-------|
| AleSmith YuleSmith &#40; Winter &#41; Imperial Red Ale | AleSmith Brewing Company | American Strong Ale | 8.50 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2156
rtable_id: 1973
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    |
|:------------------------------------|:--------------------|:----------|:-------|
| Intuition Barrel Aged Riverside Red | Intuition Ale Works | Amber Ale | 7.80 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1661
rtable_id: 1163
label: 0