MMTU-benchmark/MMTU huggingface dataset:
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Tie no   | Home team           | Score   | Away team           | Attendance       |
|:---------|:--------------------|:--------|:--------------------|:-----------------|
| 1        | leicester city      | 2–1     | norwich city        | 25 january 1997  |
| 2        | blackburn rovers    | 1–2     | coventry city       | 15 february 1997 |
| 3        | bolton wanderers    | 2–3     | chesterfield        | 4 february 1997  |
| 4        | hednesford town     | 2–3     | middlesbrough       | 25 january 1997  |
| 5        | derby county        | 3–1     | aston villa         | 25 january 1997  |
| 6        | everton             | 2–3     | bradford city       | 25 january 1997  |
| 7        | newcastle united    | 1–2     | nottingham forest   | 26 january 1997  |
| 8        | manchester city     | 3–1     | watford             | 5 february 1997  |
| 9        | queens park rangers | 3–2     | barnsley            | 25 january 1997  |
| 10       | portsmouth          | 3–0     | reading             | 25 january 1997  |
| 11       | manchester united   | 1–1     | wimbledon           | 25 january 1997  |
| replay   | wimbledon           | 1–0     | manchester united   | 4 february 1997  |
| 12       | carlisle united     | 0–2     | sheffield wednesday | 25 january 1997  |
| 13       | chelsea             | 4–2     | liverpool           | 27,950           |
| 14       | arsenal             | 0–1     | leeds united        | 4 february 1997  |
| 15       | peterborough united | 2–4     | wrexham             | 4 february 1997  |
| 16       | birmingham city     | 3–1     | stockport county    | 25 january 1997  |

Question: WHAT IS THE ATTENDANCE  WITH A READING AWAY TEAM?

table_id: 2-17004128-5
label: SELECT "Attendance" FROM "table" WHERE "Away team" = "reading"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
|   Position | Team                |   Points |   Played |   Drawn |   Lost |   Against | Difference   |
|-----------:|:--------------------|---------:|---------:|--------:|-------:|----------:|:-------------|
|          1 | são paulo           |       33 |       20 |       3 |      2 |        22 | 41           |
|          2 | corinthians         |       32 |       20 |       2 |      3 |        28 | 43           |
|          3 | palmeiras           |       31 |       20 |       3 |      3 |        20 | 33           |
|          4 | juventus            |       23 |       20 |       5 |      6 |        31 | 18           |
|          5 | ypiranga-sp         |       23 |       20 |       1 |      8 |        40 | 1            |
|          6 | santos              |       21 |       20 |       1 |      9 |        39 | 6            |
|          7 | portuguesa          |       21 |       20 |       3 |      8 |        34 | 5            |
|          8 | comercial-sp        |       12 |       20 |       2 |     13 |        53 | - 16         |
|          9 | portuguesa santista |       10 |       20 |       2 |     14 |        81 | - 49         |
|         10 | são paulo railway   |        9 |       20 |       1 |     15 |        77 | - 39         |
|         11 | jabaquara           |        5 |       20 |       1 |     17 |        73 | - 43         |

Question: Which Against has a Drawn smaller than 5, a Lost of 3, and a Position of 3?

table_id: 2-15331868-1
label: SELECT MIN("Against") FROM "table" WHERE "Drawn" < 5 AND "Lost" = 3 AND "Position" = 3
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Episode   | First broadcast   | Davids team                          | Lees team                             | Scores   |
|:----------|:------------------|:-------------------------------------|:--------------------------------------|:---------|
| 2x01      | 11 july 2008      | rob brydon and krishnan guru-murthy  | gabby logan and robert webb           | 7–6      |
| 2x02      | 18 july 2008      | trisha goddard and rich hall         | frankie boyle and ben shephard        | 7–5      |
| 2x03      | 25 july 2008      | david baddiel and maureen lipman     | jimmy carr and richard wilson         | 5–6      |
| 2x04      | 1 august 2008     | michael aspel and dara ó briain      | jason manford and davina mccall       | 7–5      |
| 2x05      | 8 august 2008     | olivia colman and peter serafinowicz | hugh dennis and eamonn holmes         | 6–8      |
| 2x06      | 15 august 2008    | danny baker and anton du beke        | michael buerk and russell howard      | 6–7      |
| 2x07      | 22 august 2008    | vic reeves and shane richie          | tara palmer-tomkinson and rhys thomas | 10–3     |

