MMTU-benchmark/MMTU huggingface dataset:
Task: Data-transform-pbe (source dataset: Transformation-text)

You are given a input table where each row is an input record, and an output table that contains one additional column, called "Output", whose values in each row can be produced by transforming values of the same row in the input table. Your task is to write the corresponding code that can perform such transformations, based on the given input-output examples. Make sure that the transformations you write can generalize to additional input examples not shown in the input table.

Implementation Details:
1. Generate Python code using the Pandas library to perform the transformation.
2. The code should read the input table from "input.csv".
3. Apply the transformation based on the observed pattern.
4. Save the transformed output to "output.csv".
5. Ensure that the output structure matches the expected format, including column names and data types.

Your task is to ensure that the Python script is correctly formatted, efficient, and ready for execution on any dataset following the same transformation pattern.

No explanation and return the Python code in a markdown code block: ```python
<PYTHON-CODE>
```.

Input Table:
| Input                                      |
|:-------------------------------------------|
| MFM-Robot/5.2.59-internal HH464 OS 9.0.8   |
| MFM-Robot/6.2.88-internal EQ829 OS 4.6.7   |
| MFM-4.8.61/xPhone-7.4.9                    |
| MFM-8.8.90/xPhone-6.5.9                    |
| MFM-9.0.96/xPhone-0.1.1                    |
| MFM-3.0.08/xPhone-7.8                      |
|                                            |
| MFM-Robot/6.5.56-internal BM MFBF OS 1.4.4 |
| MFM-Robot/5.7.53-internal RD FMPG OS 3.2.7 |
| MFM-4.1.84/xPhone-6.3.3                    |

Output Table:
| Input                                      | Output   |
|:-------------------------------------------|:---------|
| MFM-Robot/5.2.59-internal HH464 OS 9.0.8   | HH464    |
| MFM-Robot/6.2.88-internal EQ829 OS 4.6.7   | EQ829    |
| MFM-4.8.61/xPhone-7.4.9                    | xPhone   |
| MFM-8.8.90/xPhone-6.5.9                    | xPhone   |
| MFM-9.0.96/xPhone-0.1.1                    | xPhone   |
| MFM-3.0.08/xPhone-7.8                      | xPhone   |
|                                            |          |
| MFM-Robot/6.5.56-internal BM MFBF OS 1.4.4 | BM MFBF  |
| MFM-Robot/5.7.53-internal RD FMPG OS 3.2.7 | RD FMPG  |
| MFM-4.1.84/xPhone-6.3.3                    | xPhone   |



filename: UserAgent.000001
instruction: Conditional
Substring
example_input: example_input.csv
example_output: example_output.csv
test_input: test_input.csv
test_output: test_output.csv
Task: Data-transform-pbe (source dataset: Transformation-text)

You are given a input table where each row is an input record, and an output table that contains one additional column, called "Output", whose values in each row can be produced by transforming values of the same row in the input table. Your task is to write the corresponding code that can perform such transformations, based on the given input-output examples. Make sure that the transformations you write can generalize to additional input examples not shown in the input table.

Implementation Details:
1. Generate Python code using the Pandas library to perform the transformation.
2. The code should read the input table from "input.csv".
3. Apply the transformation based on the observed pattern.
4. Save the transformed output to "output.csv".
5. Ensure that the output structure matches the expected format, including column names and data types.

Your task is to ensure that the Python script is correctly formatted, efficient, and ready for execution on any dataset following the same transformation pattern.

No explanation and return the Python code in a markdown code block: ```python
<PYTHON-CODE>
```.

Input Table:
| Input                 |
|:----------------------|
| Green Bay Packers (2) |
| New York Jets         |
| Seattle Seahawks (2)  |

Output Table:
| Input                 | Output            |
|:----------------------|:------------------|
| Green Bay Packers (2) | Green Bay Packers |
| New York Jets         | New York Jets     |
| Seattle Seahawks (2)  | Seattle Seahawks  |



filename: Team.000003
instruction: Substring
example_input: example_input.csv
example_output: example_output.csv
test_input: test_input.csv
test_output: test_output.csv
Task: Data-transform-pbe (source dataset: Transformation-text)

You are given a input table where each row is an input record, and an output table that contains one additional column, called "Output", whose values in each row can be produced by transforming values of the same row in the input table. Your task is to write the corresponding code that can perform such transformations, based on the given input-output examples. Make sure that the transformations you write can generalize to additional input examples not shown in the input table.

