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

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                                                  |
|:-------------------------------------------------------|
| 5 super commerce place blvd Ste H, Richmond, VA, 23452 |
| 100 main street, redmond, wa, 98052                    |
| 1001 sunset blvd, Room 301, Sacramento California      |

Output Table:
| Input                                                  | Output                      |
|:-------------------------------------------------------|:----------------------------|
| 5 super commerce place blvd Ste H, Richmond, VA, 23452 | 5 super commerce place blvd |
| 100 main street, redmond, wa, 98052                    | 100 main street             |
| 1001 sunset blvd, Room 301, Sacramento California      | 1001 sunset blvd            |



filename: Transform-Data-by-Example/Benchmark/benchmark-headcase/funct_comp_address_streetline.txt
instruction: //address
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: TDE)

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          |
|:---------------|
| 102.31.1.244   |
| 39.255.255.255 |
| 20.55.255.255  |

Output Table:
| Input          | Output                   |
|:---------------|:-------------------------|
| 102.31.1.244   | 0:0:0:0:0:ffff:661f:1f4  |
| 39.255.255.255 | 0:0:0:0:0:ffff:27ff:ffff |
| 20.55.255.255  | 0:0:0:0:0:ffff:1437:ffff |



filename: Transform-Data-by-Example/Benchmark/benchmark-headcase/funct_ipv4v6.txt
instruction: //convert ipv4 to ipv6
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: TDE)

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                      |
|:---------------------------|
| James Smith                |
| Alice Bob Doe              |
| Mr. Charles P. Wooten, III |

Output Table:
| Input                      | Output   |
|:---------------------------|:---------|
| James Smith                | SJ       |
| Alice Bob Doe              | DA       |
| Mr. Charles P. Wooten, III | WC       |



filename: Transform-Data-by-Example/Benchmark/benchmark-headcase/funct_comp_pname_initials.txt
instruction: // name to initial+last
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: TDE)

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     |
|:----------|
| 6/2       |
| 2 / 2 + 1 |
| (1+3)/2   |

Output Table:
| Input     |   Output |
|:----------|---------:|
| 6/2       |        3 |
| 2 / 2 + 1 |        2 |
| (1+3)/2   |        2 |



filename: Transform-Data-by-Example/Benchmark/benchmark-headcase/funct_expression.txt
instruction: //
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: TDE)

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        |
|:-------------|
| James Smith  |
| John Johnson |

Output Table:
| Input        | Output   |
|:-------------|:---------|
| James Smith  | Smith    |
| John Johnson | Johnson  |



filename: Transform-Data-by-Example/Benchmark/benchmark-headcase/funct_comp_pname_lastname.txt
instruction: // name to initial+last
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: TDE)

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                                                  |
|:-------------------------------------------------------|
| 5 super commerce place blvd Ste H, Richmond, VA, 23452 |
| 10 commerce way, Richmond, VA, 23452                   |
| 1001 sunset blvd, Room 301, Sacramento California      |

Output Table:
| Input                                                  | Output                    |
|:-------------------------------------------------------|:--------------------------|
| 5 super commerce place blvd Ste H, Richmond, VA, 23452 | super commerce place blvd |
| 10 commerce way, Richmond, VA, 23452                   | commerce way              |
| 1001 sunset blvd, Room 301, Sacramento California      | sunset blvd               |



filename: Transform-Data-by-Example/Benchmark/benchmark-headcase/funct_comp_address_street.txt
instruction: //address
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: TDE)

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             |
|:------------------|
| 2011-Jan-12       |
| 6/1/2009 12:01:01 |
| 7/1/2009          |

Output Table:
| Input             | Output     |
|:------------------|:-----------|
| 2011-Jan-12       | January 12 |
| 6/1/2009 12:01:01 | June 1     |
| 7/1/2009          | July 1     |



filename: Transform-Data-by-Example/Benchmark/benchmark-headcase/funct_comp_datetime.txt
instruction: //
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: TDE)

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                      |
|:---------------------------|
| James Smith                |
| Alice C. Doe               |
| Mr. Charles P. Wooten, III |

Output Table:
| Input                      | Output    |
|:---------------------------|:----------|
| James Smith                | J. Smith  |
| Alice C. Doe               | A. Doe    |
| Mr. Charles P. Wooten, III | C. Wooten |



filename: Transform-Data-by-Example/Benchmark/benchmark-headcase/funct_comp_pname.txt
instruction: // name to initial+last
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: TDE)

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 |
|--------:|
|       3 |
|       9 |
|       5 |

Output Table:
|   Input |   Output |
|--------:|---------:|
|       3 |        9 |
|       9 |       27 |
|       5 |       15 |



filename: Transform-Data-by-Example/Benchmark/benchmark-headcase/numeric_linear.txt
instruction: //
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: TDE)

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                 |
|:----------------------|
| John Adam Johnson     |
| Charlie Denis Edwards |
| Doe, John             |