Question: Name the scores for michael buerk and russell howard

table_id: 1-23575917-2
label: SELECT "Scores" FROM "table" WHERE "Lees team" = "Michael Buerk and Russell Howard"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Player            |   Rec. |   Yards |   Avg. |   TD's |   Long |
|:------------------|-------:|--------:|-------:|-------:|-------:|
| kenny higgins     |     95 |    1440 |   15.2 |     25 |     47 |
| maurice brown     |     34 |     510 |   15   |      9 |     44 |
| c. j. johnson     |     34 |     411 |   12.5 |      8 |     30 |
| demetris bendross |     15 |     158 |   10.5 |      2 |     39 |
| rocco forgione    |     14 |     152 |   10.9 |      2 |     24 |
| dan alexander     |     13 |     124 |    9.5 |      1 |     18 |
| carlos wright     |      7 |      64 |    9.1 |      1 |     15 |
| isaiah ross       |      5 |      50 |   10   |      0 |     19 |
| terrell browden   |      2 |      21 |   10.5 |      1 |     12 |
| james baron       |      2 |       7 |    3.5 |      1 |      5 |
| joe minucci       |      2 |       6 |    3   |      1 |      3 |
| ahmad hawkins     |      2 |       4 |    2   |      0 |      3 |

Question: What is the average of the player with 124 yards and less than 13 rec.?

table_id: 2-11786160-4
label: SELECT AVG("Avg.") FROM "table" WHERE "Yards" = 124 AND "Rec." < 13
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Model Number   | Frequency   | L2-Cache   | Front Side Bus   | Multiplier   | Voltage   | Socket     |
|:---------------|:------------|:-----------|:-----------------|:-------------|:----------|:-----------|
| c3 1.0a        | 1000 mhz    | 64 kib     | 133 mhz          | 7.5×         | 1.4 v     | socket 370 |
| c3 1.0b        | 1000 mhz    | 64 kib     | 133 mhz          | 7.5×         | 1.45 v    | ebga       |
| c3 1.1a        | 1133 mhz    | 64 kib     | 133 mhz          | 8.5×         | 1.4 v     | socket 370 |
| c3 1.1b        | 1133 mhz    | 64 kib     | 133 mhz          | 8.5×         | 1.45 v    | ebga       |
| c3 1.2a        | 1200 mhz    | 64 kib     | 133 mhz          | 9×           | 1.45 v    | socket 370 |
| c3 1.2b        | 1200 mhz    | 64 kib     | 133 mhz          | 9×           | v         | ebga       |
| c3 1.2c        | 1200 mhz    | 64 kib     | 200 mhz          | 6×           | v         | ebga       |
| c3 1.3a        | 1333 mhz    | 64 kib     | 133 mhz          | 10×          | 1.4 v     | socket 370 |
| c3 1.3b        | 1333 mhz    | 64 kib     | 133 mhz          | 10×          | v         | ebga       |
| c3 1.3c        | 1300 mhz    | 64 kib     | 200 mhz          | 6.5×         | v         | ebga       |
| c3 1.4a        | 1400 mhz    | 64 kib     | 133 mhz          | 10.5×        | 1.4 v     | socket 370 |
| c3 1.4b        | 1400 mhz    | 64 kib     | 133 mhz          | 10.5×        | v         | ebga       |
| c3 1.4c        | 1400 mhz    | 64 kib     | 200 mhz          | 7×           | v         | ebga       |

Question: Which Multiplier has a Front Side Bus of 200 mhz, and a Frequency of 1200 mhz?

