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:
| Time           | Show Name                      | DJ's                 | Local/Networked   | Ad Freq              | News Freq   |
|:---------------|:-------------------------------|:---------------------|:------------------|:---------------------|:------------|
| 5am-9:00am     | sarah and dwayne for breakfast | sarah and dwayne     | local             | 15 minutes           | 30 minutes  |
| 9:00am–2:00pm  | widest variety                 | cameron humphries    | local             | no traffic           | 30 minutes  |
| 2:00pm–7:00pm  | greg "clarkey" clarke          | clarkey              | local             | 20 minutes           | 60 minutes  |
| 7:00pm–11:00pm | the love lounge                | marea lambert-barker | networked         | 20 minutes until 7pm | 20 minutes  |
| 11:00pm–4:00am | talking back the night         | jamie mcdonald       | networked         | 20 minutes           | 1 hour      |
| 4:00pm–5:00am  | best mix overnight             | jamie mcdonald       | networked         | 20 minutes           | 1 hour      |

Question: What show has Cameron Humphries DJ'ing?

table_id: 2-18992167-1
label: SELECT "Show Name" FROM "table" WHERE "DJ''s" = "cameron humphries"
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:
| Television Station   | Frequency   | Site          | Transmitted      | Network                         | Status   | Country of Region   |
|:---------------------|:------------|:--------------|:-----------------|:--------------------------------|:---------|:--------------------|
| tv1                  | 28 uhf      | gunung ledang | 10 kw/800 kw erp | radio televisyen malaysia (rtm) | national | malaysia            |
| tv2                  | 7 uhf       | gunung ledang | 10 kw/800 kw erp | radio televisyen malaysia (rtm) | national | malaysia            |
| tv3                  | 12 uhf      | gunung ledang | 20 kw            | media prima berhad              | national | malaysia            |
| ntv7                 | 35 uhf      | gunung ledang | 20 kw            | media prima berhad              | national | malaysia            |
| 8tv                  | 48 uhf      | gunung ledang | 20 kw            | media prima berhad              | national | malaysia            |

Question: How many stations are transmitted on frequency 7 uhf?

table_id: 1-1601792-4
label: SELECT COUNT("Transmitted") FROM "table" WHERE "Frequency" = "7 UHF"
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:
| Province     | Formed date     | Formed from   | Dissolution date   | Reason              |
|:-------------|:----------------|:--------------|:-------------------|:--------------------|
| auckland     | 17 january 1853 | new ulster    | 1 november 1876    | provinces abolished |
| new plymouth | 17 january 1853 | new ulster    | 1 november 1876    | provinces abolished |
| hawke's bay  | 1 november 1858 | wellington    | 1 november 1876    | provinces abolished |
| wellington   | 17 january 1853 | new munster   | 1 november 1876    | provinces abolished |
| nelson       | 17 january 1853 | new munster   | 1 november 1876    | provinces abolished |
| marlborough  | 1 november 1859 | nelson        | 1 november 1876    | provinces abolished |
| westland     | 1 december 1873 | canterbury    | 1 november 1876    | provinces abolished |
| canterbury   | 17 january 1853 | new munster   | 1 november 1876    | provinces abolished |
| otago        | 17 january 1853 | new munster   | 1 november 1876    | provinces abolished |

Question: How many provinces are named Wellington?

table_id: 1-275023-1
label: SELECT COUNT("Formed date") FROM "table" WHERE "Province" = "Wellington"
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 |   Played |   Points |   Wins |   Draws |   Losses |   Goals for |   Goals against |   Goal Difference |
|-----------:|---------:|---------:|-------:|--------:|---------:|------------:|----------------:|------------------:|
|          1 |       10 |       14 |      5 |       4 |        1 |          27 |              10 |                17 |
|          2 |       10 |       13 |      5 |       3 |        2 |          20 |              14 |                 6 |
|          3 |       10 |       11 |      5 |       1 |        4 |          27 |              20 |                 7 |
|          4 |       10 |        9 |      4 |       1 |        5 |          23 |              21 |                 2 |
|          5 |       10 |        8 |      3 |       2 |        5 |          11 |              21 |               -10 |
|          6 |       10 |        5 |      2 |       1 |        7 |          13 |              35 |               -22 |

Question: What is the average draws with less than 3 wins and more than 5 points?

