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:
| University                                    | Location   |   Year Founded |   QS World University Rankings 2012 | Times Higher Education World University Rankings 2012-2013   |
|:----------------------------------------------|:-----------|---------------:|------------------------------------:|:-------------------------------------------------------------|
| nanjing university                            | nanjing    |           1902 |                                 168 | 251-275                                                      |
| peking university                             | beijing    |           1898 |                                  44 | 45                                                           |
| shanghai jiao tong university                 | shanghai   |           1896 |                                 125 | 276-300                                                      |
| tsinghua university                           | beijing    |           1911 |                                  48 | 52                                                           |
| university of science and technology of china | hefei      |           1958 |                                 186 | 201-225                                                      |

Question: What university was founded in 1898?

table_id: 1-24697604-1
label: SELECT "University" FROM "table" WHERE "Year Founded" = 1898
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Name       | Pennant   | Builder                   | Laid Down     | Launched         | Commissioned      | Fate                    |
|:-----------|:----------|:--------------------------|:--------------|:-----------------|:------------------|:------------------------|
| chaplet    | r52       | thornycroft , woolston    | 29 april 1943 | 18 july 1944     | 24 august 1945    | sold for scrapping 1965 |
| chequers * | r61       | scotts, greenock          | 4 may 1943    | 30 october 1944  | 28 september 1945 | sold for scrapping 1966 |
| chieftain  | r36       | scotts, greenock          | 27 june 1943  | 26 february 1945 | 7 march 1946      | sold for scrapping 1961 |
| chevron    | r51       | alex. stephen , linthouse | 18 march 1943 | 23 february 1944 | 23 august 1945    | sold for scrapping 1969 |
| cheviot    | r90       | alex. stephen, linthouse  | 27 april 1943 | 2 may 1944       | 11 december 1945  | sold for scrapping 1966 |

Question: What is the builder launched 30 october 1944?

table_id: 1-1206583-2
label: SELECT "Builder" FROM "table" WHERE "Launched" = "30 October 1944"
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 | Rowers                                  | Country   | Time    | Notes   |
|-------:|:----------------------------------------|:----------|:--------|:--------|
|      1 | marcello miani , elia luini             | italy     | 6:16.16 | sa/b    |
|      2 | zhang guolin , sun jie                  | china     | 6:17.62 | sa/b    |
|      3 | samuel beltz , thomas gibson            | australia | 6:19.15 | r       |
|      4 | eyder batista , yunior perez            | cuba      | 6:19.36 | r       |
|      5 | devender kumar khandwal , manjeet singh | india     | 6:37.13 | r       |

Question: What is the lowest rank for the team that raced a time of 6:17.62 and a notes of sa/b?

table_id: 2-18662685-4
label: SELECT MIN("Rank") FROM "table" WHERE "Notes" = "sa/b" AND "Time" = "6:17.62"
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   | Score   | Set 1   | Set 2   | Total   |
|:-------|:--------|:--------|:--------|:--------|
| 3 july | 0–2     | 15:21   | 15:21   | 30:42   |
| 3 july | 0–2     | 15:21   | 19:21   | 34:42   |
| 3 july | 2–1     | 19:21   | 21:19   | 55:53   |
| 3 july | 2–0     | 21:16   | 21:17   | 42:33   |
| 3 july | 0–2     | 12:21   | 14:21   | 26:42   |
| 3 july | 2–0     | 22:20   | 21:16   | 43:36   |
| 3 july | 1–2     | 21:17   | 21:23   | 53:55   |
| 3 july | 2–0     | 21:11   | 21:12   | 42:23   |

Question: What Set 2 has a set one at 19:21?