table_id: 2-16341329-3
label: SELECT "Multiplier" FROM "table" WHERE "Front Side Bus" = "200 mhz" AND "Frequency" = "1200 mhz"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Date             | Tournament             | Surface   | Opponent in the Final   | Score         |
|:-----------------|:-----------------------|:----------|:------------------------|:--------------|
| april 20, 1997   | tokyo, japan           | hard      | amy frazier             | 4–6, 6–4, 6–4 |
| january 11, 1998 | gold coast , australia | hard      | maría vento-kabchi      | 7–5, 6–0      |
| april 19, 1998   | tokyo, japan           | hard      | corina morariu          | 6–3, 6–3      |
| march 2, 2003    | scottsdale , usa       | hard      | kim clijsters           | 3–6, 7–5, 6–4 |
| october 26, 2003 | linz , austria         | hard      | nadia petrova           | 7–5, 6–4      |
| january 10, 2004 | gold coast, australia  | hard      | nadia petrova           | 1–6, 6–1, 6–4 |

Question: Final that has a Date of january 10, 2004 had what opponent?

table_id: 2-1514559-5
label: SELECT "Opponent in the Final" FROM "table" WHERE "Date" = "january 10, 2004"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Class                | Wheel arrangement    | Fleet number(s)      | Quantity made        | Quantity preserved   |
|:---------------------|:---------------------|:---------------------|:---------------------|:---------------------|
| 2-6-0 — oooo — mogul | 2-6-0 — oooo — mogul | 2-6-0 — oooo — mogul | 2-6-0 — oooo — mogul | 2-6-0 — oooo — mogul |
| d                    | 2-6-0                | 100–107              | 8                    | 0                    |
| d-1                  | 2-6-0                | 200–207              | 8                    | 0                    |
| d-2                  | 2-6-0                | 108–172              | 65                   | 0                    |
| d-3                  | 2-6-0                | 208                  | 1                    | 0                    |
| d-4                  | 2-6-0                | 209                  | 1                    | 0                    |
| d-20                 | 2-6-0                | 2100–2120            | 21                   | 0                    |
| z                    | 2-6-0                | 322                  | 1                    | 0                    |

Question: What is Fleet Number(s), when Wheel Arrangement is "2-6-0", and when Class is "Z"?

table_id: 2-17248696-4
label: SELECT "Fleet number(s)" FROM "table" WHERE "Wheel arrangement" = "2-6-0" AND "Class" = "z"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Kanji   | Name     | Builder                        | Laid down   | Launched   | Completed   |
|:--------|:---------|:-------------------------------|:------------|:-----------|:------------|
| 春雨    | harusame | yokosuka naval arsenal , japan | 1902-02-01  | 1902-10-31 | 1903-06-26  |
| 村雨    | murasame | yokosuka naval arsenal , japan | 1902-03-20  | 1902-11-29 | 1903-07-07  |
| 速鳥    | hayatori | yokosuka naval arsenal , japan | 1902-04-15  | 1903-03-12 | 1903-08-24  |
| 朝霧    | asagiri  | yokosuka naval arsenal , japan | 1902-04-15  | 1903-04-15 | 1903-09-18  |
| 有明    | ariake   | kure naval arsenal , japan     | 1904-06-30  | 1904-12-17 | 19??-03-15  |
| 吹雪    | fubuki   | kure naval arsenal , japan     | 1904-09-29  | 1905-01-21 | 1905-02-28  |
| 霰      | arare    | kure naval arsenal , japan     | 1904-10-29  | 1905-04-05 | 1905-05-10  |

Question: What is the launched date for the Harusame ship?

table_id: 2-12639175-1
label: SELECT "Launched" FROM "table" WHERE "Name" = "harusame"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Home team       | Home team score   | Away team       | Away team score   | Venue          |   Crowd | Date          |
|:----------------|:------------------|:----------------|:------------------|:---------------|--------:|:--------------|
| hawthorn        | 17.16 (118)       | north melbourne | 11.17 (83)        | princes park   |   16106 | 25 april 1981 |
| collingwood     | 21.20 (146)       | melbourne       | 13.5 (83)         | victoria park  |   30096 | 25 april 1981 |
| richmond        | 15.22 (112)       | geelong         | 11.18 (84)        | mcg            |   46230 | 25 april 1981 |
| south melbourne | 18.22 (130)       | footscray       | 9.14 (68)         | lake oval      |   12545 | 25 april 1981 |
| st kilda        | 10.13 (73)        | carlton         | 19.23 (137)       | moorabbin oval |   32341 | 25 april 1981 |
| fitzroy         | 19.11 (125)       | essendon        | 15.14 (104)       | vfl park       |   33465 | 25 april 1981 |