Implementation Details:
1. Generate Python code using the Pandas library to perform the transformation.
2. The code should read the input table from "input.csv".
3. Apply the transformation based on the observed pattern.
4. Save the transformed output to "output.csv".
5. Ensure that the output structure matches the expected format, including column names and data types.

Your task is to ensure that the Python script is correctly formatted, efficient, and ready for execution on any dataset following the same transformation pattern.

No explanation and return the Python code in a markdown code block: ```python
<PYTHON-CODE>
```.

Input Table:
| Input        |
|:-------------|
| 'ad'         |
| 'doloremque' |

Output Table:
| Input        | Output       |
|:-------------|:-------------|
| 'ad'         | "ad"         |
| 'doloremque' | "doloremque" |



filename: Word.000001
instruction: Concatenation
Substring
example_input: example_input.csv
example_output: example_output.csv
test_input: test_input.csv
test_output: test_output.csv
Task: Data-transform-pbe (source dataset: Transformation-text)

You are given a input table where each row is an input record, and an output table that contains one additional column, called "Output", whose values in each row can be produced by transforming values of the same row in the input table. Your task is to write the corresponding code that can perform such transformations, based on the given input-output examples. Make sure that the transformations you write can generalize to additional input examples not shown in the input table.

Implementation Details:
1. Generate Python code using the Pandas library to perform the transformation.
2. The code should read the input table from "input.csv".
3. Apply the transformation based on the observed pattern.
4. Save the transformed output to "output.csv".
5. Ensure that the output structure matches the expected format, including column names and data types.

Your task is to ensure that the Python script is correctly formatted, efficient, and ready for execution on any dataset following the same transformation pattern.

No explanation and return the Python code in a markdown code block: ```python
<PYTHON-CODE>
```.

Input Table:
| Input                                      |
|:-------------------------------------------|
| MFM-Robot/5.2.59-internal HH464 OS 9.0.8   |
| MFM-Robot/6.2.88-internal EQ829 OS 4.6.7   |
| MFM-4.8.61/xPhone-7.4.9                    |
| MFM-8.8.90/xPhone-6.5.9                    |
| MFM-9.0.96/xPhone-0.1.1                    |
| MFM-3.0.08/xPhone-7.8                      |
|                                            |
| MFM-Robot/6.5.56-internal BM MFBF OS 1.4.4 |
| MFM-Robot/5.7.53-internal RD FMPG OS 3.2.7 |
| MFM-4.1.84/xPhone-6.3.3                    |

Output Table:
| Input                                      | Output   |
|:-------------------------------------------|:---------|
| MFM-Robot/5.2.59-internal HH464 OS 9.0.8   | Robot    |
| MFM-Robot/6.2.88-internal EQ829 OS 4.6.7   | Robot    |
| MFM-4.8.61/xPhone-7.4.9                    | xOS      |
| MFM-8.8.90/xPhone-6.5.9                    | xOS      |
| MFM-9.0.96/xPhone-0.1.1                    | xOS      |
| MFM-3.0.08/xPhone-7.8                      | xOS      |
|                                            |          |
| MFM-Robot/6.5.56-internal BM MFBF OS 1.4.4 | Robot    |
| MFM-Robot/5.7.53-internal RD FMPG OS 3.2.7 | Robot    |
| MFM-4.1.84/xPhone-6.3.3                    | xOS      |



filename: UserAgent.000004
instruction: Concatenation
Conditional
Substring
example_input: example_input.csv
example_output: example_output.csv
test_input: test_input.csv
test_output: test_output.csv
Task: Data-transform-pbe (source dataset: Transformation-text)

You are given a input table where each row is an input record, and an output table that contains one additional column, called "Output", whose values in each row can be produced by transforming values of the same row in the input table. Your task is to write the corresponding code that can perform such transformations, based on the given input-output examples. Make sure that the transformations you write can generalize to additional input examples not shown in the input table.

Implementation Details:
1. Generate Python code using the Pandas library to perform the transformation.
2. The code should read the input table from "input.csv".
3. Apply the transformation based on the observed pattern.
4. Save the transformed output to "output.csv".
5. Ensure that the output structure matches the expected format, including column names and data types.

Your task is to ensure that the Python script is correctly formatted, efficient, and ready for execution on any dataset following the same transformation pattern.

