MMTU-benchmark/MMTU huggingface dataset:
Task: semantic-join (source dataset: DataXFormer)

You are given two input tables below. Your task is to identify the most likely semantic relationships between values of these two columns, and then output pairs of values from Table 1 and Table 2, that can be joined/linked based on the inferred semantic relationships. 

No explanation is needed, only return your answer in JSON format: {"output": <answer>}, where the <answer> is a list of lists. Each inner list should contain exactly one value from Table 1, and its semantically matching value from Table 2. If a value from Table 1 does not have corresponding value from Table 2, you can omit it in the answer. But be careful, not to miss any values from Table 1 that do have corresponding matching values in Table 2.

Input Table 1:
| Col_0    |
|:---------|
| 1/1/15   |
| 4/1/15   |
| 6/1/15   |
| 12/1/15  |
| 12/8/15  |
| 5/8/15   |
| 8/8/15   |
| 8/8/15   |
| 4/20/13  |
| 11/20/11 |

Input Table 2:
| Col_1      |
|:-----------|
| 03/10/1436 |
| 06/11/1436 |
| 08/13/1436 |
| 02/18/1437 |
| 02/25/1437 |
| 07/19/1436 |
| 10/22/1436 |
| 10/01/1434 |
| 06/09/1434 |
| 12/23/1432 |

Joined Table:



label: 1/1/15
03/10/1436
4/1/15
06/11/1436
6/1/15
08/13/1436
12/1/15
02/18/1437
12/8/15
02/25/1437
5/8/15
07/19/1436
8/8/15
10/22/1436
8/8/15
10/01/1434
4/20/13
06/09/1434
11/20/11
12/23/1432
Task: semantic-join (source dataset: DataXFormer)

You are given two input tables below. Your task is to identify the most likely semantic relationships between values of these two columns, and then output pairs of values from Table 1 and Table 2, that can be joined/linked based on the inferred semantic relationships. 

No explanation is needed, only return your answer in JSON format: {"output": <answer>}, where the <answer> is a list of lists. Each inner list should contain exactly one value from Table 1, and its semantically matching value from Table 2. If a value from Table 1 does not have corresponding value from Table 2, you can omit it in the answer. But be careful, not to miss any values from Table 1 that do have corresponding matching values in Table 2.

Input Table 1:
| Col_0             |
|:------------------|
| 128.31.34.154     |
| 130.0.75.55       |
| 155.56.47.116     |
| 129.42.38.1       |
| 137.254.120.50    |
| 66.220.158.68     |
| 978-1-118-12938-8 |
| 140.205.248.2     |
| 162.13.40.196     |
| 191.239.213.197   |

Input Table 2:
| Col_1         |
|:--------------|
| csail.mit.edu |
| signavio.de   |
| Sap.com       |
| ibm.com       |
| oracle.com    |
| facebook.com  |
| alibaba.cn    |
| dubsmash.com  |
| nokia.com     |
| microsoft.com |

Joined Table:



label: 128.31.34.154
csail.mit.edu
130.0.75.55
signavio.de
155.56.47.116
Sap.com
129.42.38.1
ibm.com
137.254.120.50
oracle.com
66.220.158.68
facebook.com
978-1-118-12938-8
alibaba.cn
140.205.248.2
dubsmash.com
162.13.40.196
nokia.com
191.239.213.197
microsoft.com
Task: semantic-join (source dataset: DataXFormer)

You are given two input tables below. Your task is to identify the most likely semantic relationships between values of these two columns, and then output pairs of values from Table 1 and Table 2, that can be joined/linked based on the inferred semantic relationships. 

No explanation is needed, only return your answer in JSON format: {"output": <answer>}, where the <answer> is a list of lists. Each inner list should contain exactly one value from Table 1, and its semantically matching value from Table 2. If a value from Table 1 does not have corresponding value from Table 2, you can omit it in the answer. But be careful, not to miss any values from Table 1 that do have corresponding matching values in Table 2.

Input Table 1:
| Col_0     |
|:----------|
| 1066-8888 |
| 0824-3298 |
| 1806-2636 |
| 2326-5744 |
| 0893-6080 |
| 0976-2280 |
| 1350-1917 |
| 0362-5915 |
| 0036-8075 |
| 2320-2890 |

Input Table 2:
| Col_1                                              |
|:---------------------------------------------------|
| The VLDB Journal                                   |
| Man and Nature                                     |
| Acta Scientiarum Animal Sciences                   |
| Advances in Chemical Science                       |
| Neural Networks                                    |
| International journal of Web & Semantic Technology |
| Information Systems Journal                        |
| TODS                                               |
| Science Magazine                                   |
| Biomedical Journal                                 |

Joined Table:



label: 1066-8888
The VLDB Journal
0824-3298
Man and Nature
1806-2636
Acta Scientiarum Animal Sciences
2326-5744
Advances in Chemical Science
0893-6080
Neural Networks
0976-2280
International journal of Web & Semantic Technology
1350-1917
Information Systems Journal
0362-5915
TODS
0036-8075
Science Magazine
2320-2890
Biomedical Journal
Task: semantic-join (source dataset: DataXFormer)

You are given two input tables below. Your task is to identify the most likely semantic relationships between values of these two columns, and then output pairs of values from Table 1 and Table 2, that can be joined/linked based on the inferred semantic relationships. 