table_id: 2-18246956-35
label: SELECT "Set 2" FROM "table" WHERE "Set 1" = "19:21"
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:
| Runs   | Wicket   | Batting partners                          | Batting team   | Fielding team   | Venue               | Season   |
|:-------|:---------|:------------------------------------------|:---------------|:----------------|:--------------------|:---------|
| 624    | 3rd      | mahela jayawardene and kumar sangakkara   | sri lanka      | south africa    | colombo             | 2006     |
| 576    | 2nd      | roshan mahanama and sanath jayasuriya     | sri lanka      | india           | colombo             | 1997     |
| 467    | 3rd      | andrew jones and martin crowe             | new zealand    | sri lanka       | wellington          | 1990/91  |
| 451    | 2nd      | donald bradman and w h ponsford           | australia      | england         | sydney              | 1934     |
| 451    | 3rd      | mudassar nazar and javed miandad          | pakistan       | india           | hyderabad, pakistan | 1982/83  |
| 446    | 2nd      | conrad hunte and gary sobers              | west indies    | pakistan        | the oval            | 1957/58  |
| 438    | 2nd      | marvan atapattu and kumar sangakkara      | sri lanka      | zimbabwe        | bulawayo            | 2004     |
| 437    | 4th      | mahela jayawardene and thilan samaraweera | sri lanka      | pakistan        | karachi             | 2008/09  |
| 429*   | 3rd      | jacques rudolph and boeta dippenaar       | south africa   | bangladesh      | chittagong          | 2003     |
| 415    | 1st      | graeme smith and neil mckenzie            | south africa   | bangladesh      | chittagong          | 2008     |

Question: Which batting team had 624 runs?

table_id: 2-1670921-2
label: SELECT "Batting team" FROM "table" WHERE "Runs" = "624"
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 order | Rank                | Name               | Date            | Active service                                     |
|-------------:|:--------------------|:-------------------|:----------------|:---------------------------------------------------|
|           13 | admiral             | david g. farragut  | 25 july 1866    | war of 1812 , mexican war , and american civil war |
|           14 | general of the army | ulysses s. grant   | 25 july 1866    | mexican war and american civil war                 |
|           15 | general of the army | william t. sherman | 4 march 1869    | mexican war , american civil war , and indian wars |
|           16 | admiral             | david d. porter    | 17 october 1870 | mexican war and american civil war                 |
|           17 | general of the army | philip h. sheridan | 1 june 1888     | american civil war and indian wars                 |

Question: What rank does the person participating in American Civil war and indian wars?

table_id: 2-1516389-4
label: SELECT "Rank" FROM "table" WHERE "Active service" = "american civil war and indian wars"
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       | hubert green     | united states | 69-67=136 | –4       |
| 2       | terry diehl      | united states | 69-68=137 | –3       |
| 3       | tom purtzer      | united states | 69-69=138 | –2       |
| t4      | sam adams        | united states | 70-69=139 | –1       |
| t4      | rod funseth      | united states | 69-70=139 | –1       |
| t4      | gary player      | south africa  | 72-67=139 | –1       |
| t7      | jay haas         | united states | 72-68=140 | e        |
| t7      | joe inman        | united states | 70-70=140 | e        |
| t9      | wally armstrong  | united states | 71-70=141 | +1       |
| t9      | andy bean        | united states | 71-70=141 | +1       |
| t9      | al geiberger     | united states | 70-71=141 | +1       |
| t9      | peter oosterhuis | england       | 71-70=141 | +1       |

Question: What was the to par when the score was 69-69=138?