No explanation and return the Python code in a markdown code block: ```python
<PYTHON-CODE>
```.

Input Table:
| Input                    |
|:-------------------------|
| 1Z 388 965 96 5014 296 7 |
| 1Z 781 7D9 14 5364 887 7 |
| 1Z 339 5D2 97 3412 476 4 |

Output Table:
| Input                    | Output   |
|:-------------------------|:---------|
| 1Z 388 965 96 5014 296 7 | 388 96   |
| 1Z 781 7D9 14 5364 887 7 | 781 14   |
| 1Z 339 5D2 97 3412 476 4 | 339 97   |



filename: ShippingCode.000007
instruction: Concatenation
Substring
example_input: example_input.csv
example_output: example_output.csv
test_input: test_input.csv
test_output: test_output.csv
Task: Data-transform-pbe (source dataset: Transformation-text)

You are given a input table where each row is an input record, and an output table that contains one additional column, called "Output", whose values in each row can be produced by transforming values of the same row in the input table. Your task is to write the corresponding code that can perform such transformations, based on the given input-output examples. Make sure that the transformations you write can generalize to additional input examples not shown in the input table.

Implementation Details:
1. Generate Python code using the Pandas library to perform the transformation.
2. The code should read the input table from "input.csv".
3. Apply the transformation based on the observed pattern.
4. Save the transformed output to "output.csv".
5. Ensure that the output structure matches the expected format, including column names and data types.

Your task is to ensure that the Python script is correctly formatted, efficient, and ready for execution on any dataset following the same transformation pattern.

No explanation and return the Python code in a markdown code block: ```python
<PYTHON-CODE>
```.

Input Table:
| Input                 |
|:----------------------|
| MFM-2.4.76/xPad-4.1.8 |
| MFM-5.2.59/xPhone-4.9 |
| MFM-7.7.92/xPhone-5.6 |
| MFM-2.1.06/xPhone-6.6 |
| MFM-8.9.06/xPhone-5.9 |
| MFM-6.4.90/xPad-8.9   |

Output Table:
| Input                 | Output   |
|:----------------------|:---------|
| MFM-2.4.76/xPad-4.1.8 | 4.1.8    |
| MFM-5.2.59/xPhone-4.9 | 4.9      |
| MFM-7.7.92/xPhone-5.6 | 5.6      |
| MFM-2.1.06/xPhone-6.6 | 6.6      |
| MFM-8.9.06/xPhone-5.9 | 5.9      |
| MFM-6.4.90/xPad-8.9   | 8.9      |



filename: UserAgent.000005
instruction: Substring
example_input: example_input.csv
example_output: example_output.csv
test_input: test_input.csv
test_output: test_output.csv
Task: Data-transform-pbe (source dataset: Transformation-text)

You are given a input table where each row is an input record, and an output table that contains one additional column, called "Output", whose values in each row can be produced by transforming values of the same row in the input table. Your task is to write the corresponding code that can perform such transformations, based on the given input-output examples. Make sure that the transformations you write can generalize to additional input examples not shown in the input table.

Implementation Details:
1. Generate Python code using the Pandas library to perform the transformation.
2. The code should read the input table from "input.csv".
3. Apply the transformation based on the observed pattern.
4. Save the transformed output to "output.csv".
5. Ensure that the output structure matches the expected format, including column names and data types.

Your task is to ensure that the Python script is correctly formatted, efficient, and ready for execution on any dataset following the same transformation pattern.

No explanation and return the Python code in a markdown code block: ```python
<PYTHON-CODE>
```.

Input Table:
| Input                   |
|:------------------------|
| 09. Vero7 - Eius9       |
| 02. Ad3 - Harum5        |
| 06. Vel4 - Quas7        |
| 01. Assumenda6 - Natus9 |
| 08. Porro6 - Adipisci8  |

Output Table:
| Input                   | Output     |
|:------------------------|:-----------|
| 09. Vero7 - Eius9       | Vero7      |
| 02. Ad3 - Harum5        | Ad3        |
| 06. Vel4 - Quas7        | Vel4       |
| 01. Assumenda6 - Natus9 | Assumenda6 |
| 08. Porro6 - Adipisci8  | Porro6     |



filename: Song.000001
instruction: Substring
example_input: example_input.csv
example_output: example_output.csv
test_input: test_input.csv
test_output: test_output.csv
Task: Data-transform-pbe (source dataset: Transformation-text)