No explanation is needed, only return your answer in JSON format: {"output": <answer>}, where the <answer> is a list of lists. Each inner list should contain exactly one value from Table 1, and its semantically matching value from Table 2. If a value from Table 1 does not have corresponding value from Table 2, you can omit it in the answer. But be careful, not to miss any values from Table 1 that do have corresponding matching values in Table 2.

Input Table 1:
| Col_0       |
|:------------|
| Rotterdam   |
| Marseille   |
| Toronto     |
| Istanbul    |
| Aarhus      |
| Munich      |
| Barcelona   |
| Alexandria  |
| Los Angeles |
| Krakow      |
| Graz        |
| Osaka       |
| Reykjavik   |
| Florence    |
| Milan       |
| Geneva      |
| Vienna      |
| Toulouse    |
| Sofia       |
| Athens      |

Input Table 2:
| Col_1         |
|:--------------|
| Netherlands   |
| France        |
| Canada        |
| Turkey        |
| Denmark       |
| Germany       |
| Spain         |
| Egypt         |
| United States |
| Poland        |
| Austria       |
| Japan         |
| Iceland       |
| Italy         |
| Italy         |
| Switzerland   |
| Austria       |
| France        |
| Bulgaria      |
| Greece        |

Joined Table:



label: Rotterdam
Netherlands
Marseille
France
Toronto
Canada
Istanbul
Turkey
Aarhus
Denmark
Munich
Germany
Barcelona
Spain
Alexandria
Egypt
Los Angeles
United States
Krakow
Poland
Graz
Austria
Osaka
Japan
Reykjavik
Iceland
Florence
Italy
Milan
Italy
Geneva
Switzerland
Vienna
Austria
Toulouse
France
Sofia
Bulgaria
Athens
Greece
Task: semantic-join (source dataset: DataXFormer)

You are given two input tables below. Your task is to identify the most likely semantic relationships between values of these two columns, and then output pairs of values from Table 1 and Table 2, that can be joined/linked based on the inferred semantic relationships. 

No explanation is needed, only return your answer in JSON format: {"output": <answer>}, where the <answer> is a list of lists. Each inner list should contain exactly one value from Table 1, and its semantically matching value from Table 2. If a value from Table 1 does not have corresponding value from Table 2, you can omit it in the answer. But be careful, not to miss any values from Table 1 that do have corresponding matching values in Table 2.

Input Table 1:
| Col_0   |
|:--------|
| Neymar  |
| Neymar  |
| Messi   |
| Ronaldo |
| Ronaldo |
| Neuer   |
| Neuer   |
| Pirlo   |
| Pirlo   |
| Pirlo   |

Input Table 2:
| Col_1             |
|:------------------|
| FC Barcelona      |
| Santos            |
| FC BArcelona      |
| Manchester United |
| Real Madrid       |
| Bayern Munich     |
| Schalke 04        |
| Juventus          |
| Milan             |
| Brescia           |

Joined Table:



label: Neymar
FC Barcelona
Neymar
Santos
Messi
FC BArcelona
Ronaldo
Manchester United
Ronaldo
Real Madrid
Neuer
Bayern Munich
Neuer
Schalke 04
Pirlo
Juventus
Pirlo
Milan
Pirlo
Brescia
Task: semantic-join (source dataset: DataXFormer)

You are given two input tables below. Your task is to identify the most likely semantic relationships between values of these two columns, and then output pairs of values from Table 1 and Table 2, that can be joined/linked based on the inferred semantic relationships. 

No explanation is needed, only return your answer in JSON format: {"output": <answer>}, where the <answer> is a list of lists. Each inner list should contain exactly one value from Table 1, and its semantically matching value from Table 2. If a value from Table 1 does not have corresponding value from Table 2, you can omit it in the answer. But be careful, not to miss any values from Table 1 that do have corresponding matching values in Table 2.

Input Table 1:
| Col_0      |
|:-----------|
| Actinium   |
| Aluminum   |
| Americium  |
| Antimony   |
| Argon      |
| Arsenic    |
| Astatine   |
| Barium     |
| Beryllium  |
| Bismuth    |
| Boron      |
| Bromine    |
| Cadmium    |
| Calcium    |
| Carbon     |
| Cerium     |
| Cesium     |
| Chlorine   |
| Chromium   |
| Cobalt     |
| Copper     |
| Dysprosium |
| Erbium     |
| Europium   |
| Fluorine   |
| Francium   |
| Gadolinium |
| Gallium    |
| Germanium  |
| Gold       |
| Hafnium    |
| Helium     |
| Holmium    |
| Hydrogen   |
| Indium     |
| Iodine     |
| Iridium    |
| Iron       |
| Krypton    |
| Lanthanum  |

Input Table 2:
|   Col_1 |
|--------:|
|    3200 |
|    2467 |
|    2607 |
|    1750 |
|    -186 |
|     613 |
|     337 |
|    1140 |
|    2970 |
|    1560 |
|    2550 |
|      59 |
|     765 |
|    1484 |
|    4827 |
|    3257 |
|     678 |
|     -35 |
|    2672 |
|    2870 |
|    2567 |
|    2562 |
|    2510 |
|    1597 |
|    -188 |
|     677 |
|    3233 |
|    2403 |
|    2830 |
|    2807 |
|    5400 |
|    -269 |
|    2720 |
|    -253 |
|    2000 |
|     184 |
|    4527 |
|    2750 |
|    -153 |
|    3469 |