table_id: 2-17298923-5
label: SELECT AVG("Draws") FROM "table" WHERE "Wins" < 3 AND "Points" > 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:
| Home team       | Home team score   | Away team       | Away team score   | Venue           |   Crowd | Date       |
|:----------------|:------------------|:----------------|:------------------|:----------------|--------:|:-----------|
| melbourne       | 16.16 (112)       | st kilda        | 10.21 (81)        | mcg             |   25703 | 6 may 1939 |
| essendon        | 16.8 (104)        | richmond        | 15.16 (106)       | windy hill      |   21000 | 6 may 1939 |
| collingwood     | 17.11 (113)       | footscray       | 14.14 (98)        | victoria park   |   20000 | 6 may 1939 |
| carlton         | 17.21 (123)       | north melbourne | 16.10 (106)       | princes park    |   18000 | 6 may 1939 |
| hawthorn        | 17.14 (116)       | geelong         | 8.18 (66)         | glenferrie oval |   12000 | 6 may 1939 |
| south melbourne | 9.14 (68)         | fitzroy         | 10.17 (77)        | lake oval       |   15000 | 6 may 1939 |

Question: When Geelong is the Away team, what did the Home team score?

table_id: 2-10806852-3
label: SELECT "Home team score" FROM "table" WHERE "Away team" = "geelong"
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             | Result   | Score   | Brazil scorers                              | Competition                               |
|:-----------------|:---------|:--------|:--------------------------------------------|:------------------------------------------|
| may 17, 1979     | w        | 6-0     | éder , zico (3), nílton batata (2)          | international friendly                    |
| may 31, 1979     | w        | 5-1     | edinho , sócrates (2), nílton batata , éder | international friendly                    |
| june 21, 1979    | w        | 5-0     | sócrates (2), toninho , zico (2)            | international friendly (unofficial match) |
| july 5, 1979     | d        | 1-1     | juary                                       | international friendly (unofficial match) |
| july 26, 1979    | l        | 1-2     | roberto dinamite                            | copa américa                              |
| august 2, 1979   | w        | 2-1     | tita , zico                                 | copa américa                              |
| august 16, 1979  | w        | 2-0     | tita , zico                                 | copa américa                              |
| august 23, 1979  | d        | 2-2     | sócrates (2)                                | copa américa                              |
| october 24, 1979 | l        | 1-2     | palhinha                                    | copa américa                              |
| october 31, 1979 | d        | 2-2     | falcão , sócrates                           | copa américa                              |

Question: What Competition had a game on October 31, 1979?

table_id: 2-15152729-6
label: SELECT "Competition" FROM "table" WHERE "Date" = "october 31, 1979"
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:
| Actor/actress        | Character             | Rank                 | Tenure    | Episodes   |
|:---------------------|:----------------------|:---------------------|:----------|:-----------|
| rodger corser        | lawson blake          | senior sergeant      | 2008–2011 | 01–70      |
| callan mulvey        | brendan 'josh' joshua | sergeant             | 2008–2011 | 01–70      |
| claire van der boom  | grace barry           | senior constable     | 2008      | 01–11      |
| josef ber            | dominic wales         | sergeant             | 2008–2010 | 01–51      |
| nicole da silva      | stella dagostino      | senior constable     | 2008–2011 | 01–70      |
| ashley zukerman      | michael sandrelli     | senior constable     | 2008–2011 | 01-65      |
| samuel johnson       | leon broznic          | intelligence officer | 2008–2011 | 01-70      |
| catherine mcclements | kerry vincent         | superintendent       | 2008–2011 | 01-70      |
| jolene anderson      | shannon henry         | sergeant             | 2009–2011 | 14-70      |
| kevin hofbauer       | christian tapu        | constable            | 2010–2011 | 36-70      |
| antony starr         | charlie lewis         | senior sergeant      | 2011      | 58-70      |

Question: What Rodger Corser Episode has a Rank of senior sergeant?