Output Table:
| Input                 | Output   |
|:----------------------|:---------|
| John Adam Johnson     | A        |
| Charlie Denis Edwards | D        |
| Doe, John             |          |



filename: Transform-Data-by-Example/Benchmark/benchmark-headcase/funct_comp_pname_middle.txt
instruction: // name to initial+last
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: TDE)

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                                                                           |
|:--------------------------------------------------------------------------------|
| skin=noskin; path=/; domain=.amazon.com; expires=Mon, 22-Mar-2010 18:40:34 GMT; |
| path=/; expires=Wed, 13 Jan 2021 22:23:01 GMT; domain=.abc.com;                 |
| path=/; expires=Wed, 13 Jan 2021 22:23:01 GMT; domain=.foo.com;                 |

Output Table:
| Input                                                                           | Output      |
|:--------------------------------------------------------------------------------|:------------|
| skin=noskin; path=/; domain=.amazon.com; expires=Mon, 22-Mar-2010 18:40:34 GMT; | .amazon.com |
| path=/; expires=Wed, 13 Jan 2021 22:23:01 GMT; domain=.abc.com;                 | .abc.com    |
| path=/; expires=Wed, 13 Jan 2021 22:23:01 GMT; domain=.foo.com;                 | .foo.com    |



filename: Transform-Data-by-Example/Benchmark/benchmark-headcase/funct_cookie.txt
instruction: //
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: TDE)

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          |
|:---------------|
| 2014-08-03     |
| 2011-04-01     |
| March 26, 2009 |

Output Table:
| Input          |   Output |
|:---------------|---------:|
| 2014-08-03     |        8 |
| 2011-04-01     |        4 |
| March 26, 2009 |        3 |



filename: Transform-Data-by-Example/Benchmark/benchmark-headcase/funct_datetime_month2.txt
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: TDE)

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              |
|:-------------------|
| cnn.co.uk          |
| www.photos.abc.com |
| drive.google.ca    |

Output Table:
| Input              | Output   |
|:-------------------|:---------|
| cnn.co.uk          | cnn      |
| www.photos.abc.com | abc      |
| drive.google.ca    | google   |



filename: Transform-Data-by-Example/Benchmark/benchmark-headcase/funct_domain_sld.txt
instruction: //
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: TDE)

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 |
|--------:|
|    1.55 |
|  123    |
| 1293.3  |

Output Table:
|   Input |   Output |
|--------:|---------:|
|    1.55 |      1.6 |
|  123    |    120   |
| 1293.3  |   1300   |



filename: Transform-Data-by-Example/Benchmark/benchmark-headcase/numeric_scientific_notation.txt
instruction: //
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: TDE)

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 |
|-------------:|
|  1.5857      |
| 23.45        |
|  1.23457e+09 |

Output Table:
|        Input |       Output |
|-------------:|-------------:|
|  1.5857      |  1.6         |
| 23.45        | 23.5         |
|  1.23457e+09 |  1.23457e+09 |



filename: Transform-Data-by-Example/Benchmark/benchmark-headcase/numeric_rounding.txt
instruction: //
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: TDE)

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                                               |
|:----------------------------------------------------|
| 1201 super commerce blvd Ste H, Richmond, VA, 23452 |
| 10 commerce way, Richmond, VA, 23452                |
| 100 sunset blvd, room 301, Sacramento California    |

Output Table:
| Input                                               | Output   |
|:----------------------------------------------------|:---------|
| 1201 super commerce blvd Ste H, Richmond, VA, 23452 | VA       |
| 10 commerce way, Richmond, VA, 23452                | VA       |
| 100 sunset blvd, room 301, Sacramento California    | CA       |



filename: Transform-Data-by-Example/Benchmark/benchmark-headcase/funct_comp_address_state.txt
instruction: //address
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: TDE)

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      |
|:-----------|
| 316148410X |
| 1861972717 |
| 1566199093 |

Output Table:
| Input      | Output            |
|:-----------|:------------------|
| 316148410X | 978-3-1614-8410-0 |
| 1861972717 | 978-1-86197-271-2 |
| 1566199093 | 978-1-56619-909-4 |



filename: Transform-Data-by-Example/Benchmark/benchmark-headcase/funct_isbn10to13.txt
instruction: // isbn 10 to 13 conversion http://www.isbn.org/ISBN_converter
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: TDE)

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                   |
|:------------------------|
| very.common@example.com |
| A@b.com@example.com     |
| A@b@c@example.com       |

Output Table:
| Input                   | Output   |
|:------------------------|:---------|
| very.common@example.com | true     |
| A@b.com@example.com     | false    |
| A@b@c@example.com       | false    |



filename: Transform-Data-by-Example/Benchmark/benchmark-headcase/funct_email.txt
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: TDE)

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   |
|:--------|
| 3 ft    |
| 12 ft   |
| 10.5 ft |

Output Table:
| Input   | Output   |
|:--------|:---------|
| 3 ft    | 0.9 m    |
| 12 ft   | 3.7 m    |
| 10.5 ft | 3.2 m    |