Joined Table:



label: Actinium
3200
Aluminum
2467
Americium
2607
Antimony
1750
Argon
-186
Arsenic
613
Astatine
337
Barium
1140
Beryllium
2970
Bismuth
1560
Boron
2550
Bromine
59
Cadmium
765
Calcium
1484
Carbon
4827
Cerium
3257
Cesium
678
Chlorine
-35
Chromium
2672
Cobalt
2870
Copper
2567
Dysprosium
2562
Erbium
2510
Europium
1597
Fluorine
-188
Francium
677
Gadolinium
3233
Gallium
2403
Germanium
2830
Gold
2807
Hafnium
5400
Helium
-269
Holmium
2720
Hydrogen
-253
Indium
2000
Iodine
184
Iridium
4527
Iron
2750
Krypton
-153
Lanthanum
3469
Task: semantic-join (source dataset: DataXFormer)

You are given two input tables below. Your task is to identify the most likely semantic relationships between values of these two columns, and then output pairs of values from Table 1 and Table 2, that can be joined/linked based on the inferred semantic relationships. 

No explanation is needed, only return your answer in JSON format: {"output": <answer>}, where the <answer> is a list of lists. Each inner list should contain exactly one value from Table 1, and its semantically matching value from Table 2. If a value from Table 1 does not have corresponding value from Table 2, you can omit it in the answer. But be careful, not to miss any values from Table 1 that do have corresponding matching values in Table 2.

Input Table 1:
| Col_0           |
|:----------------|
| Oracle          |
| IBM             |
| Microsoft       |
| GM              |
| GE              |
| Bank of America |
| Staples         |
| Starbucks       |
| Nokia           |
| Dell            |

Input Table 2:
| Col_1               |
|:--------------------|
| IT Software         |
| IT Hardware         |
| IT Software         |
| Automobile          |
| Electricity         |
| Finance             |
| office supply chain |
| Coffee shop         |
| Telecommunications  |
| IT Services         |

Joined Table:



label: Oracle
IT Software
IBM
IT Hardware
Microsoft
IT Software
GM
Automobile
GE
Electricity
Bank of America
Finance
Staples
office supply chain
Starbucks
Coffee shop
Nokia
Telecommunications
Dell
IT Services
Task: semantic-join (source dataset: DataXFormer)

You are given two input tables below. Your task is to identify the most likely semantic relationships between values of these two columns, and then output pairs of values from Table 1 and Table 2, that can be joined/linked based on the inferred semantic relationships. 

No explanation is needed, only return your answer in JSON format: {"output": <answer>}, where the <answer> is a list of lists. Each inner list should contain exactly one value from Table 1, and its semantically matching value from Table 2. If a value from Table 1 does not have corresponding value from Table 2, you can omit it in the answer. But be careful, not to miss any values from Table 1 that do have corresponding matching values in Table 2.

Input Table 1:
| Col_0                       |
|:----------------------------|
| Platoon                     |
| American Beauty             |
| Rocky IV                    |
| The Blues Brothers          |
| Memento                     |
| Up in the Air               |
| Four weedings and a funeral |
| Alien: Resurrection         |
| Pulp Fiction                |
| Fight Club                  |
| American History X          |

Input Table 2:
|   Col_1 |
|--------:|
|    1986 |
|    1999 |
|    1985 |
|    1980 |
|    2000 |
|    2009 |
|    1994 |
|    1997 |
|    1994 |
|    1999 |
|    1998 |

Joined Table:



label: Platoon
1986
American Beauty
1999
Rocky IV
1985
The Blues Brothers
1980
Memento
2000
Up in the Air
2009
Four weedings and a funeral
1994
Alien: Resurrection
1997
Pulp Fiction
1994
Fight Club
1999
American History X
1998
Task: semantic-join (source dataset: DataXFormer)

You are given two input tables below. Your task is to identify the most likely semantic relationships between values of these two columns, and then output pairs of values from Table 1 and Table 2, that can be joined/linked based on the inferred semantic relationships. 

No explanation is needed, only return your answer in JSON format: {"output": <answer>}, where the <answer> is a list of lists. Each inner list should contain exactly one value from Table 1, and its semantically matching value from Table 2. If a value from Table 1 does not have corresponding value from Table 2, you can omit it in the answer. But be careful, not to miss any values from Table 1 that do have corresponding matching values in Table 2.

Input Table 1:
| Col_0             |
|:------------------|
| 0-553-10354-7     |
| 1501260049        |
| 0-688-03036-X     |
| 978-0374275631    |
| 033036426X        |
| 9.78055E+12       |
| 978-1-118-12938-8 |
| 978-3-642-29575-1 |
| 978-0451476807    |
| 978-0312427986    |

Input Table 2:
| Col_1                                                   |
|:--------------------------------------------------------|
| George R. R. Martin                                     |
| CLAYTON M. CHRISTENSEN                                  |
| John Irving                                             |
| Daniel Kehlmann                                         |
| Markus Zusak                                            |
| David A. Vise and Mark Malseed                          |
| Abraham Silberschatz and Peter B. Galvin and Greg Gagne |
| Hasso Plattner and Alexander Zeier                      |
| Ken Follet                                              |
| Mario Vargas Llosa                                      |

Joined Table:



label: 0-553-10354-7
George R. R. Martin
1501260049
CLAYTON M. CHRISTENSEN
0-688-03036-X
John Irving
978-0374275631
Daniel Kehlmann
033036426X
Markus Zusak
9.78055E+12
David A. Vise and Mark Malseed
978-1-118-12938-8
Abraham Silberschatz and Peter B. Galvin and Greg Gagne
978-3-642-29575-1
Hasso Plattner and Alexander Zeier
978-0451476807
Ken Follet
978-0312427986
Mario Vargas Llosa
Task: semantic-join (source dataset: DataXFormer)

You are given two input tables below. Your task is to identify the most likely semantic relationships between values of these two columns, and then output pairs of values from Table 1 and Table 2, that can be joined/linked based on the inferred semantic relationships. 

No explanation is needed, only return your answer in JSON format: {"output": <answer>}, where the <answer> is a list of lists. Each inner list should contain exactly one value from Table 1, and its semantically matching value from Table 2. If a value from Table 1 does not have corresponding value from Table 2, you can omit it in the answer. But be careful, not to miss any values from Table 1 that do have corresponding matching values in Table 2.

Input Table 1:
| Col_0   |
|:--------|
| #ffb6c1 |
| #333333 |
| #d52b1e |
| #306860 |
| #045ca2 |
| #fed100 |
| #000000 |
| #999999 |
| #123456 |
| #000fff |

Input Table 2:
| Col_1       |
|:------------|
| (255182193) |
| (515151)    |
| (2134330)   |
| (4810496)   |
| (492162)    |
| (2542090)   |
| (000)       |
| (153153153) |
| (185286)    |
| (015255)    |

Joined Table:



label: #ffb6c1
(255182193)
#333333
(515151)
#d52b1e
(2134330)
#306860
(4810496)
#045ca2
(492162)
#fed100
(2542090)
#000000
(000)
#999999
(153153153)
#123456
(185286)
#000fff
(015255)
Task: semantic-join (source dataset: DataXFormer)

You are given two input tables below. Your task is to identify the most likely semantic relationships between values of these two columns, and then output pairs of values from Table 1 and Table 2, that can be joined/linked based on the inferred semantic relationships. 

No explanation is needed, only return your answer in JSON format: {"output": <answer>}, where the <answer> is a list of lists. Each inner list should contain exactly one value from Table 1, and its semantically matching value from Table 2. If a value from Table 1 does not have corresponding value from Table 2, you can omit it in the answer. But be careful, not to miss any values from Table 1 that do have corresponding matching values in Table 2.

Input Table 1:
| Col_0                  |
|:-----------------------|
| Golden State Warriors  |
| Boston Celtics         |
| San Antonio Spurs      |
| Los Angeles Lakers     |
| Utah Jazz              |
| Los Angeles Clippers   |
| Memphis Grizzlies      |
| Miami Heat             |
| Toronto Raptors        |
| Dallas Mavericks       |
| Houston Rockets        |
| Chicago Bulls          |
| Cleveland Cavaliers    |
| Orlando Magic          |
| Detroit Pistons        |
| Milwaukee Bucks        |
| Charlotte Bobcats      |
| Sacramento Kings       |
| Minnesota Timberwolves |

Input Table 2:
| Col_1           |
|:----------------|
| Mark Jackson    |
| Doc Rivers      |
| Gregg Popovich  |
| Mike DˈAntoni   |
| Tyrone Corbin   |
| Vinny Del Negro |
| Lionel Hollins  |
| Erik Spoelstra  |
| Dwane Casey     |
| Rick Carlisle   |
| Kevin McHale    |
| Tom Thibodeau   |
| Byron Scott     |
| Jacque Vaughn   |
| Lawrence Frank  |
| Jim Boylan      |
| Mike Dunlap     |
| Keith Smart     |
| Rick Adelman    |

Joined Table:



label: Golden State Warriors
Mark Jackson
Boston Celtics
Doc Rivers
San Antonio Spurs
Gregg Popovich
Los Angeles Lakers
Mike DˈAntoni
Utah Jazz
Tyrone Corbin
Los Angeles Clippers
Vinny Del Negro
Memphis Grizzlies
Lionel Hollins
Miami Heat
Erik Spoelstra
Toronto Raptors
Dwane Casey
Dallas Mavericks
Rick Carlisle
Houston Rockets
Kevin McHale
Chicago Bulls
Tom Thibodeau
Cleveland Cavaliers
Byron Scott
Orlando Magic
Jacque Vaughn
Detroit Pistons
Lawrence Frank
Milwaukee Bucks
Jim Boylan
Charlotte Bobcats
Mike Dunlap
Sacramento Kings
Keith Smart
Minnesota Timberwolves
Rick Adelman
Task: semantic-join (source dataset: DataXFormer)

You are given two input tables below. Your task is to identify the most likely semantic relationships between values of these two columns, and then output pairs of values from Table 1 and Table 2, that can be joined/linked based on the inferred semantic relationships. 

No explanation is needed, only return your answer in JSON format: {"output": <answer>}, where the <answer> is a list of lists. Each inner list should contain exactly one value from Table 1, and its semantically matching value from Table 2. If a value from Table 1 does not have corresponding value from Table 2, you can omit it in the answer. But be careful, not to miss any values from Table 1 that do have corresponding matching values in Table 2.

Input Table 1:
| Col_0      |
|:-----------|
| feet       |
| pound      |
| fahrenheit |
| ounces     |
| inch       |
| acre       |
| gallon     |
| barrel     |
| pint       |