table_id: 2-17798548-1
label: SELECT "Episodes" FROM "table" WHERE "Rank" = "senior sergeant" AND "Actor/actress" = "rodger corser"
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:
| DVD title                    | Season       | Aspect ratio   |   Episode count | Time length   | Release date      |
|:-----------------------------|:-------------|:---------------|----------------:|:--------------|:------------------|
| ben 10: alien force volume 1 | season one   | 4:3            |               5 | 110 minutes   | october 21, 2008  |
| ben 10: alien force volume 2 | season one   | 4:3            |               4 | 88 minutes    | january 13, 2009  |
| ben 10: alien force volume 3 | season one   | 4:3            |               4 | 88 minutes    | april 7, 2009     |
| ben 10: alien force volume 4 | season two   | 16:9           |               5 | 113 minutes   | september 1, 2009 |
| ben 10: alien force volume 5 | season two   | 16:9           |               4 | 90 minutes    | november 17, 2009 |
| ben 10: alien force volume 6 | season two   | 16:9           |               4 | 90 minutes    | march 30, 2010    |
| ben 10: alien force volume 7 | season three | 16:9           |               7 | 159 minutes   | june 29, 2010     |
| ben 10: alien force volume 8 | season three | 16:9           |               6 | 136 minutes   | august 24, 2010   |
| ben 10: alien force volume 9 | season three | 16:9           |               7 | 180 minutes   | october 5, 2010   |

Question: What is the release date for Ben 10: Alien Force Volume 9 on DVD?

table_id: 2-16581695-7
label: SELECT "Release date" FROM "table" WHERE "DVD title" = "ben 10: alien force volume 9"
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:
|   Standard order | English translation            | Transcription (based on Pinyin)   | Traditional Chinese   | Simplified Chinese   |
|-----------------:|:-------------------------------|:----------------------------------|:----------------------|:---------------------|
|                1 | grieving i make my plaint      | xi song                           | 惜誦                  | 惜诵                 |
|                2 | crossing the river             | she jiang                         | 涉江                  | 涉江                 |
|                3 | a lament for ying              | ai ying                           | 哀郢                  | 哀郢                 |
|                4 | the outpouring of sad thoughts | chou si                           | 抽思                  | 抽思                 |
|                5 | embracing sand                 | huai sha                          | 懷沙                  | 怀沙                 |
|                6 | thinking of a fair one         | si meiren                         | 思美人                | 思美人               |
|                7 | alas for the days gone by      | xi wangri                         | 昔往日                | 昔往日               |
|                8 | in praise of the orange-tree   | ju song                           | 橘頌                  | 橘颂                 |
|                9 | grieving at the eddying wind   | bei hui feng                      | 悲回風                | 悲回风               |

Question: What is the highest standard order for the Transcription based on Pinyin, She Jiang?

table_id: 2-1805919-1
label: SELECT MAX("Standard order") FROM "table" WHERE "Transcription (based on Pinyin)" = "she jiang"
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:
|   # | Spacecraft              | Spacewalkers                     | Start ( UTC )           | End (UTC)               | Duration    |
|----:|:------------------------|:---------------------------------|:------------------------|:------------------------|:------------|
| 240 | iss expedition 10 eva 1 | leroy chiao salizhan sharipov    | january 26, 2005, 07:43 | january 26, 2005, 13:11 | 5 h, 28 min |
| 241 | iss expedition 10 eva 2 | leroy chiao salizhan sharipov    | march 28, 2005, 06:25   | march 28, 2005, 11:31   | 5 h, 06 min |
| 242 | sts-114 eva 1           | soichi noguchi stephen robinson  | july 30, 2005, 05:46    | july 30, 2005, 12:36    | 6 h, 50 min |
| 243 | sts-114 eva 2           | soichi noguchi stephen robinson  | august 1, 2005, 04:44   | august 1, 2005, 11:58   | 7 h, 14 min |
| 244 | sts-114 eva 3           | soichi noguchi stephen robinson  | august 3, 2005, 04:14   | august 3, 2005, 10:15   | 6 h, 01 min |
| 245 | iss expedition 11 eva 1 | sergei krikalev john l. phillips | august 18, 2005, 19:02  | august 19, 2005, 00:00  | 4 h, 58 min |

Question: What is the end (UTC) for spacecraft STS-114 Eva 3?