You are given a input table where each row is an input record, and an output table that contains one additional column, called "Output", whose values in each row can be produced by transforming values of the same row in the input table. Your task is to write the corresponding code that can perform such transformations, based on the given input-output examples. Make sure that the transformations you write can generalize to additional input examples not shown in the input table.

Implementation Details:
1. Generate Python code using the Pandas library to perform the transformation.
2. The code should read the input table from "input.csv".
3. Apply the transformation based on the observed pattern.
4. Save the transformed output to "output.csv".
5. Ensure that the output structure matches the expected format, including column names and data types.

Your task is to ensure that the Python script is correctly formatted, efficient, and ready for execution on any dataset following the same transformation pattern.

No explanation and return the Python code in a markdown code block: ```python
<PYTHON-CODE>
```.

Input Table:
| Input                                                                                   |
|:----------------------------------------------------------------------------------------|
| http://example.com/SomePath/another/en/foo-a9/GUID-8DDB2E31-0FCE-4EA9-8A6D-7CE2CB4A051A |
| http://example.com/SomePath/another/en/foo-a4/GUID-B3D68203-6E71-43CD-ABF1-32156B6848B0 |
| http://example.com/SomePath/another/en/foo-a4/GUID-98FAB309-BEA9-40E9-A0AA-FC7CD8C2AA70 |
| http://example.com/SomePath/another/en/foo-a4/GUID-8ADE3E75-6C71-4C6A-ACFD-D00D4B7D72E2 |
| http://example.com/SomePath/another/en/foo-a4/GUID-0BE43650-E7EB-4A78-8E9D-C3D477073FD9 |

Output Table:
| Input                                                                                   | Output                                              |
|:----------------------------------------------------------------------------------------|:----------------------------------------------------|
| http://example.com/SomePath/another/en/foo-a9/GUID-8DDB2E31-0FCE-4EA9-8A6D-7CE2CB4A051A | en_foo-a9_GUID-8DDB2E31-0FCE-4EA9-8A6D-7CE2CB4A051A |
| http://example.com/SomePath/another/en/foo-a4/GUID-B3D68203-6E71-43CD-ABF1-32156B6848B0 | en_foo-a4_GUID-B3D68203-6E71-43CD-ABF1-32156B6848B0 |
| http://example.com/SomePath/another/en/foo-a4/GUID-98FAB309-BEA9-40E9-A0AA-FC7CD8C2AA70 | en_foo-a4_GUID-98FAB309-BEA9-40E9-A0AA-FC7CD8C2AA70 |
| http://example.com/SomePath/another/en/foo-a4/GUID-8ADE3E75-6C71-4C6A-ACFD-D00D4B7D72E2 | en_foo-a4_GUID-8ADE3E75-6C71-4C6A-ACFD-D00D4B7D72E2 |
| http://example.com/SomePath/another/en/foo-a4/GUID-0BE43650-E7EB-4A78-8E9D-C3D477073FD9 | en_foo-a4_GUID-0BE43650-E7EB-4A78-8E9D-C3D477073FD9 |



filename: Url.000004
instruction: Concatenation
Substring
example_input: example_input.csv
example_output: example_output.csv
test_input: test_input.csv
test_output: test_output.csv
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 Toad Amber Ale | Blue Cat Brew Pub   | American Amber / Red Ale | 5.70 % |

Entity B:
| Beer_Name                | Brew_Factory_Name   | Style             | ABV    |
|:-------------------------|:--------------------|:------------------|:-------|
| Baird Red Rose Amber Ale | Baird Brewing Co. . | California Common | 5.40 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 3372
rtable_id: 1281
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    |
|:---------------------------|:-------------------------|:--------------------|:-------|
| Pike Old Bawdy Barley Wine | The Pike Brewing Company | American Barleywine | 9.90 % |

Entity B:
| Beer_Name                      | Brew_Factory_Name       | Style       | ABV     |
|:-------------------------------|:------------------------|:------------|:--------|
| Bristol Old No. 23 Barley Wine | Bristol Brewing Company | Barley Wine | 11.25 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 4068
rtable_id: 2374
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   |
|:-------------------------|:--------------------|:--------------------|:------|
| Centurion Barleywine Ale | Golden City Brewery | American Barleywine | -     |