Input Table 2:
| Col_1      |
|:-----------|
| meter      |
| kilo gram  |
| celcius    |
| gram       |
| centimeter |
| hectar     |
| liter      |
| liter      |
| liter      |

Joined Table:



label: feet
meter
pound
kilo gram
fahrenheit
celcius
ounces
gram
inch
centimeter
acre
hectar
gallon
liter
barrel
liter
pint
liter
Task: semantic-join (source dataset: DataXFormer)

You are given two input tables below. Your task is to identify the most likely semantic relationships between values of these two columns, and then output pairs of values from Table 1 and Table 2, that can be joined/linked based on the inferred semantic relationships. 

No explanation is needed, only return your answer in JSON format: {"output": <answer>}, where the <answer> is a list of lists. Each inner list should contain exactly one value from Table 1, and its semantically matching value from Table 2. If a value from Table 1 does not have corresponding value from Table 2, you can omit it in the answer. But be careful, not to miss any values from Table 1 that do have corresponding matching values in Table 2.

Input Table 1:
| Col_0   |
|:--------|
| U+0041  |
| U+0042  |
| U+0043  |
| U+0044  |
| U+0054  |
| U+0055  |
| U+0056  |
| U+0057  |
| U+0058  |
| U+0059  |
| U+005A  |

Input Table 2:
|   Col_1 |
|--------:|
|      65 |
|      66 |
|      67 |
|      68 |
|      84 |
|      85 |
|      86 |
|      87 |
|      88 |
|      89 |
|      90 |

Joined Table:



label: U+0041
65
U+0042
66
U+0043
67
U+0044
68
U+0054
84
U+0055
85
U+0056
86
U+0057
87
U+0058
88
U+0059
89
U+005A
90
Task: semantic-join (source dataset: DataXFormer)

You are given two input tables below. Your task is to identify the most likely semantic relationships between values of these two columns, and then output pairs of values from Table 1 and Table 2, that can be joined/linked based on the inferred semantic relationships. 

No explanation is needed, only return your answer in JSON format: {"output": <answer>}, where the <answer> is a list of lists. Each inner list should contain exactly one value from Table 1, and its semantically matching value from Table 2. If a value from Table 1 does not have corresponding value from Table 2, you can omit it in the answer. But be careful, not to miss any values from Table 1 that do have corresponding matching values in Table 2.

Input Table 1:
| Col_0        |
|:-------------|
| 23135106     |
| 02079K305    |
| 459200101    |
| 60505104     |
| 369604103    |
| 37045V100    |
| 20030N101    |
| ARDEUT116183 |
| 594918104    |
| 803054204    |

Input Table 2:
| Col_1                           |
|:--------------------------------|
| Amazon.com Inc.                 |
| Google Inc                      |
| International Business Machines |
| Bank of America Corporation     |
| General Electric Company        |
| General Motors Company          |
| Comcast Corporation             |
| Apple Inc                       |
| Microsoft Corporation           |
| SAP AG O.N.                     |

Joined Table:



label: 23135106
Amazon.com Inc.
02079K305
Google Inc
459200101
International Business Machines
60505104
Bank of America Corporation
369604103
General Electric Company
37045V100
General Motors Company
20030N101
Comcast Corporation
ARDEUT116183
Apple Inc
594918104
Microsoft Corporation
803054204
SAP AG O.N.
Task: semantic-join (source dataset: DataXFormer)

You are given two input tables below. Your task is to identify the most likely semantic relationships between values of these two columns, and then output pairs of values from Table 1 and Table 2, that can be joined/linked based on the inferred semantic relationships. 

No explanation is needed, only return your answer in JSON format: {"output": <answer>}, where the <answer> is a list of lists. Each inner list should contain exactly one value from Table 1, and its semantically matching value from Table 2. If a value from Table 1 does not have corresponding value from Table 2, you can omit it in the answer. But be careful, not to miss any values from Table 1 that do have corresponding matching values in Table 2.

Input Table 1:
| Col_0   |
|:--------|
| Hello   |
| science |
| Country |
| City    |
| Bank    |
| Work    |
| Book    |
| Shoes   |
| Ear     |
| Pencile |

Input Table 2:
| Col_1        |
|:-------------|
| Hallo        |
| Wissenschaft |
| Land         |
| Stadt        |
| Bank         |
| Arbeit       |
| Buch         |
| Schuhe       |
| Ohr          |
| Bleistift    |

Joined Table:



label: Hello
Hallo
science
Wissenschaft
Country
Land
City
Stadt
Bank
Bank
Work
Arbeit
Book
Buch
Shoes
Schuhe
Ear
Ohr
Pencile
Bleistift
Task: semantic-join (source dataset: DataXFormer)

You are given two input tables below. Your task is to identify the most likely semantic relationships between values of these two columns, and then output pairs of values from Table 1 and Table 2, that can be joined/linked based on the inferred semantic relationships. 

No explanation is needed, only return your answer in JSON format: {"output": <answer>}, where the <answer> is a list of lists. Each inner list should contain exactly one value from Table 1, and its semantically matching value from Table 2. If a value from Table 1 does not have corresponding value from Table 2, you can omit it in the answer. But be careful, not to miss any values from Table 1 that do have corresponding matching values in Table 2.

