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:
| Institution          | Location                  |   Founded | Type    |   Enrollment | Nickname   |   Joined |   Left | Current Conference     |
|:---------------------|:--------------------------|----------:|:--------|-------------:|:-----------|---------:|-------:|:-----------------------|
| anna maria college   | paxton, massachusetts     |      1946 | private |         1432 | amcats     |     1984 |   2011 | great northeast (gnac) |
| colby–sawyer college | new london, new hampshire |      1837 | private |         1200 | chargers   |     1994 |   2011 | north atlantic (nac)   |
| emerson college      | boston, massachusetts     |      1880 | private |         4290 | lions      |     1984 |   1989 | newmac                 |
| hellenic college     | brookline, massachusetts  |      1937 | private |          222 | owls       |     1984 |   1985 | dropped athletics      |
| new england college  | henniker, new hampshire   |      1946 | private |         1460 | pilgrims   |     1989 |   2011 | north atlantic (nac)   |
| regis college †      | weston, massachusetts     |      1927 | private |         1737 | pride      |     1988 |   2011 | necc                   |

Question: What is the latest founded year?

table_id: 1-1973729-2
label: SELECT MAX("Founded") FROM "table"
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:
|   Pick # | CFL Team                                        | Player             | Position   | College            |
|---------:|:------------------------------------------------|:-------------------|:-----------|:-------------------|
|       25 | hamilton tiger-cats (via montreal via hamilton) | robert pavlovic    | te         | south carolina     |
|       26 | edmonton eskimos                                | micheal jean-louis | dl         | laval              |
|       27 | edmonton eskimos (via winnipeg)                 | calvin mccarty     | rb         | western washington |
|       28 | saskatchewan roughriders                        | ryan ackerman      | ol         | regina             |
|       29 | toronto argonauts                               | eric maranda       | lb         | laval              |
|       30 | toronto argonauts (via calgary)                 | steve schmidt      | te         | san diego state    |
|       31 | montreal alouettes                              | james judges       | de         | buffalo            |

Question: How many people were pick #30?

table_id: 1-10812403-4
label: SELECT COUNT("Position") FROM "table" WHERE "Pick #" = 30
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:
|   Round # |   Pick # | Player           | Position       | College            |
|----------:|---------:|:-----------------|:---------------|:-------------------|
|         1 |       26 | henry jones      | defensive back | illinois           |
|         2 |       54 | phil hansen      | defensive end  | north dakota state |
|         3 |       82 | darryl wren      | defensive back | pittsburg state    |
|         4 |      138 | shawn wilbourn   | defensive back | long beach state   |
|         5 |      166 | millard hamilton | wide receiver  | clark university   |
|         6 |      194 | amir rasul       | running back   | florida a&m        |
|         8 |      222 | brad lamb        | wide receiver  | anderson           |
|         9 |      249 | mark maddox      | linebacker     | northern michigan  |
|        10 |      277 | tony delorenzo   | guard          | new mexico state   |
|        11 |      305 | dean kirkland    | guard          | washington         |

Question: Which player went to Pittsburg State

table_id: 1-15353123-1
label: SELECT "Player" FROM "table" WHERE "College" = "Pittsburg State"
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:
|   Pick | Round          | Player            | Free Agent Class   | New Team                      |
|-------:|:---------------|:------------------|:-------------------|:------------------------------|
|     16 | 1              | frank catalanotto | type a             | texas rangers                 |
|     38 | compensation-a | justin speier     | type a             | los angeles angels of anaheim |
|     45 | compensation-a | frank catalanotto | type a             | texas rangers                 |
|     56 | compensation-a | ted lilly         | type b             | chicago cubs                  |
|     88 | 2              | justin speier     | type a             | los angeles angels of anaheim |

Question: Which new team has a compensation-a round, and Frank Catalanotto as a player?