filename: Transform-Data-by-Example/Benchmark/benchmark-headcase/funct_unit.txt
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: TDE)

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 |
|-------------:|
|  1.5857      |
| 12.34        |
|  1.23457e+09 |

Output Table:
|        Input |    Output |
|-------------:|----------:|
|  1.5857      |  1.59     |
| 12.34        | 12.3      |
|  1.23457e+09 |  1.23e+09 |



filename: Transform-Data-by-Example/Benchmark/benchmark-headcase/numeric_scientific_notation2.txt
instruction: //
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: TDE)

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      |
|:-----------|
| 05/12/2015 |
| 01/01/2014 |
| 01/21/2014 |

Output Table:
| Input      | Output    |
|:-----------|:----------|
| 05/12/2015 | Tuesday   |
| 01/01/2014 | Wednesday |
| 01/21/2014 | Tuesday   |



filename: Transform-Data-by-Example/Benchmark/benchmark-headcase/funct_datetime_daysofweek.txt
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: TDE)

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 |
|----------:|
|   0.15857 |
|   1.234   |
| 123       |

Output Table:
|     Input |   Output |
|----------:|---------:|
|   0.15857 |     0.16 |
|   1.234   |     1.2  |
| 123       |   120    |



filename: Transform-Data-by-Example/Benchmark/benchmark-headcase/numeric_const_significant.txt
instruction: //
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: TDE)

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                                                               |
|:--------------------------------------------------------------------|
| $GPRMC,235947.000,V,0000.0000,N,00000.0000,E,,,041299,,*1D          |
| $GPRMC,092204.999,A,4250.5589,S,14718.5084,E,0.00,89.68,211200,,*25 |

Output Table:
| Input                                                               | Output   |
|:--------------------------------------------------------------------|:---------|
| $GPRMC,235947.000,V,0000.0000,N,00000.0000,E,,,041299,,*1D          | 0 km/h   |
| $GPRMC,092204.999,A,4250.5589,S,14718.5084,E,0.00,89.68,211200,,*25 | 0 km/h   |



filename: Transform-Data-by-Example/Benchmark/benchmark-headcase/funct_nmea_speed.txt
instruction: //   http://rl.se/gprmc   AND https://www.google.com/search?q=11.9+kt+to+km&ie=utf-8&oe=utf-8#q=11.9+knots+to+km%2Fh
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: TDE)

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   |
|:--------|
| 33ºC    |
| 6ºC     |
| 46ºC    |

Output Table:
| Input   | Output   |
|:--------|:---------|
| 33ºC    | 91.4ºF   |
| 6ºC     | 42.8ºF   |
| 46ºC    | 114.8ºF  |



filename: Transform-Data-by-Example/Benchmark/benchmark-headcase/numeric_fahrenheit.txt
instruction: //
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: TDE)

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             |
|:------------------|
| ISBN13-316148410X |
| ISBN13-1861972717 |
| ISBN13-1566199093 |

Output Table:
| Input             | Output            |
|:------------------|:------------------|
| ISBN13-316148410X | 978-3-1614-8410-0 |
| ISBN13-1861972717 | 978-1-86197-271-2 |
| ISBN13-1566199093 | 978-1-56619-909-4 |



filename: Transform-Data-by-Example/Benchmark/benchmark-headcase/input_splitter1.txt
instruction: //upper caseing
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: TDE)

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                                             |
|:--------------------------------------------------|
| fe80::/10                                         |
| 192.168.100.14/24                                 |
| fe80::d501:4ee:3882:c586-fe80::d502:4ee:3882:c586 |

Output Table:
| Input                                             | Output                   |
|:--------------------------------------------------|:-------------------------|
| fe80::/10                                         | fe80::                   |
| 192.168.100.14/24                                 | 192.168.100.14           |
| fe80::d501:4ee:3882:c586-fe80::d502:4ee:3882:c586 | fe80::d502:4ee:3882:c586 |



filename: Transform-Data-by-Example/Benchmark/benchmark-headcase/funct_iprange_begin.txt
instruction: //CIDR    https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing
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: TDE)

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                                                               |
|:--------------------------------------------------------------------|
| $GPRMC,155123.000,A,4043.8432,N,07359.7653,W,0.15,83.25,200407,,*28 |
| $GPRMC,092204.999,A,4250.5589,S,14718.5084,E,0.00,89.68,211200,,*25 |

Output Table:
| Input                                                               |   Output |
|:--------------------------------------------------------------------|---------:|
| $GPRMC,155123.000,A,4043.8432,N,07359.7653,W,0.15,83.25,200407,,*28 |    83.25 |
| $GPRMC,092204.999,A,4250.5589,S,14718.5084,E,0.00,89.68,211200,,*25 |    89.68 |



filename: Transform-Data-by-Example/Benchmark/benchmark-headcase/funct_nmea_bearing.txt
instruction: //
example_input: example_input.csv
example_output: example_output.csv
test_input: test_input.csv
test_output: test_output.csv