Input Table 1:
| Col_0             |
|:------------------|
| 0-553-10354-7     |
| 1501260049        |
| 0-688-03036-X     |
| 978-0374275631    |
| 033036426X        |
| 9.78055E+12       |
| 978-1-118-12938-8 |
| 978-3-642-29575-1 |
| 978-0451476807    |
| 978-0312427986    |

Input Table 2:
| Col_1                         |
|:------------------------------|
| Bantam Spectra                |
| Harvard Business Review Press |
| William Morrow                |
| Farrar Straus and Giroux      |
| Knopf                         |
| Dell publishing               |
| Wiley                         |
| Springer                      |
| Signet                        |
| Picador                       |

Joined Table:



label: 0-553-10354-7
Bantam Spectra
1501260049
Harvard Business Review Press
0-688-03036-X
William Morrow
978-0374275631
Farrar Straus and Giroux
033036426X
Knopf
9.78055E+12
Dell publishing
978-1-118-12938-8
Wiley
978-3-642-29575-1
Springer
978-0451476807
Signet
978-0312427986
Picador
Task: semantic-join (source dataset: DataXFormer)

You are given two input tables below. Your task is to identify the most likely semantic relationships between values of these two columns, and then output pairs of values from Table 1 and Table 2, that can be joined/linked based on the inferred semantic relationships. 

No explanation is needed, only return your answer in JSON format: {"output": <answer>}, where the <answer> is a list of lists. Each inner list should contain exactly one value from Table 1, and its semantically matching value from Table 2. If a value from Table 1 does not have corresponding value from Table 2, you can omit it in the answer. But be careful, not to miss any values from Table 1 that do have corresponding matching values in Table 2.

Input Table 1:
| Col_0       |
|:------------|
| 84;84;84    |
| 211;211;211 |
| 255;255;255 |
| 138;43;226  |
| 173;216;230 |
| 240;255;255 |
| 0;255;255   |
| 165;42;42   |
| 47;79;47    |
| 255;165;0   |

Input Table 2:
| Col_1      |
|:-----------|
| Grey       |
| LightGrey  |
| White      |
| BlueViolet |
| LightBlue  |
| Azure      |
| Cyan       |
| Brown      |
| Dark Green |
| Orange     |

Joined Table:



label: 84;84;84
Grey
211;211;211
LightGrey
255;255;255
White
138;43;226
BlueViolet
173;216;230
LightBlue
240;255;255
Azure
0;255;255
Cyan
165;42;42
Brown
47;79;47
Dark Green
255;165;0
Orange
Task: semantic-join (source dataset: DataXFormer)

You are given two input tables below. Your task is to identify the most likely semantic relationships between values of these two columns, and then output pairs of values from Table 1 and Table 2, that can be joined/linked based on the inferred semantic relationships. 

No explanation is needed, only return your answer in JSON format: {"output": <answer>}, where the <answer> is a list of lists. Each inner list should contain exactly one value from Table 1, and its semantically matching value from Table 2. If a value from Table 1 does not have corresponding value from Table 2, you can omit it in the answer. But be careful, not to miss any values from Table 1 that do have corresponding matching values in Table 2.

Input Table 1:
| Col_0   |
|:--------|
| D321987 |
| D320987 |
| D299342 |
| D323980 |
| D320900 |
| D320090 |
| D300090 |
| D300155 |
| RE35311 |
| RE35114 |

Input Table 2:
| Col_1                                                             |
|:------------------------------------------------------------------|
| Handleless Toothbrush                                             |
| Telephone set                                                     |
| Handset transceiver and telephone dialer stand with display panel |
| Dual compartment bottle                                           |
| Bathroom etagere                                                  |
| Decorative moulding                                               |
| Rocker                                                            |
| Toy can opener                                                    |
| Data dependency collapsing hardware apparatus                     |
| Fluid flow meter                                                  |

Joined Table:



label: D321987
Handleless Toothbrush
D320987
Telephone set
D299342
Handset transceiver and telephone dialer stand with display panel
D323980
Dual compartment bottle
D320900
Bathroom etagere
D320090
Decorative moulding
D300090
Rocker
D300155
Toy can opener
RE35311
Data dependency collapsing hardware apparatus
RE35114
Fluid flow meter
Task: semantic-join (source dataset: DataXFormer)

You are given two input tables below. Your task is to identify the most likely semantic relationships between values of these two columns, and then output pairs of values from Table 1 and Table 2, that can be joined/linked based on the inferred semantic relationships. 

No explanation is needed, only return your answer in JSON format: {"output": <answer>}, where the <answer> is a list of lists. Each inner list should contain exactly one value from Table 1, and its semantically matching value from Table 2. If a value from Table 1 does not have corresponding value from Table 2, you can omit it in the answer. But be careful, not to miss any values from Table 1 that do have corresponding matching values in Table 2.

Input Table 1:
| Col_0                  |
|:-----------------------|
| Golden State Warriors  |
| Boston Celtics         |
| San Antonio Spurs      |
| Los Angeles Lakers     |
| Memphis Grizzlies      |
| Dallas Mavericks       |
| Houston Rockets        |
| Chicago Bulls          |
| Detroit Pistons        |
| Sacramento Kings       |
| Minnesota Timberwolves |