table_id: 2-12014051-1
label: SELECT "New Team" FROM "table" WHERE "Round" = "compensation-a" AND "Player" = "frank catalanotto"
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    | Winning Team   | Losing Team   | Score            | Venue              |
|:--------|:---------------|:--------------|:-----------------|:-------------------|
| june 14 | devil rays     | marlins       | 4-3 (14 innings) | pro player stadium |
| june 15 | marlins        | devil rays    | 3-0              | pro player stadium |
| june 16 | devil rays     | marlins       | 4-1              | pro player stadium |
| june 28 | devil rays     | marlins       | 4-0              | tropicana field    |
| june 29 | marlins        | devil rays    | 3-2              | tropicana field    |
| june 30 | devil rays     | marlins       | 6-5 (12 innings) | tropicana field    |

Question: What was the score of the game on June 28?

table_id: 2-11506714-2
label: SELECT "Score" FROM "table" WHERE "Date" = "june 28"
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   | Graemes guest   | Jeremys guest     | Votes (%)   |
|:----------|:------------------|:----------------|:------------------|:------------|
| 1x01      | 27 february 1998  | maria mcerlane  | tony hawks        | 75–25       |
| 1x02      | 6 march 1998      | fred macaulay   | rebecca front     | 56–44       |
| 1x03      | 13 march 1998     | greg proops     | tim brooke-taylor | 52–48       |
| 1x04      | 20 march 1998     | gordon kennedy  | pauline mclynn    | 57–43       |
| 1x05      | 27 march 1998     | andy hamilton   | richard wilson    | tbc         |

Question: what is the name of the jeremy guest for the episode 1x01

table_id: 1-17413485-1
label: SELECT "Jeremys guest" FROM "table" WHERE "Episode" = "1x01"
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       | City               | Opponent   | Results¹   | Type of game   |
|:-----------|:-------------------|:-----------|:-----------|:---------------|
| january 16 | cairo , egypt      | egypt      | 3:1        | friendly       |
| may 9      | belgrade           | greece     | 1:0        | 1954 wcq       |
| may 14     | brussels , belgium | belgium    | 3:1        | friendly       |
| may 21     | belgrade           | wales      | 5:2        | friendly       |
| june 5     | zagreb             | turkey     | 2:2        | friendly       |
| october 18 | zagreb             | france     | 3:1        | friendly       |
| november 8 | skoplje            | israel     | 1:0        | 1954 wcq       |

Question: What were the results against the game against Egypt?

table_id: 2-14305653-31
label: SELECT "Results¹" FROM "table" WHERE "Opponent" = "egypt"
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:
| Reserve         | District             | IUCN   |   Est. | Description                                        |
|:----------------|:---------------------|:-------|-------:|:---------------------------------------------------|
| aguacaliente    | toledo               | iv     |   1998 | terrestrial.                                       |
| cockscomb basin | stann creek / toledo | iv     |   1997 | terrestrial.                                       |
| corozal bay     | belize / corozal     | iv     |   1998 | marine.                                            |
| crooked tree    | belize / orange walk | iv     |   1984 | ramsar site . boundaries ill defined. terrestrial. |
| gales point     | belize               | iv     |   1998 | terrestrial.                                       |
| spanish creek   | belize / orange walk | iv     |   2002 | terrestrial.                                       |
| swallow caye    | belize               | iv     |   2002 | marine.                                            |

Question: What is the IUCN for the Cockscomb Basin reserve when the Est. is less than 1998?

table_id: 2-17625231-4
label: SELECT "IUCN" FROM "table" WHERE "Est." < 1998 AND "Reserve" = "cockscomb basin"
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:
| Code Name   | Function (figure)      | Real Name               | Birthplace                 | Serial number   | Primary military speciality   | Secondary military speciality   |
|:------------|:-----------------------|:------------------------|:---------------------------|:----------------|:------------------------------|:--------------------------------|
| sky raider  | commander              | charles 'chuck' connors | cincinnati                 | af 934101       | space battle tactics          | space command                   |
| blast off   | space patroller        | greg taggart            | sydney , australia         | af 934102       | weapons                       | freefall aerobatics             |
| kiwi        | space engineer         | scott walters           | christchurch , new zealand | af 934777       | computer engineering          | freefall combat                 |
| hot jets    | space pilot            | yuri ivanovich asimov   | leningrad , russia         | af 934100       | space astrogation             | pilot instructor                |
| hawkwind    | space security trooper | lars elsund             | stockholm                  | af 934103       | combat helipilot              | unarmed combat                  |
| moondancer  | triad fighter pilot    | tariq el shafei         | middle east                | af 934848       | astral assault tactics        | rapid space deployment          |