table_id: 1-22385461-6
label: SELECT "End (UTC)" FROM "table" WHERE "Spacecraft" = "STS-114 EVA 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:
|   Rank | Name                                    |   Floors* | Year* (est.)   | Status                     |
|-------:|:----------------------------------------|----------:|:---------------|:---------------------------|
|      1 | museum plaza                            |        62 | n/a            | cancelled; plans abandoned |
|      2 | capital plaza                           |        25 | 2012           | proposed                   |
|      3 | jefferson development                   |        18 | 2010           | proposed                   |
|      4 | willow grande                           |        17 | 2011           | proposed                   |
|      5 | riverpark place tower 2                 |        16 | 2008           | proposed                   |
|      6 | riverpark place tower 1                 |        16 | 2008           | proposed                   |
|      7 | central city district residential tower |        15 | 2010           | proposed                   |
|      8 | zirmed gateway towers                   |        12 | 2009           | completed                  |

Question: What is the lowest rank of the building with 12 floors?

table_id: 2-17473119-2
label: SELECT MIN("Rank") FROM "table" WHERE "Floors*" = 12
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   | Ground                |   Crowd | Date                           |
|:-----------------|:------------------|:---------------|:------------------|:----------------------|--------:|:-------------------------------|
| essendon         | 2.13.11 (107)     | fremantle      | 1.13.12 (99)      | marrara oval          |   13196 | friday, 20 february, 7:10 pm   |
| western bulldogs | 0.12.9 (81)       | richmond       | 2.13.9 (105)      | telstra dome          |   22537 | friday, 20 february, 7:40 pm   |
| kangaroos        | 2.10.13 (91)      | melbourne      | 4.11.11 (113)     | manuka oval           |    3227 | saturday, 21 february, 1:10 pm |
| west coast       | 1.18.14 (131)     | collingwood    | 0.2.14 (26)       | subiaco oval          |   24101 | saturday, 21 february, 5:40 pm |
| port adelaide    | 1.8.5 (65)        | geelong        | 2.10.7 (85)       | bundaberg rum stadium |    7645 | saturday, 21 february, 7:10 pm |
| hawthorn         | 0.4.16 (40)       | brisbane lions | 0.12.5 (77)       | york park             |   12443 | sunday, 22 february, 1:10 pm   |
| sydney           | 2.4.6 (48)        | carlton        | 1.22.9 (150)      | telstra stadium       |    6190 | sunday, 22 february, 3:45 pm   |
| adelaide         | 1.11.5 (80)       | st kilda       | 1.12.12 (93)      | aami stadium          |   13905 | sunday, 22 february, 4:40 pm   |

Question: What is the crowd where the away team scored 1.13.12 (99)?

table_id: 2-16388545-1
label: SELECT "Crowd" FROM "table" WHERE "Away team score" = "1.13.12 (99)"
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 | Tournament                    | Venue                   | Result   | Extra     |
|-------:|:------------------------------|:------------------------|:---------|:----------|
|   1966 | european championships        | budapest , hungary      | 4th      | decathlon |
|   1966 | european junior championships | odessa , soviet union   | 1st      | long jump |
|   1969 | european championships        | athens , greece         | 6th      | long jump |
|   1971 | european championships        | helsinki , finland      | 1st      | long jump |
|   1972 | european indoor championships | grenoble , france       | 1st      | long jump |
|   1972 | olympic games                 | munich , west germany   | 6th      | long jump |
|   1973 | european indoor championships | rotterdam , netherlands | 2nd      | long jump |
|   1974 | european indoor championships | gothenburg , sweden     | 3rd      | long jump |
|   1974 | european championships        | rome , italy            | 7th      | long jump |

Question: What is the extra result associated with 6th place in 1972?

table_id: 2-11484479-1
label: SELECT "Extra" FROM "table" WHERE "Result" = "6th" AND "Year" = 1972
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:
| School                              | Location(s)    | Control                                | Type                               |   Enrollment |   Founded |
|:------------------------------------|:---------------|:---------------------------------------|:-----------------------------------|-------------:|----------:|
| harris-stowe state university       | st. louis      | historically black * public university | baccalaureate college              |         1854 |      1857 |
| lincoln university                  | jefferson city | historically black public university   | master’s colleges and universities |         3109 |      1866 |
| missouri southern state university  | joplin         | public university                      | baccalaureate college              |         5264 |      1937 |
| missouri state university           | springfield    | public university                      | master’s colleges and universities |        18748 |      1905 |
| missouri western state university   | st. joseph     | public university                      | baccalaureate college              |         5508 |      1915 |
| northwest missouri state university | maryville      | public university                      | master’s colleges and universities |         6687 |      1905 |
| southeast missouri state university | cape girardeau | public university                      | master’s colleges and universities |        10738 |      1873 |
| truman state university             | kirksville     | public university                      | master’s colleges and universities |         5880 |      1867 |