table_id: 2-17245483-4
label: SELECT "To par" FROM "table" WHERE "Score" = "69-69=138"
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:
| W.H. Archer        | J.E. Armstrong   | H.L. Birkett   | F.A. Brill      | H.T. Brewer   |
|:-------------------|:-----------------|:---------------|:----------------|:--------------|
| r. cochrane        | r. crawford      | l.l. davidson  | h.c. doney      | w.c. drummond |
| c.i.m. dryden      | b.h. driver      | f.h. dunner    | b.f. elliott    | w.s. evenden  |
| w.mc. a. calpraith | c.p. greeks      | r.s. greeks    | c. crindrod     | a. hadley     |
| c.m. herzoc        | j.j.c. herzoc    | a.f. hill      | j.l. howie      | h.m. jones    |
| d.m. lawson        | j.r.r. leys      | w.h. mckenzie  | c.e. makeham    | j.c. mill     |
| a.c.h. millar      | a.j. wilson      | r. mollinson   | a. moore        | k.r. murray   |
| r. newman          | w.c. pickering   | c.h. rose      | j.d. rutherford | j.d. shaddick |
| r.a. sinclair      | arthur smith     | alex smith     | e.p. smith      | j. teaze      |

Question: Who is h.t. brewer when je armstrong is c.p. greeks?

table_id: 1-1320857-1
label: SELECT "H.T. Brewer" FROM "table" WHERE "J.E. Armstrong" = "C.P. Greeks"
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 Moondancer's Primary Military Speciality?

table_id: 2-13130124-1
label: SELECT "Primary military speciality" FROM "table" WHERE "Code Name" = "moondancer"
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:
| Character              | Original Berkeley Cast   | Original Broadway Cast   | Original 1st US Tour Cast   | Original UK Cast   | Original Tokyo / Seoul Tour Cast   | Original 3rd US Tour Cast   |
|:-----------------------|:-------------------------|:-------------------------|:----------------------------|:-------------------|:-----------------------------------|:----------------------------|
| johnny                 | john gallagher, jr.      | john gallagher, jr.      | van hughes                  | alex nee           | sean michael murray                | jared nepute                |
| will                   | michael esper            | michael esper            | jake epstein                | casey o'farrell    | casey o'farrell                    | casey o'farrell             |
| tunny                  | matt caplan              | stark sands              | scott j. campbell           | thomas hettrick    | thomas hettrick                    | dan tracy                   |
| whatsername            | rebecca naomi jones      | rebecca naomi jones      | gabrielle mcclinton         | alyssa dipalma     | alyssa dipalma                     | olivia puckett              |
| heather                | mary faber               | mary faber               | leslie mcdonel              | kennedy caughell   | mariah macfarlane                  | mariah macfarlane           |
| the extraordinary girl | christina sajous         | christina sajous         | nicci claspell              | jenna rubaii       | jenna rubaii                       | taylor jones                |

Question: Who was in the original broadway cast while jake epstein was in the original 1st us tour cast? 

table_id: 1-24353141-1
label: SELECT "Original Broadway Cast" FROM "table" WHERE "Original 1st US Tour Cast" = "Jake Epstein"
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   |   Total matches | Total W-L-H   | Singles W-L-H                        |   Points won | Points %   |
|:-------|----------------:|:--------------|:-------------------------------------|-------------:|:-----------|
| career |              46 | 22-18-6       | 5-5-2                                |         25   | 54.35%     |
| 1990   |               3 | 2-1-0         | 1-0-0 def. r. jones 3&2              |          2   | 66.7%      |
| 1992   |               3 | 3-0-0         | 1-0-0 def. b. burton 4&2             |          3   | 100%       |
| 1994   |               3 | 1-2-0         | 0-1-0 lost to b. burton 1 dn         |          1   | 33.3%      |
| 1996   |               5 | 3-2-0         | 0-1-0 lost to m. mcgann 3&2          |          3   | 60%        |
| 1998   |               5 | 3-1-1         | 1-0-0 def. p. hurst 1 up             |          3.5 | 70%        |
| 2000   |               4 | 1-2-1         | 0-1-0 lost to k. robbins 3&2         |          1.5 | 37.5%      |
| 2002   |               5 | 2-3-0         | 0-1-0 lost to m. mallon 3&2          |          2   | 40%        |
| 2003   |               4 | 1-2-1         | 1-0-0 def. m. mallon, conceded on 15 |          1.5 | 37.5%      |
| 2005   |               5 | 3-2-0         | 0-1-0 lost to p. creamer 7&5         |          3   | 60%        |
| 2007   |               4 | 2-1-1         | 1-0-0 def b. lincicome 4&3           |          2.5 | 62.5%      |
| 2009   |               2 | 0-1-1         | 0-0-1 halved with b. lang            |          0.5 | 25%        |
| 2011   |               3 | 1-1-1         | 0-0-1 halved with j. inkster         |          1.5 | 50%        |