Question: What is the highest crowd when fitzroy is the home team?

table_id: 2-10823950-5
label: SELECT MAX("Crowd") FROM "table" WHERE "Home team" = "fitzroy"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
|   Year | Manufacturer   |   Start |   Finish | Team         |
|-------:|:---------------|--------:|---------:|:-------------|
|   2002 | ford           |      23 |        7 | penske       |
|   2003 | dodge          |      37 |       43 | penske       |
|   2004 | dodge          |      20 |       31 | penske       |
|   2005 | dodge          |       9 |       20 | penske       |
|   2006 | dodge          |      18 |        3 | penske       |
|   2007 | dodge          |      16 |       38 | penske       |
|   2008 | dodge          |       7 |        1 | penske       |
|   2009 | chevrolet      |      36 |       36 | stewart-haas |
|   2010 | chevrolet      |      17 |       34 | stewart-haas |
|   2011 | chevrolet      |      21 |       22 | stewart-haas |
|   2012 | chevrolet      |      18 |       21 | stewart-haas |
|   2013 | chevrolet      |      34 |        5 | stewart-haas |

Question: Before 2008, if the Manufacturer is dodge and the start is under 9, what's the highest finish time?

table_id: 2-1600272-4
label: SELECT MAX("Finish") FROM "table" WHERE "Manufacturer" = "dodge" AND "Start" < 9 AND "Year" < 2008
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Rank   | Nation         |   Gold |   Silver |   Bronze |   Total |
|:-------|:---------------|-------:|---------:|---------:|--------:|
| 1      | soviet union   |      5 |        3 |        3 |      11 |
| 2      | hungary        |      2 |        3 |        6 |      11 |
| 3      | east germany   |      6 |        3 |        1 |      10 |
| 4      | sweden         |      1 |        1 |        3 |       5 |
| 5      | yugoslavia     |      2 |        1 |        0 |       3 |
| 6      | romania        |      1 |        1 |        1 |       3 |
| 7      | new zealand    |      0 |        2 |        0 |       2 |
| 8      | norway         |      0 |        1 |        1 |       2 |
| 9      | west germany   |      0 |        0 |        2 |       2 |
| 10     | france         |      1 |        0 |        0 |       1 |
| 11     | canada         |      0 |        1 |        0 |       1 |
| 12     | czechoslovakia |      0 |        1 |        0 |       1 |
| 13     | netherlands    |      0 |        1 |        0 |       1 |
| 14     | spain          |      0 |        0 |        1 |       1 |
| total  | total          |     18 |       18 |       18 |      54 |

Question: How many silver medals when the total was 2 and less than 1 bronze?

table_id: 2-18661293-4
label: SELECT SUM("Silver") FROM "table" WHERE "Bronze" < 1 AND "Total" = 2
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Name           | Years               | League    | FA Cup      | League Cup   | Europe      | Other [C ]   | Total     |
|:---------------|:--------------------|:----------|:------------|:-------------|:------------|:-------------|:----------|
| bobby charlton | 1956–1973           | 199 (606) | 0 19 0 (78) | 00 7 0 (24)  | 0 22 0 (45) | 00 2 00 (5)  | 249 (758) |
| denis law      | 1962–1973           | 171 (309) | 0 34 0 (46) | 00 3 0 (11)  | 0 28 0 (33) | 00 1 00 (5)  | 237 (404) |
| jack rowley    | 1937–1955           | 182 (380) | 0 26 0 (42) | 00 0 00 (0)  | 00 0 00 (0) | 00 3 00 (2)  | 211 (424) |
| wayne rooney   | 2004–present        | 145 (286) | 0 17 0 (29) | 00 5 0 (15)  | 0 34 0 (79) | 00 4 00 (7)  | 205 (416) |
| dennis viollet | 1952–1962           | 159 (259) | 00 5 0 (18) | 00 1 00 (2)  | 0 13 0 (12) | 00 1 00 (2)  | 179 (293) |
| george best    | 1963–1974           | 137 (361) | 0 21 0 (46) | 00 9 0 (25)  | 0 11 0 (34) | 00 1 00 (4)  | 179 (470) |
| joe spence     | 1919–1933           | 158 (481) | 0 10 0 (29) | 00 0 00 (0)  | 00 0 00 (0) | 00 0 00 (0)  | 168 (510) |
| ryan giggs     | 1991–present        | 114 (664) | 0 12 0 (74) | 0 12 0 (40)  | 0 29 (152)  | 00 1 0 (19)  | 168 (949) |
| mark hughes    | 1983–1986 1988–1995 | 120 (345) | 0 17 0 (46) | 0 16 0 (38)  | 00 9 0 (33) | 00 1 00 (5)  | 163 (467) |
| paul scholes   | 1994–2011 2012–2013 | 107 (499) | 0 13 0 (49) | 00 9 0 (21)  | 0 26 (134)  | 00 0 0 (15)  | 155 (718) |