Entity B:
| Beer_Name                            | Brew_Factory_Name   | Style       | ABV     |
|:-------------------------------------|:--------------------|:------------|:--------|
| Golden City Centurion Barleywine Ale | Golden City Brewery | Barley Wine | 11.20 % |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 4161
rtable_id: 2409
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    |
|:------------------------------|:--------------------|:-------------------------|:-------|
| Willoughby American Amber Ale | Willoughby Brewing  | American Amber / Red Ale | 4.90 % |

Entity B:
| Beer_Name                     | Brew_Factory_Name        | Style     | ABV    |
|:------------------------------|:-------------------------|:----------|:-------|
| Willoughby American Amber Ale | Willoughby Brewing Co. . | Amber Ale | 5.50 % |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 3381
rtable_id: 1859
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     |
|:------------------------------------|:------------------------------|:--------------------|:--------|
| Thomas Hooker Old Marley Barleywine | Thomas Hooker Brewing Company | American Barleywine | 10.00 % |

Entity B:
| Beer_Name                           | Brew_Factory_Name             | Style       | ABV   |
|:------------------------------------|:------------------------------|:------------|:------|
| Thomas Hooker Old Marley Barleywine | Thomas Hooker Brewing Company | Barley Wine | 10 %  |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 4063
rtable_id: 2331
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 Racer India Style Red Ale | Central City Brewers + Distillers | American Amber / Red Ale | 5.60 % |

Entity B:
| Beer_Name                      | Brew_Factory_Name        | Style                          | ABV   |
|:-------------------------------|:-------------------------|:-------------------------------|:------|
| GoodLife Redside India Red Ale | GoodLife Brewing Company | India Pale Ale &#40; IPA &#41; | 6 %   |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 525
rtable_id: 2972
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 Racer India Style Red Ale | Central City Brewers + Distillers | American Amber / Red Ale | 5.60 % |

Entity B:
| Beer_Name                    | Brew_Factory_Name   | Style     | ABV    |
|:-----------------------------|:--------------------|:----------|:-------|
| Heist American Style Red Ale | Heist Brewery       | Amber Ale | 4.50 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 525
rtable_id: 433
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   |
|:------------------------|:--------------------|:--------------------|:------|
| Marble Imperial Red Ale | Marble Brewery      | American Strong Ale | 9 %   |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 3963
rtable_id: 63
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    |
|:----------------------------------------------|:--------------------|:--------------------|:-------|
| Three Heads Buffalo Soul Jah Imperial Red Ale | Custom Brewcrafters | American Strong Ale | 9.20 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 29
rtable_id: 2883
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    |
|:------------------------|:-----------------------|:-------------------------|:-------|
| Lavery Imperial Red Ale | Lavery Brewing Company | American Amber / Red Ale | 8.20 % |

Entity B:
| Beer_Name                                    | Brew_Factory_Name                 | Style               | ABV    |
|:---------------------------------------------|:----------------------------------|:--------------------|:-------|
| Laurelwood Organic Deranger Imperial Red Ale | Laurelwood Public House & Brewery | American Strong Ale | 8.60 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 285
rtable_id: 411
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    |
|:---------------------|:------------------------|:-------------------------|:-------|
| Real McCoy Amber Ale | Mammoth Brewing Company | American Amber / Red Ale | 4.50 % |

Entity B:
| Beer_Name                    | Brew_Factory_Name       | Style   | ABV    |
|:-----------------------------|:------------------------|:--------|:-------|
| Mammoth Real McCoy Amber Ale | Mammoth Brewing Company | Altbier | 4.50 % |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 271
rtable_id: 1410
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    |
|:-------------------------------------|:-------------------------|:-------------------------|:-------|
| Bulleit Bourbon Barrel Aged G'Knight | Oskar Blues Grill & Brew | American Amber / Red Ale | 8.70 % |

Entity B:
| Beer_Name                                   | Brew_Factory_Name    | Style       | ABV   |
|:--------------------------------------------|:---------------------|:------------|:------|
| Figure Eight Bourbon Barrel Aged Jumbo Love | Figure Eight Brewing | Barley Wine | -     |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1219
rtable_id: 2470
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 Ale | Red Car Brewery and Restaurant | American Amber / Red Ale | 5.70 % |