Question: Which Total matches is the highest one that has Points % of 70%?

table_id: 2-1524633-6
label: SELECT MAX("Total matches") FROM "table" WHERE "Points %" = "70%"
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       | 17.18 (120)       | richmond        | 7.12 (54)         | mcg                   |   38000 | 1 july 1961 |
| fitzroy         | 9.9 (63)          | st kilda        | 9.8 (62)          | brunswick street oval |   19291 | 1 july 1961 |
| essendon        | 12.11 (83)        | footscray       | 13.14 (92)        | windy hill            |   22440 | 1 july 1961 |
| carlton         | 10.18 (78)        | geelong         | 17.16 (118)       | princes park          |   17936 | 1 july 1961 |
| south melbourne | 9.14 (68)         | north melbourne | 7.8 (50)          | lake oval             |    8750 | 1 july 1961 |
| hawthorn        | 13.12 (90)        | collingwood     | 4.12 (36)         | glenferrie oval       |   31500 | 1 july 1961 |

Question: Where was the game held where the home team scored 17.18 (120)?

table_id: 2-10776330-11
label: SELECT "Venue" FROM "table" WHERE "Home team score" = "17.18 (120)"
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:
| County    | Town/City    | Milepost                | Station                     | Connections                                        |
|:----------|:-------------|:------------------------|:----------------------------|:---------------------------------------------------|
| fairfield | stratford    | 59.0                    | stratford (limited service) | shore line east gbta : 1, 10, 16, 23, coastal link |
| new haven | milford      | waterbury branch splits | waterbury branch splits     | waterbury branch splits                            |
| new haven | derby        | 69.5                    | derby–shelton               | gbta :15, 23 cttransit new haven : f               |
| new haven | ansonia      | 71.1                    | ansonia                     | cttransit new haven : f                            |
| new haven | seymour      | 75                      | seymour                     | cttransit new haven : f                            |
| new haven | beacon falls | 78.5                    | beacon falls                | n/a                                                |
| new haven | naugatuck    | 82.5                    | naugatuck                   | cttransit waterbury : n1                           |

Question: How many towns or cities are at milepost 71.1? 

table_id: 1-2572788-1
label: SELECT COUNT("Town/City") FROM "table" WHERE "Milepost" = "71.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:
|   Season |   Overall |   Slalom | Giant Slalom   | Super G   | Downhill   |
|---------:|----------:|---------:|:---------------|:----------|:-----------|
|     1986 |        51 |       39 | 23             | 19        | —          |
|     1987 |        15 |       24 | 9              | 18        | —          |
|     1988 |         2 |        1 | 1              | 8         | —          |
|     1989 |         3 |        2 | 7              | 7         | —          |
|     1990 |         9 |        2 | 14             | —         | —          |
|     1991 |         2 |        6 | 1              | —         | —          |
|     1992 |         2 |        1 | 1              | 43        | —          |
|     1993 |         5 |        2 | 2              | —         | —          |
|     1994 |         3 |        1 | 11             | —         | —          |
|     1995 |         1 |        1 | 1              | —         | —          |
|     1996 |         5 |        2 | 8              | —         | —          |
|     1997 |        25 |        5 | —              | —         | —          |
|     1998 |        14 |        7 | 13             | —         | —          |

Question: Which Giant Slalom was obtained in the 1997 season?