Question: What is the value for the League Cup when the FA Cup value is 0 13 0 (49)?

table_id: 2-12783587-2
label: SELECT "League Cup" FROM "table" WHERE "FA Cup" = "0 13 0 (49)"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Proceed to Quarter-final   | Match points   | Aggregate score   |   Points margin | Eliminated from competition   |
|:---------------------------|:---------------|:------------------|----------------:|:------------------------------|
| brive                      | 4 – 0          | 102 – 29          |              73 | el salvador                   |
| clermont auvergne          | 4 – 0          | 78 – 37           |              41 | borders                       |
| sale sharks                | 4 – 0          | 58 – 25           |              33 | narbonne                      |
| grenoble                   | 4 – 0          | 65 – 38           |              27 | béziers                       |
| connacht                   | 2 – 2          | 70 – 22           |              48 | montpellier                   |
| saracens                   | 2 – 2          | 70 – 25           |              45 | overmach parma                |
| pau                        | 2 – 2          | 41 – 38           |               3 | london irish                  |

Question: How many teams eliminated béziers from competition?

table_id: 1-28068063-3
label: SELECT COUNT("Match points") FROM "table" WHERE "Eliminated from competition" = "Béziers"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Place   | Player            | Country       | Score     | To par   |
|:--------|:------------------|:--------------|:----------|:---------|
| 1       | j. b. holmes      | united states | 71-68=139 | –1       |
| t2      | ben curtis        | united states | 73-67=140 | e        |
| t2      | justin rose       | england       | 73-67=140 | e        |
| t2      | charlie wi        | south korea   | 70-70=140 | e        |
| t5      | henrik stenson    | sweden        | 71-70=141 | +1       |
| t5      | david toms        | united states | 72-69=141 | +1       |
| t8      | aaron baddeley    | australia     | 71-71=142 | +2       |
| t8      | ángel cabrera     | argentina     | 70-72=142 | +2       |
| t8      | ken duke          | united states | 69-73=142 | +2       |
| t8      | sergio garcía     | spain         | 69-73=142 | +2       |
| t8      | sean o'hair       | united states | 69-73=142 | +2       |
| t8      | jeev milkha singh | india         | 68-74=142 | +2       |
| t8      | brandt snedeker   | united states | 71-71=142 | +2       |

Question: What is the Country of the T8 Place Player with a Score of 68-74=142?

table_id: 2-17807292-4
label: SELECT "Country" FROM "table" WHERE "Place" = "t8" AND "Score" = "68-74=142"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
|   Year | Award                                | Category                          | Motive                            | Result    |
|-------:|:-------------------------------------|:----------------------------------|:----------------------------------|:----------|
|   2006 | mvpa award                           | directorial debut of the year     | switchfoot - " stars "            | won       |
|   2007 | premios lo nuestro                   | "video of the year"               | belinda - " ni freud ni tu mama " | nominated |
|   2007 | mtv video music awards latin america | "video of the year"               | belinda - " bella traición "      | won       |
|   2007 | ovmala                               | "best lighting"                   | belinda - " luz sin gravedad "    | won       |
|   2007 | ovmala                               | "best costume in a video (women)" | belinda - " bella traición "      | nominated |
|   2007 | ovmala                               | "best female video"               | belinda - " luz sin gravedad "    | won       |