Question: What is the Code Name for the Space Pilot Function (figure)?

table_id: 2-13130124-1
label: SELECT "Code Name" FROM "table" WHERE "Function (figure)" = "space pilot"
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   | Away team   | Match score              | "Pick The Winners" score   | FootyTAB winner   |
|:------------|:------------|:-------------------------|:---------------------------|:------------------|
| canberra    | st. george  | canberra 8 st. george 22 | canberra 8 st. george 29.5 | st. george        |
| balmain     | canterbury  | balmain 14 canterbury 19 | balmain 20.5 canterbury 19 | balmain           |
| newcastle   | easts       | newcastle 10 easts 20    | newcastle 10 easts 25.5    | easts             |
| norths      | manly       | norths 19 manly 4        | norths 20.5 manly 4        | norths            |
| penrith     | parramatta  | penrith 10 parramatta 11 | penrith 10 parramatta 18.5 | parramatta        |
| cronulla    | brisbane    | cronulla 10 brisbane 19  | cronulla 19.5 brisbane 19  | cronulla          |
| wests       | gold coast  | wests 14 gold coast 10   | wests 14 gold coast 19.5   | gold coast        |
| illawarra   | souths      | illawarra 19 souths 0    | illawarra 19 souths 5.5    | illawarra         |

Question: What is the Home team when the "Pick The Winners" score was newcastle 10 easts 25.5?