Question: Which school would you come across if you were in Kirksville?

table_id: 1-2076463-2
label: SELECT "School" FROM "table" WHERE "Location(s)" = "Kirksville"
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:
| Nation      |   Gold |   Silver |   Bronze |   Total |
|:------------|-------:|---------:|---------:|--------:|
| philippines |      1 |        0 |        1 |       2 |
| malaysia    |      1 |        0 |        1 |       2 |
| indonesia   |      0 |        1 |        0 |       1 |
| thailand    |      0 |        1 |        0 |       1 |
| singapore   |      0 |        0 |        0 |       0 |
| cambodia    |      0 |        0 |        0 |       0 |

Question: Gold of 0, and a Total larger than 0, and a Silver larger than 1 and what is the highest bronze?

table_id: 2-14035046-3
label: SELECT MAX("Bronze") FROM "table" WHERE "Gold" = 0 AND "Total" > 0 AND "Silver" > 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:
| Location                      | Culture   | # found   | Ball diameter   | Period              |
|:------------------------------|:----------|:----------|:----------------|:--------------------|
| el manati                     | olmec     | 5         | 10–14cm         | 1600–1700 bce       |
| el manati                     | olmec     | 2         | 22cm            | 1200 bce            |
| sacred cenote                 | maya      | unknown   | 4cm             | 850 - 1550 ce       |
| main ballcourt, tenochtitlan  | aztec     | 2         | 7cm             | early 16th century? |
| house of eagles, tenochtitlan | aztec     | 4         | 6-8½ cm         | early 16th century? |

Question: What's the Ball Diameter with the Culture of Olmec?

table_id: 2-14789152-2
label: SELECT "Ball diameter" FROM "table" WHERE "Culture" = "olmec"
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:
|   Overall Pick # | AFL Team           | Player           | Position         | College        |
|-----------------:|:-------------------|:-----------------|:-----------------|:---------------|
|                4 | miami dolphins     | bob griese       | quarterback      | purdue         |
|                5 | houston oilers     | george webster 1 | linebacker       | michigan state |
|                6 | denver broncos     | floyd little     | running back     | syracuse       |
|               12 | new york jets      | paul seiler      | offensive guard  | notre dame     |
|               14 | san diego chargers | ron billingsley  | defensive tackle | wyoming        |
|               17 | oakland raiders    | gene upshaw      | offensive guard  | texas a&i      |
|               21 | boston patriots    | john charles     | defensive back   | purdue         |
|               22 | buffalo bills      | george daney     | offensive guard  | arizona state  |
|               23 | houston oilers     | tom regner       | offensive guard  | notre dame     |
|               24 | kansas city chiefs | gene trosch      | defensive tackle | miami (fl)     |

Question: what college has paul seiler as a player?

table_id: 2-12165135-1
label: SELECT "College" FROM "table" WHERE "Player" = "paul seiler"
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  |      8 |        6 |        3 |      17 |
| 2      | bulgaria      |      4 |        2 |        5 |      11 |
| 3      | united states |      3 |        2 |        2 |       7 |
| 4      | romania       |      1 |        2 |        2 |       5 |
| 5      | poland        |      1 |        1 |        0 |       2 |
| 6      | cuba          |      1 |        0 |        1 |       2 |
| 6      | norway        |      1 |        0 |        1 |       2 |
| 8      | north korea   |      1 |        0 |        0 |       1 |
| 9      | hungary       |      0 |        2 |        1 |       3 |
| 9      | mongolia      |      0 |        2 |        1 |       3 |
| 11     | canada        |      0 |        1 |        1 |       2 |
| 11     | east germany  |      0 |        1 |        1 |       2 |
| 13     | iran          |      0 |        1 |        0 |       1 |
| 14     | finland       |      0 |        0 |        1 |       1 |
| 14     | japan         |      0 |        0 |        1 |       1 |
| total  | total         |     20 |       20 |       20 |      60 |

Question: What is the largest gold number when the total is less than 3, the rank is 5, and the silver is more than 1?

table_id: 2-15759604-1
label: SELECT MAX("Gold") FROM "table" WHERE "Total" < 3 AND "Rank" = "5" AND "Silver" > 1