table_id: 2-1161075-1
label: SELECT "Giant Slalom" FROM "table" WHERE "Season" = 1997
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 |   Gold |   Silver |   Bronze |   Total |
|-------:|-------:|---------:|---------:|--------:|
|      1 |     84 |       69 |       69 |     222 |
|      2 |     36 |       40 |       34 |     110 |
|      3 |     26 |       29 |       31 |      86 |
|      4 |     22 |       17 |       11 |      50 |
|      5 |     12 |       13 |       13 |      38 |
|      6 |     11 |        7 |       11 |      29 |
|      7 |     10 |        4 |        8 |      22 |
|      8 |      7 |       12 |       10 |      29 |
|      9 |      6 |       12 |       13 |      31 |
|     10 |      6 |        5 |        7 |      18 |

Question: What is the average number of gold medals won among participants that won less than 13 silver, less than 8 bronze, and more than 18 medals overall?

table_id: 2-178745-3
label: SELECT AVG("Gold") FROM "table" WHERE "Silver" < 13 AND "Total" > 18 AND "Bronze" < 8
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Class to 1928   | Class from 1928   | Seats   |   Quantity | Year(s) of Manufacture   |
|:----------------|:------------------|:--------|-----------:|:-------------------------|
| di-26           | cid-26            | 66      |         77 | 1927/28                  |
| di-27           | cid-27; ciu-27/28 | 66      |        440 | 1927/28                  |
| bci-28          | bci-28            | 15/34   |        449 | 1928/29                  |
| ci-28           | ci-28             | 58      |       1744 | 1928/29                  |
| cdi-28          | ccid-28; cciu-28  | 29/29   |         40 | 1928                     |
| bi-29           | bi-29             | 38      |       1632 | 1929/30                  |
| bci-29          | bci-29            | 15/34   |        500 | 1929/30                  |
| ci-29           | ci-29             | 58      |        450 | 1929/30                  |
| ci-30           | ci-30             | 58      |        194 | 1929/30                  |

Question: What Class to 1928 has the Quantity smaller than 440 and Seats of 29/29?

table_id: 2-18734371-3
label: SELECT "Class to 1928" FROM "table" WHERE "Quantity" < 440 AND "Seats" = "29/29"
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       | greg norman    | australia     |      63 | –9       |
| 2       | phil mickelson | united states |      65 | –7       |
| t3      | scott hoch     | united states |      67 | –5       |
| t3      | bob tway       | united states |      67 | –5       |
| 5       | lee janzen     | united states |      68 | –4       |
| t6      | nick faldo     | england       |      69 | –3       |
| t6      | brad faxon     | united states |      69 | –3       |
| t6      | david gilford  | england       |      69 | –3       |
| t6      | scott simpson  | united states |      69 | –3       |
| t6      | vijay singh    | fiji          |      69 | –3       |

Question: What's the sum of all phil mickelson's game scores?

table_id: 2-16514480-1
label: SELECT SUM("Score") FROM "table" WHERE "Player" = "phil mickelson"
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      | russia     |     86 |       57 |       31 |     174 |
| 2      | turkey     |     39 |       40 |       41 |     120 |
| 3      | ukraine    |     21 |       23 |       12 |      56 |
| 4      | greece     |     15 |       23 |       51 |      89 |
| 5      | romania    |     10 |       15 |       29 |      54 |
| 6      | azerbaijan |      9 |        7 |       11 |      27 |
| 7      | georgia    |      6 |        8 |       20 |      34 |
| 8      | moldova    |      0 |        3 |       15 |      18 |
| 9      | armenia    |      0 |        2 |       12 |      14 |
| 10     | bulgaria   |      0 |        2 |        3 |       5 |
| 11     | albania    |      0 |        2 |        1 |       3 |
| total  | total      |    186 |      182 |      224 |     592 |

Question: How many Bronzes have a Rank of 9, and a Silver larger than 2?

table_id: 2-18901519-1
label: SELECT SUM("Bronze") FROM "table" WHERE "Rank" = "9" AND "Silver" > 2