table_id: 2-15427451-1
label: SELECT "Home team" FROM "table" WHERE """Pick The Winners"" score" = "newcastle 10 easts 25.5"
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        | H/A/N   | Opponent               | Score   | Record   |
|:------------|:--------|:-----------------------|:--------|:---------|
| february 1  | a       | buffalo braves         | 104-99  | 17-37    |
| february 2  | a       | detroit pistons        | 108-133 | 17-38    |
| february 4  | h       | seattle supersonics    | 112-118 | 17-39    |
| february 5  | a       | atlanta hawks          | 117-120 | 17-40    |
| february 6  | h       | buffalo braves         | 108-121 | 17-41    |
| february 8  | a       | chicago bulls          | 90-114  | 17-42    |
| february 9  | h       | milwaukee bucks        | 121-126 | 17-43    |
| february 12 | a       | new york knicks        | 91-106  | 17-44    |
| february 13 | h       | detroit pistons        | 121-136 | 17-45    |
| february 16 | a       | philadelphia 76ers     | 116-121 | 17-46    |
| february 18 | h       | cincinnati royals      | 133-109 | 18-46    |
| february 19 | a       | cincinnati royals      | 92-112  | 18-47    |
| february 20 | h       | new york knicks        | 111-109 | 19-47    |
| february 23 | h       | boston celtics         | 111-113 | 19-48    |
| february 25 | h       | portland trail blazers | 113-104 | 20-48    |
| february 27 | h       | phoenix suns           | 125-127 | 20-49    |

Question: What is H/A/N, when Record is 20-48?

table_id: 2-16946097-7
label: SELECT "H/A/N" FROM "table" WHERE "Record" = "20-48"
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:
| Official Name   | Status   | Area km 2   |   Population | Census Ranking   |
|:----------------|:---------|:------------|-------------:|:-----------------|
| drummond        | parish   | 1,014.90    |         2250 | 1,231 of 5,008   |
| denmark         | parish   | 750.51      |         1592 | 1,561 of 5,008   |
| gordon          | parish   | 1,430.98    |         1567 | 1,574 of 5,008   |
| grand falls     | parish   | 158.43      |         1172 | 1,871 of 5,008   |
| perth           | parish   | 318.06      |         1096 | 1,956 of 5,008   |
| andover         | parish   | 123.57      |          942 | 2,160 of 5,008   |

Question: What is the minimum population of the parish with a 750.51 km area?

table_id: 1-176524-2
label: SELECT MIN("Population") FROM "table" WHERE "Area km 2" = "750.51"
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   |   Money ( $ ) |
|:--------|:--------------|:--------------|:----------------|:---------|--------------:|
| 1       | raymond floyd | united states | 65-66-70-70=271 | –17      |         40000 |
| 2       | ben crenshaw  | united states | 70-70-72-67=279 | –9       |         25000 |
| t3      | jack nicklaus | united states | 67-69-73-73=282 | –6       |         16250 |
| t3      | larry ziegler | united states | 67-71-72-72=282 | –6       |         16250 |
| t5      | charles coody | united states | 72-69-70-74=285 | –3       |         11167 |
| t5      | hale irwin    | united states | 71-77-67-70=285 | –3       |         11167 |
| t5      | tom kite      | united states | 73-67-72-73=285 | –3       |         11167 |
| 8       | billy casper  | united states | 71-76-71-69=287 | -1       |          8000 |
| t9      | roger maltbie | united states | 72-75-70-71=288 | e        |          6000 |
| t9      | graham marsh  | australia     | 73-68-75-72=288 | e        |          6000 |
| t9      | tom weiskopf  | united states | 73-71-70-74=288 | e        |          6000 |

Question: what is the to par when the player is roger maltbie?

table_id: 2-16457056-1
label: SELECT "To par" FROM "table" WHERE "Player" = "roger maltbie"
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       | paul broadhurst    | england       |      65 | –6       |
| t2      | mark brooks        | united states |      67 | –4       |
| t2      | fred couples       | united states |      67 | –4       |
| t2      | brad faxon         | united states |      67 | –4       |
| t2      | tom lehman         | united states |      67 | –4       |
| t2      | mark mccumber      | united states |      67 | –4       |
| t2      | mark o'meara       | united states |      67 | –4       |
| t2      | loren roberts      | united states |      67 | –4       |
| t2      | hidemichi tanaka   | japan         |      67 | –4       |
| t10     | ernie els          | south africa  |      68 | –3       |
| t10     | klas eriksson      | sweden        |      68 | –3       |
| t10     | nick faldo         | england       |      68 | –3       |
| t10     | jim furyk          | united states |      68 | –3       |
| t10     | pádraig harrington | ireland       |      68 | –3       |
| t10     | shigeki maruyama   | japan         |      68 | –3       |
| t10     | carl mason         | england       |      68 | –3       |
| t10     | nick price         | zimbabwe      |      68 | –3       |

Question: What is the lowest score that has t10 as the place, with Ireland as the country?

table_id: 2-18097219-4
label: SELECT MIN("Score") FROM "table" WHERE "Place" = "t10" AND "Country" = "ireland"
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 | Winners   |   Total wins | Runners-up   | Third-place   |   Number of clubs |
|---------:|:----------|-------------:|:-------------|:--------------|------------------:|
|     1987 | liaoning  |            1 | tianjin      | shanghai      |                 8 |
|     1988 | liaoning  |            2 | shandong     | shanghai      |                21 |
|     1989 | china b   |            1 | liaoning     | shanghai      |                 8 |
|     1990 | liaoning  |            3 | august 1st   | dalian        |                 8 |
|     1991 | liaoning  |            4 | shanghai     | beijing       |                 8 |
|     1992 | liaoning  |            5 | guangzhou fc | dalian        |                 8 |
|     1993 | liaoning  |            6 | guangdong    | beijing       |                 8 |

Question: Who is third-place with less than 5 total wins with china b as the winners?

table_id: 2-17632217-1
label: SELECT "Third-place" FROM "table" WHERE "Total wins" < 5 AND "Winners" = "china b"
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           |       36 |       20 |       2 |      1 |        20 | 50           |
|          2 | corinthians         |       31 |       20 |       3 |      3 |        24 | 32           |
|          3 | palmeiras           |       29 |       20 |       7 |      2 |        17 | 30           |
|          4 | portuguesa          |       25 |       20 |       5 |      5 |        22 | 22           |
|          5 | jabaquara           |       20 |       20 |       2 |      9 |        65 | - 17         |
|          6 | santos              |       18 |       20 |       2 |     10 |        46 | - 12         |
|          7 | ypiranga-sp         |       17 |       20 |       1 |     11 |        44 | - 7          |
|          8 | são paulo railway   |       14 |       20 |       2 |     12 |        52 | - 15         |
|          9 | juventus            |       12 |       20 |       2 |     13 |        45 | - 11         |
|         10 | comercial-sp        |       11 |       20 |       3 |     13 |        60 | - 28         |
|         11 | portuguesa santista |        7 |       20 |       3 |     15 |        69 | - 44         |

Question: What is the lowest Points with an against of 20 and less than 1 lost?

table_id: 2-15331084-1
label: SELECT MIN("Points") FROM "table" WHERE "Against" = 20 AND "Lost" < 1
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      | brazil (bra)         |      2 |        0 |        1 |       3 |
| 1      | south korea (kor)    |      2 |        0 |        1 |       3 |
| 3      | portugal (por)       |      1 |        3 |        1 |       5 |
| 4      | great britain (gbr)  |      1 |        1 |        0 |       2 |
| 4      | hong kong (hkg)      |      1 |        1 |        0 |       2 |
| 6      | spain (esp)          |      0 |        1 |        2 |       3 |
| 7      | greece (gre)         |      0 |        1 |        0 |       1 |
| 8      | czech republic (cze) |      0 |        0 |        1 |       1 |
| 8      | ireland (irl)        |      0 |        0 |        1 |       1 |
| total  | total                |      7 |        7 |        7 |      21 |

Question: What is the least total number of medals when the bronze medals is 1, and Czech Republic (CZE) is the nation?

table_id: 2-18395141-2
label: SELECT MIN("Total") FROM "table" WHERE "Bronze" = 1 AND "Nation" = "czech republic (cze)"
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 | Winner             | Jockey             | Trainer                     | Owner                                        | Time     | Purse    |
|-------:|:-------------------|:-------------------|:----------------------------|:---------------------------------------------|:---------|:---------|
|   2013 | london bridge      | mike smith         | jo hughes                   | eastwind racing & martha trussell            | 2:58.32  | $500,000 |
|   2012 | calidoscopio (arg) | aaron gryder       | guillermo frenkel santillán | stud dona pancha                             | 2:57.25  | $500,000 |
|   2011 | afleet again       | cornelio velasquez | robert e. reid, jr.         | kasey k racing stable                        | 3:00.39  | $500,000 |
|   2010 | eldaafer           | john velazquez     | diane alvardo               | ieah stables and mansour albaroudy           | 2:59.62  | $500,000 |
|   2009 | man of iron        | johnny murtagh     | aidan o'brien               | derrick smith/ susan magnier / michael tabor | 2:54.11  | $500,000 |
|   2008 | muhannak           | pat smullen        | ralph beckett               | richard pegum                                | 2:28.24† | $500,000 |

Question: What is the purse for the year earlier than 2013 and muhannak was the winner?

table_id: 2-14644714-1
label: SELECT "Purse" FROM "table" WHERE "Year" < 2013 AND "Winner" = "muhannak"
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:
| Call sign   |   Frequency MHz | City of license        |   ERP W | Class   | FCC info   |
|:------------|----------------:|:-----------------------|--------:|:--------|:-----------|
| k206cc      |            89.1 | lockwood, california   |      10 | d       | fcc        |
| k205bn      |            88.9 | los gatos, california  |      77 | d       | fcc        |
| k257be      |            99.3 | los gatos, california  |      10 | d       | fcc        |
| k208cw      |            89.5 | monterey, california   |      74 | d       | fcc        |
| k272cg      |           102.3 | morro bay, california  |       7 | d       | fcc        |
| k220bv      |            91.9 | san jose, california   |      10 | d       | fcc        |
| k276br      |           103.1 | santa cruz, california |       5 | d       | fcc        |
| k236aj      |            95.1 | soledad, california    |      10 | d       | fcc        |
| k217co      |            91.3 | carmel, california     |      10 | d       | fcc        |

Question: What call sign is licensed in soledad, california?

table_id: 2-13975482-1
label: SELECT "Call sign" FROM "table" WHERE "City of license" = "soledad, california"