Input Table 2:
| Col_1         |
|:--------------|
| Bob Myers     |
| Danny Ainge   |
| R.C. Buford   |
| Mitch Kupchak |
| Chris Wallace |
| Donnie Nelson |
| Daryl Morey   |
| Gar Forman    |
| Joe Dumars    |
| Geoff Petrie  |
| David Kahn    |

Joined Table:



label: Golden State Warriors
Bob Myers
Boston Celtics
Danny Ainge
San Antonio Spurs
R.C. Buford
Los Angeles Lakers
Mitch Kupchak
Memphis Grizzlies
Chris Wallace
Dallas Mavericks
Donnie Nelson
Houston Rockets
Daryl Morey
Chicago Bulls
Gar Forman
Detroit Pistons
Joe Dumars
Sacramento Kings
Geoff Petrie
Minnesota Timberwolves
David Kahn
Task: semantic-join (source dataset: DataXFormer)

You are given two input tables below. Your task is to identify the most likely semantic relationships between values of these two columns, and then output pairs of values from Table 1 and Table 2, that can be joined/linked based on the inferred semantic relationships. 

No explanation is needed, only return your answer in JSON format: {"output": <answer>}, where the <answer> is a list of lists. Each inner list should contain exactly one value from Table 1, and its semantically matching value from Table 2. If a value from Table 1 does not have corresponding value from Table 2, you can omit it in the answer. But be careful, not to miss any values from Table 1 that do have corresponding matching values in Table 2.

Input Table 1:
| Col_0     |
|:----------|
| Germany   |
| Germany   |
| Germany   |
| France    |
| Brazil    |
| Brazil    |
| Italy     |
| Brazil    |
| Uruguay   |
| Brazil    |
| Argentina |
| Italy     |
| Brazil    |
| Italy     |
| Italy     |
| Spain     |
| England   |

Input Table 2:
|   Col_1 |
|--------:|
|    1954 |
|    1974 |
|    1990 |
|    1998 |
|    2002 |
|    1994 |
|    2006 |
|    1958 |
|    1950 |
|    1962 |
|    1986 |
|    1982 |
|    1970 |
|    1938 |
|    1934 |
|    2010 |
|    1966 |

Joined Table:



label: Germany
1954
Germany
1974
Germany
1990
France
1998
Brazil
2002
Brazil
1994
Italy
2006
Brazil
1958
Uruguay
1950
Brazil
1962
Argentina
1986
Italy
1982
Brazil
1970
Italy
1938
Italy
1934
Spain
2010
England
1966
Task: NL2SQL (source dataset: Spider)

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.

Database:
pilot_1

Tables:

Table: PilotSkills
| pilot_name   | plane_name   |   age |
|:-------------|:-------------|------:|
| Celko        | Piper Cub    |    23 |
| Higgins      | B-52 Bomber  |    34 |
| Higgins      | F-14 Fighter |    50 |
| Higgins      | Piper Cub    |    30 |
| Jones        | B-52 Bomber  |    24 |
| Jones        | F-14 Fighter |    32 |
| Smith        | B-1 Bomber   |    41 |
| Smith        | B-52 Bomber  |    26 |
| Smith        | F-14 Fighter |    45 |
| Wilson       | B-1 Bomber   |    52 |


Table: Hangar
| plane_name   | location   |
|:-------------|:-----------|
| B-1 Bomber   | Chicago    |
| B-52 Bomber  | Austin     |
| F-14 Fighter | Boston     |
| Piper Cub    | Seattle    |


Question: How many different places have some plane?

db_id: pilot_1
tables: name: PilotSkills
data: PilotSkills.csv
name: Hangar
data: Hangar.csv
label: SELECT count(DISTINCT LOCATION) FROM hangar
sqlite_path: $MMTU_HOME/data_sqlite/spider/spider_data/test_database/pilot_1/pilot_1.sqlite
Task: NL2SQL (source dataset: Spider)

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.

Database:
boat_1

Tables:

Table: Sailors
|   sid | name   |   rating |   age |
|------:|:-------|---------:|------:|
|     1 | Eugene |        7 |    22 |
|     2 | Luis   |        2 |    39 |
|     3 | Ken    |        8 |    27 |


Table: Boats
|   bid | name   | color   |
|------:|:-------|:--------|
|   101 | Legacy | red     |
|   102 | Melon  | blue    |
|   103 | Mars   | red     |


Table: Reserves
|   sid |   bid | day   |
|------:|------:|:------|
|     1 |   102 | 9/12  |
|     2 |   102 | 9/13  |
|     2 |   103 | 9/14  |
|     2 |   103 | 9/15  |


Question: What is id about sailors who do not have boat reservations?

db_id: boat_1
tables: name: Sailors
data: Sailors.csv
name: Boats
data: Boats.csv
name: Reserves
data: Reserves.csv
label: SELECT sid FROM Sailors EXCEPT SELECT T1.sid FROM Sailors AS T1 JOIN Reserves AS T2 ON T1.sid  =  T2.sid
sqlite_path: $MMTU_HOME/data_sqlite/spider/spider_data/test_database/boat_1/boat_1.sqlite
Task: NL2SQL (source dataset: Spider)

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.

Database:
warehouse_1

Tables:

Table: Warehouses
|   Code | Location      |   Capacity |
|-------:|:--------------|-----------:|
|      1 | Chicago       |          3 |
|      2 | Chicago       |          4 |
|      3 | New York      |          7 |
|      4 | Los Angeles   |          2 |
|      5 | San Francisco |          8 |