Entity B:
| Beer_Name                        | Brew_Factory_Name             | Style     | ABV    |
|:---------------------------------|:------------------------------|:----------|:-------|
| Big Bear Lake Sidewinder Red Ale | Big Bear Lake Brewing Company | Amber Ale | 8.50 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1251
rtable_id: 812
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    |
|:------------------------|:-----------------------|:-------------------------|:-------|
| Lavery Imperial Red Ale | Lavery Brewing Company | American Amber / Red Ale | 8.20 % |

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: 285
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   |
|:-----------------------------------|:-----------------------------|:-------------------------|:------|
| Mount Washington Organic Amber Ale | Peak Organic Brewing Company | American Amber / Red Ale | -     |

Entity B:
| Beer_Name                                 | Brew_Factory_Name   | Style     | ABV    |
|:------------------------------------------|:--------------------|:----------|:-------|
| Outpost Mr. Grain Jeans Organic Amber Ale | Lakefront Brewery   | Amber Ale | 5.50 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1471
rtable_id: 1165
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    |
|:-----------------------|:--------------------|:-------------------------|:-------|
| Brew Kahuna NW Red Ale | Sky High Brewing    | American Amber / Red Ale | 5.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: 2316
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    |
|:-----------------------|:-----------------------------|:-------------------------|:-------|
| BJ 's Imperial Red Ale | BJ 's Restaurant & Brewhouse | American Amber / Red Ale | 9.00 % |

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: 696
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    |
|:---------------------------------------------|:------------------------|:-------------------------|:-------|
| Batch 200 _ `` Olympus Mons Imperial Red Ale | Due South Brewing Co. . | American Amber / Red Ale | 9.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: 1755
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    |
|:-----------------------------|:--------------------------|:-------------------------|:-------|
| 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   |
|:--------------------------------------|:--------------------|:--------------------|:------|
| Iron Horse Fresh Hop Imperial Red Ale | Iron Horse Brewery  | American Strong Ale | -     |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 3
rtable_id: 641
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    |
|:--------------------------------------|:--------------------------|:--------------------|:-------|
| 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: 184
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    |
|:------------------|:-------------------------|:-------------------------|:-------|
| Unite Red Rye Ale | The Pike Brewing Company | American Amber / Red Ale | 4.60 % |

Entity B:
| Beer_Name                                              | Brew_Factory_Name            | Style     | ABV    |
|:-------------------------------------------------------|:-----------------------------|:----------|:-------|
| Midnight Sun Unite Double Red Hot Ale &#40; 2015 &#41; | Midnight Sun Brewing Company | Amber Ale | 7.50 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 3079
rtable_id: 2048
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   |
|:------------------------------------|:-------------------------------------------------------------|:----------|:------|
| Genesee Brew House American Red Ale | Genesee Brewing Company &#40; North American Breweries &#41; | Amber Ale | 5 %   |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 309
rtable_id: 418
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    |
|:----------------|:---------------------|:-------------------------|:-------|
| Amber Waves Ale | Capitol City Brewing | American Amber / Red Ale | 5.40 % |

Entity B:
| Beer_Name                    | Brew_Factory_Name            | Style     | ABV    |
|:-----------------------------|:-----------------------------|:----------|:-------|
| Capitol City Amber Waves Ale | Capitol City Brewing Company | Amber Ale | 5.60 % |



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

Entity B:
| Beer_Name                             | Brew_Factory_Name   | Style                          | ABV   |
|:--------------------------------------|:--------------------|:-------------------------------|:------|
| Big Time Lift Ticket American Red Ale | Big Time Brewery    | India Pale Ale &#40; IPA &#41; | 7 %   |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2155
rtable_id: 1261
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    |
|:---------------|:------------------------|:-------------------------|:-------|
| Easy Amber Ale | Scottsdale Beer Company | American Amber / Red Ale | 5.70 % |

Entity B:
| Beer_Name                   | Brew_Factory_Name      | Style     | ABV    |
|:----------------------------|:-----------------------|:----------|:-------|
| Upland Easy Chair Amber Ale | Upland Brewing Company | Amber Ale | 5.60 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2494
rtable_id: 2565
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    |
|:---------------------------------|:--------------------|:-------------------------|:-------|
| Alexander Keith 's Red Amber Ale | Alexander Keith 's  | American Amber / Red Ale | 5.00 % |

Entity B:
| Beer_Name                          | Brew_Factory_Name               | Style     | ABV    |
|:-----------------------------------|:--------------------------------|:----------|:-------|
| Hollywood Beach Red Tide Amber Ale | Hollywood Beach Brewing Company | Amber Ale | 5.20 % |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 113
rtable_id: 475
label: 0