Question: What is the motive before 2007?

table_id: 2-12618081-1
label: SELECT "Motive" FROM "table" WHERE "Year" < 2007
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Date         | Opponent   | City        | Result   | Score   |
|:-------------|:-----------|:------------|:---------|:--------|
| september 18 | illinois   | champaign   | win      | 32-18   |
| september 25 | ohio state | columbus    | win      | 28-13   |
| october 2    | iowa state | ames        | win      | 33-13   |
| october 9    | iowa       | iowa city   | win      | 25-0    |
| october 16   | missouri   | kansas city | win      | 21-6    |
| october 30   | fort riley | iowa city   | win      | 19-2    |
| november 7   | marquette  | milwaukee   | win      | 46-19   |
| november 13  | camp grant | iowa city   | win      | 28-13   |
| november 20  | notre dame | south bend  | loss     | 13-14   |
| november 27  | minnesota  | minneapolis | win      | 32-0    |

Question: What was the score for the game against Marquette?

table_id: 2-12261783-2
label: SELECT "Score" FROM "table" WHERE "Opponent" = "marquette"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Season    | Regionalliga Süd                     | Regionalliga West/Südwest   | Regionalliga Nord   | Regionalliga Nord-Ost   |
|:----------|:-------------------------------------|:----------------------------|:--------------------|:------------------------|
| 1994-95   | spvgg unterhaching                   | arminia bielefeld           | vfb lübeck          | carl zeiss jena         |
| 1995-96   | stuttgarter kickers                  | fc gütersloh rot-weiß essen | vfb oldenburg       | tennis borussia berlin  |
| 1996-97   | 1. fc nuremberg spvgg greuther fürth | sg wattenscheid 09          | hannover 96         | energie cottbus         |
| 1997-98   | ssv ulm 1846                         | rot-weiß oberhausen         | hannover 96         | tennis borussia berlin  |
| 1998-99   | waldhof mannheim kickers offenbach   | alemannia aachen            | vfl osnabrück       | chemnitzer fc           |
| 1999–2000 | ssv reutlingen                       | 1. fc saarbrücken lr ahlen  | vfl osnabrück       | 1. fc union berlin      |

Question: What was the Regionalliga Nord-Ost for the team that had a Regionalliga Sud of SpVgg Unterhaching?

table_id: 2-14242137-11
label: SELECT "Regionalliga Nord-Ost" FROM "table" WHERE "Regionalliga Süd" = "spvgg unterhaching"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
|   Game | Date     | Team      | Score         | High points           | High rebounds      | High assists       | Location Attendance   | Series   |
|-------:|:---------|:----------|:--------------|:----------------------|:-------------------|:-------------------|:----------------------|:---------|
|      1 | april 16 | atlanta   | l 93–103 (ot) | dwight howard (46)    | dwight howard (19) | hedo türkoğlu (5)  | amway center 19,108   | 0–1      |
|      2 | april 19 | atlanta   | w 88–82 (ot)  | dwight howard (33)    | dwight howard (19) | hedo türkoğlu (5)  | amway center 19,160   | 1–1      |
|      3 | april 22 | @ atlanta | l 84–88 (ot)  | dwight howard (21)    | dwight howard (15) | jameer nelson (10) | philips arena 19,865  | 1–2      |
|      4 | april 24 | @ atlanta | l 85–88 (ot)  | dwight howard (29)    | dwight howard (17) | jameer nelson (6)  | philips arena 19,490  | 1–3      |
|      5 | april 26 | atlanta   | w 101–76 (ot) | jason richardson (17) | dwight howard (8)  | jameer nelson (5)  | amway center 19,091   | 2–3      |

Question: What was the series record at after game 3?

table_id: 1-27700530-15
label: SELECT "Series" FROM "table" WHERE "Game" = 3