Table: Boxes
| Code   | Contents   |   Value |   Warehouse |
|:-------|:-----------|--------:|------------:|
| 0MN7   | Rocks      |     180 |           3 |
| 4H8P   | Rocks      |     250 |           1 |
| 4RT3   | Scissors   |     190 |           4 |
| 7G3H   | Rocks      |     200 |           1 |
| 8JN6   | Papers     |      75 |           1 |
| 8Y6U   | Papers     |      50 |           3 |
| 9J6F   | Papers     |     175 |           2 |
| LL08   | Rocks      |     140 |           4 |
| P0H6   | Scissors   |     125 |           1 |
| P2T6   | Scissors   |     150 |           2 |


Question: Select the average value of all the boxes.

db_id: warehouse_1
tables: name: Warehouses
data: Warehouses.csv
name: Boxes
data: Boxes.csv
label: SELECT avg(value) FROM boxes
sqlite_path: $MMTU_HOME/data_sqlite/spider/spider_data/test_database/warehouse_1/warehouse_1.sqlite
Task: NL2SQL (source dataset: Spider)

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.

Database:
warehouse_1

Tables:

Table: Warehouses
|   Code | Location      |   Capacity |
|-------:|:--------------|-----------:|
|      1 | Chicago       |          3 |
|      2 | Chicago       |          4 |
|      3 | New York      |          7 |
|      4 | Los Angeles   |          2 |
|      5 | San Francisco |          8 |


Table: Boxes
| Code   | Contents   |   Value |   Warehouse |
|:-------|:-----------|--------:|------------:|
| 0MN7   | Rocks      |     180 |           3 |
| 4H8P   | Rocks      |     250 |           1 |
| 4RT3   | Scissors   |     190 |           4 |
| 7G3H   | Rocks      |     200 |           1 |
| 8JN6   | Papers     |      75 |           1 |
| 8Y6U   | Papers     |      50 |           3 |
| 9J6F   | Papers     |     175 |           2 |
| LL08   | Rocks      |     140 |           4 |
| P0H6   | Scissors   |     125 |           1 |
| P2T6   | Scissors   |     150 |           2 |


Question: Find all different contents stored in New York.

db_id: warehouse_1
tables: name: Warehouses
data: Warehouses.csv
name: Boxes
data: Boxes.csv
label: SELECT DISTINCT T1.contents FROM boxes AS T1 JOIN warehouses AS T2 ON T1.warehouse  =  T2.code WHERE LOCATION  =  'New York'
sqlite_path: $MMTU_HOME/data_sqlite/spider/spider_data/test_database/warehouse_1/warehouse_1.sqlite
Task: NL2SQL (source dataset: Spider)

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.

Database:
warehouse_1

Tables:

Table: Warehouses
|   Code | Location      |   Capacity |
|-------:|:--------------|-----------:|
|      1 | Chicago       |          3 |
|      2 | Chicago       |          4 |
|      3 | New York      |          7 |
|      4 | Los Angeles   |          2 |
|      5 | San Francisco |          8 |


Table: Boxes
| Code   | Contents   |   Value |   Warehouse |
|:-------|:-----------|--------:|------------:|
| 0MN7   | Rocks      |     180 |           3 |
| 4H8P   | Rocks      |     250 |           1 |
| 4RT3   | Scissors   |     190 |           4 |
| 7G3H   | Rocks      |     200 |           1 |
| 8JN6   | Papers     |      75 |           1 |
| 8Y6U   | Papers     |      50 |           3 |
| 9J6F   | Papers     |     175 |           2 |
| LL08   | Rocks      |     140 |           4 |
| P0H6   | Scissors   |     125 |           1 |
| P2T6   | Scissors   |     150 |           2 |


Question: Find the total, average, and maximum capacity for different locations.

db_id: warehouse_1
tables: name: Warehouses
data: Warehouses.csv
name: Boxes
data: Boxes.csv
label: SELECT sum(capacity) ,  avg(capacity) ,  max(capacity) ,  LOCATION FROM warehouses GROUP BY LOCATION
sqlite_path: $MMTU_HOME/data_sqlite/spider/spider_data/test_database/warehouse_1/warehouse_1.sqlite
Task: NL2SQL (source dataset: Spider)

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.

Database:
boat_1

Tables:

Table: Sailors
|   sid | name   |   rating |   age |
|------:|:-------|---------:|------:|
|     1 | Eugene |        7 |    22 |
|     2 | Luis   |        2 |    39 |
|     3 | Ken    |        8 |    27 |


Table: Boats
|   bid | name   | color   |
|------:|:-------|:--------|
|   101 | Legacy | red     |
|   102 | Melon  | blue    |
|   103 | Mars   | red     |


Table: Reserves
|   sid |   bid | day   |
|------:|------:|:------|
|     1 |   102 | 9/12  |
|     2 |   102 | 9/13  |
|     2 |   103 | 9/14  |
|     2 |   103 | 9/15  |


Question: Find the name, rating and age of all sailors ordered by rating and age.

db_id: boat_1
tables: name: Sailors
data: Sailors.csv
name: Boats
data: Boats.csv
name: Reserves
data: Reserves.csv
label: SELECT name ,  rating ,  age FROM Sailors ORDER BY rating ,  age
sqlite_path: $MMTU_HOME/data_sqlite/spider/spider_data/test_database/boat_1/boat_1.sqlite