Files @ r28396:ef195b601c72
Branch filter:

Location: cpp/openttd-patchpack/source/src/tunnelbridge_cmd.cpp - annotation

Peter Nelson
Fix: Pass townnameparts as parameter when testing townname based companyname. (#11685)

Length of returned string could vary and pass/fail the length check with a different
string than the final selection.
   1
   2
   3
   4
   5
   6
   7
   8
   9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63
  64
  65
  66
  67
  68
  69
  70
  71
  72
  73
  74
  75
  76
  77
  78
  79
  80
  81
  82
  83
  84
  85
  86
  87
  88
  89
  90
  91
  92
  93
  94
  95
  96
  97
  98
  99
 100
 101
 102
 103
 104
 105
 106
 107
 108
 109
 110
 111
 112
 113
 114
 115
 116
 117
 118
 119
 120
 121
 122
 123
 124
 125
 126
 127
 128
 129
 130
 131
 132
 133
 134
 135
 136
 137
 138
 139
 140
 141
 142
 143
 144
 145
 146
 147
 148
 149
 150
 151
 152
 153
 154
 155
 156
 157
 158
 159
 160
 161
 162
 163
 164
 165
 166
 167
 168
 169
 170
 171
 172
 173
 174
 175
 176
 177
 178
 179
 180
 181
 182
 183
 184
 185
 186
 187
 188
 189
 190
 191
 192
 193
 194
 195
 196
 197
 198
 199
 200
 201
 202
 203
 204
 205
 206
 207
 208
 209
 210
 211
 212
 213
 214
 215
 216
 217
 218
 219
 220
 221
 222
 223
 224
 225
 226
 227
 228
 229
 230
 231
 232
 233
 234
 235
 236
 237
 238
 239
 240
 241
 242
 243
 244
 245
 246
 247
 248
 249
 250
 251
 252
 253
 254
 255
 256
 257
 258
 259
 260
 261
 262
 263
 264
 265
 266
 267
 268
 269
 270
 271
 272
 273
 274
 275
 276
 277
 278
 279
 280
 281
 282
 283
 284
 285
 286
 287
 288
 289
 290
 291
 292
 293
 294
 295
 296
 297
 298
 299
 300
 301
 302
 303
 304
 305
 306
 307
 308
 309
 310
 311
 312
 313
 314
 315
 316
 317
 318
 319
 320
 321
 322
 323
 324
 325
 326
 327
 328
 329
 330
 331
 332
 333
 334
 335
 336
 337
 338
 339
 340
 341
 342
 343
 344
 345
 346
 347
 348
 349
 350
 351
 352
 353
 354
 355
 356
 357
 358
 359
 360
 361
 362
 363
 364
 365
 366
 367
 368
 369
 370
 371
 372
 373
 374
 375
 376
 377
 378
 379
 380
 381
 382
 383
 384
 385
 386
 387
 388
 389
 390
 391
 392
 393
 394
 395
 396
 397
 398
 399
 400
 401
 402
 403
 404
 405
 406
 407
 408
 409
 410
 411
 412
 413
 414
 415
 416
 417
 418
 419
 420
 421
 422
 423
 424
 425
 426
 427
 428
 429
 430
 431
 432
 433
 434
 435
 436
 437
 438
 439
 440
 441
 442
 443
 444
 445
 446
 447
 448
 449
 450
 451
 452
 453
 454
 455
 456
 457
 458
 459
 460
 461
 462
 463
 464
 465
 466
 467
 468
 469
 470
 471
 472
 473
 474
 475
 476
 477
 478
 479
 480
 481
 482
 483
 484
 485
 486
 487
 488
 489
 490
 491
 492
 493
 494
 495
 496
 497
 498
 499
 500
 501
 502
 503
 504
 505
 506
 507
 508
 509
 510
 511
 512
 513
 514
 515
 516
 517
 518
 519
 520
 521
 522
 523
 524
 525
 526
 527
 528
 529
 530
 531
 532
 533
 534
 535
 536
 537
 538
 539
 540
 541
 542
 543
 544
 545
 546
 547
 548
 549
 550
 551
 552
 553
 554
 555
 556
 557
 558
 559
 560
 561
 562
 563
 564
 565
 566
 567
 568
 569
 570
 571
 572
 573
 574
 575
 576
 577
 578
 579
 580
 581
 582
 583
 584
 585
 586
 587
 588
 589
 590
 591
 592
 593
 594
 595
 596
 597
 598
 599
 600
 601
 602
 603
 604
 605
 606
 607
 608
 609
 610
 611
 612
 613
 614
 615
 616
 617
 618
 619
 620
 621
 622
 623
 624
 625
 626
 627
 628
 629
 630
 631
 632
 633
 634
 635
 636
 637
 638
 639
 640
 641
 642
 643
 644
 645
 646
 647
 648
 649
 650
 651
 652
 653
 654
 655
 656
 657
 658
 659
 660
 661
 662
 663
 664
 665
 666
 667
 668
 669
 670
 671
 672
 673
 674
 675
 676
 677
 678
 679
 680
 681
 682
 683
 684
 685
 686
 687
 688
 689
 690
 691
 692
 693
 694
 695
 696
 697
 698
 699
 700
 701
 702
 703
 704
 705
 706
 707
 708
 709
 710
 711
 712
 713
 714
 715
 716
 717
 718
 719
 720
 721
 722
 723
 724
 725
 726
 727
 728
 729
 730
 731
 732
 733
 734
 735
 736
 737
 738
 739
 740
 741
 742
 743
 744
 745
 746
 747
 748
 749
 750
 751
 752
 753
 754
 755
 756
 757
 758
 759
 760
 761
 762
 763
 764
 765
 766
 767
 768
 769
 770
 771
 772
 773
 774
 775
 776
 777
 778
 779
 780
 781
 782
 783
 784
 785
 786
 787
 788
 789
 790
 791
 792
 793
 794
 795
 796
 797
 798
 799
 800
 801
 802
 803
 804
 805
 806
 807
 808
 809
 810
 811
 812
 813
 814
 815
 816
 817
 818
 819
 820
 821
 822
 823
 824
 825
 826
 827
 828
 829
 830
 831
 832
 833
 834
 835
 836
 837
 838
 839
 840
 841
 842
 843
 844
 845
 846
 847
 848
 849
 850
 851
 852
 853
 854
 855
 856
 857
 858
 859
 860
 861
 862
 863
 864
 865
 866
 867
 868
 869
 870
 871
 872
 873
 874
 875
 876
 877
 878
 879
 880
 881
 882
 883
 884
 885
 886
 887
 888
 889
 890
 891
 892
 893
 894
 895
 896
 897
 898
 899
 900
 901
 902
 903
 904
 905
 906
 907
 908
 909
 910
 911
 912
 913
 914
 915
 916
 917
 918
 919
 920
 921
 922
 923
 924
 925
 926
 927
 928
 929
 930
 931
 932
 933
 934
 935
 936
 937
 938
 939
 940
 941
 942
 943
 944
 945
 946
 947
 948
 949
 950
 951
 952
 953
 954
 955
 956
 957
 958
 959
 960
 961
 962
 963
 964
 965
 966
 967
 968
 969
 970
 971
 972
 973
 974
 975
 976
 977
 978
 979
 980
 981
 982
 983
 984
 985
 986
 987
 988
 989
 990
 991
 992
 993
 994
 995
 996
 997
 998
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r15610:623a23fb6560
r15610:623a23fb6560
r5584:545d748cc681
r19944:25a78576fb5e
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r15940:064272152529
r8224:194097dc7288
r8116:df67d3c5e4fd
r5584:545d748cc681
r5584:545d748cc681
r11971:ac7eb21a00e4
r11979:a450390d0f16
r13840:e35c72858ba2
r5584:545d748cc681
r7582:dfefb1216e6f
r8083:8cd2123a0c7c
r8114:866ed489ed98
r27148:4e041ae27b9d
r17269:69ce9f105ed6
r8144:1432edd15267
r8157:cf41aa22cd09
r8398:cf5cc32ab397
r10960:e97ebf9cf99b
r9154:6e22da499a7e
r13828:41995609971a
r14248:a9050881acd7
r14477:752d803ed3be
r23698:1872cc5b7dd7
r16551:27c24a326035
r16997:e322f047824d
r18556:3a067cfd3824
r23760:58e1a032cdaf
r26094:7572e88decb3
r26102:502baaa2877d
r26102:502baaa2877d
r5584:545d748cc681
r8264:d493cb51fe8a
r8264:d493cb51fe8a
r5584:545d748cc681
r21383:942c32fb8b0e
r21383:942c32fb8b0e
r17624:f2c5f47dceaa
r17624:f2c5f47dceaa
r5584:545d748cc681
r17624:f2c5f47dceaa
r16232:444131f10b0a
r16232:444131f10b0a
r22001:0d97ce3496a8
r22001:0d97ce3496a8
r22001:0d97ce3496a8
r22001:0d97ce3496a8
r22001:0d97ce3496a8
r22001:0d97ce3496a8
r22001:0d97ce3496a8
r22001:0d97ce3496a8
r22001:0d97ce3496a8
r22001:0d97ce3496a8
r22001:0d97ce3496a8
r22001:0d97ce3496a8
r22001:0d97ce3496a8
r22001:0d97ce3496a8
r22001:0d97ce3496a8
r22001:0d97ce3496a8
r22001:0d97ce3496a8
r22001:0d97ce3496a8
r22001:0d97ce3496a8
r22001:0d97ce3496a8
r22001:0d97ce3496a8
r22001:0d97ce3496a8
r22001:0d97ce3496a8
r22001:0d97ce3496a8
r22001:0d97ce3496a8
r22001:0d97ce3496a8
r22001:0d97ce3496a8
r8489:4eb5a193cb87
r8489:4eb5a193cb87
r8489:4eb5a193cb87
r8489:4eb5a193cb87
r8532:0c31796f7b70
r23607:36c15679007d
r9642:0489dee9f080
r8489:4eb5a193cb87
r8489:4eb5a193cb87
r8489:4eb5a193cb87
r8489:4eb5a193cb87
r19944:25a78576fb5e
r8489:4eb5a193cb87
r8489:4eb5a193cb87
r8489:4eb5a193cb87
r8489:4eb5a193cb87
r5584:545d748cc681
r15610:623a23fb6560
r15610:623a23fb6560
r14876:c971c4b731c8
r14876:c971c4b731c8
r14876:c971c4b731c8
r6422:5983361e241a
r14878:df7e7e7ce347
r5584:545d748cc681
r14879:b11a63506b3b
r5584:545d748cc681
r14878:df7e7e7ce347
r14879:b11a63506b3b
r14879:b11a63506b3b
r14879:b11a63506b3b
r14879:b11a63506b3b
r14879:b11a63506b3b
r14879:b11a63506b3b
r14879:b11a63506b3b
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r17632:92f095eb81a2
r17632:92f095eb81a2
r17632:92f095eb81a2
r19944:25a78576fb5e
r19944:25a78576fb5e
r17632:92f095eb81a2
r8371:32791d4d82d0
r8371:32791d4d82d0
r14877:8260fce9fd4a
r14877:8260fce9fd4a
r14877:8260fce9fd4a
r8371:32791d4d82d0
r8371:32791d4d82d0
r8371:32791d4d82d0
r5584:545d748cc681
r8379:853fb668feea
r8379:853fb668feea
r8379:853fb668feea
r8379:853fb668feea
r8379:853fb668feea
r8379:853fb668feea
r8379:853fb668feea
r8379:853fb668feea
r8379:853fb668feea
r18252:2cba8d2d1409
r8379:853fb668feea
r8379:853fb668feea
r8379:853fb668feea
r8379:853fb668feea
r9642:0489dee9f080
r5584:545d748cc681
r8535:947bf8a72211
r9642:0489dee9f080
r23607:36c15679007d
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8371:32791d4d82d0
r23028:0602ed02c6b4
r8371:32791d4d82d0
r23028:0602ed02c6b4
r8371:32791d4d82d0
r8371:32791d4d82d0
r8371:32791d4d82d0
r8371:32791d4d82d0
r5584:545d748cc681
r23028:0602ed02c6b4
r5584:545d748cc681
r23028:0602ed02c6b4
r23028:0602ed02c6b4
r8371:32791d4d82d0
r18251:23e77d038c74
r5584:545d748cc681
r23028:0602ed02c6b4
r23028:0602ed02c6b4
r23028:0602ed02c6b4
r23028:0602ed02c6b4
r23028:0602ed02c6b4
r23028:0602ed02c6b4
r8371:32791d4d82d0
r5584:545d748cc681
r8371:32791d4d82d0
r8371:32791d4d82d0
r13748:140a77305928
r5584:545d748cc681
r5584:545d748cc681
r15610:623a23fb6560
r15610:623a23fb6560
r14942:db3a0ed92d44
r14942:db3a0ed92d44
r23023:7b8669afd1db
r14944:29599fab3827
r14942:db3a0ed92d44
r14944:29599fab3827
r5584:545d748cc681
r9578:dc0f6aac5573
r17210:893afe086e22
r14944:29599fab3827
r9578:dc0f6aac5573
r5584:545d748cc681
r14944:29599fab3827
r9578:dc0f6aac5573
r9578:dc0f6aac5573
r27148:4e041ae27b9d
r5584:545d748cc681
r24597:afde5721a3b6
r5584:545d748cc681
r14944:29599fab3827
r14944:29599fab3827
r14944:29599fab3827
r5584:545d748cc681
r5584:545d748cc681
r15610:623a23fb6560
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r24602:d0d308decaa4
r15610:623a23fb6560
r26095:00c14d52e378
r26114:91e053fa2e46
r26114:91e053fa2e46
r26114:91e053fa2e46
r26114:91e053fa2e46
r26114:91e053fa2e46
r13057:58af81fcdcf8
r5584:545d748cc681
r26114:91e053fa2e46
r5584:545d748cc681
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r8530:f024ec651ac7
r23698:1872cc5b7dd7
r5584:545d748cc681
r26114:91e053fa2e46
r5584:545d748cc681
r6422:5983361e241a
r8530:f024ec651ac7
r8530:f024ec651ac7
r26114:91e053fa2e46
r23698:1872cc5b7dd7
r8530:f024ec651ac7
r8530:f024ec651ac7
r8530:f024ec651ac7
r26114:91e053fa2e46
r27896:3f48fccebe5f
r8530:f024ec651ac7
r8531:c49e85243dd4
r9490:5cf190d39c21
r9490:5cf190d39c21
r9490:5cf190d39c21
r8531:c49e85243dd4
r12547:ebc9352127c6
r8531:c49e85243dd4
r5584:545d748cc681
r12547:ebc9352127c6
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r23607:36c15679007d
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r12547:ebc9352127c6
r12622:202e83a6cee7
r12547:ebc9352127c6
r5584:545d748cc681
r12547:ebc9352127c6
r12547:ebc9352127c6
r5584:545d748cc681
r12547:ebc9352127c6
r5584:545d748cc681
r5584:545d748cc681
r11725:57bc99fdc1bc
r5584:545d748cc681
r5584:545d748cc681
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r9490:5cf190d39c21
r9490:5cf190d39c21
r14944:29599fab3827
r14944:29599fab3827
r13868:ac8f3ac859fe
r17210:893afe086e22
r9490:5cf190d39c21
r24601:dbb2ed121b40
r5584:545d748cc681
r18260:9616113792ef
r18260:9616113792ef
r18251:23e77d038c74
r18251:23e77d038c74
r14784:4ff091d20873
r5584:545d748cc681
r23028:0602ed02c6b4
r23028:0602ed02c6b4
r5584:545d748cc681
r16725:b9041c857d37
r16725:b9041c857d37
r12622:202e83a6cee7
r5584:545d748cc681
r14880:4a8d29bc60a7
r14880:4a8d29bc60a7
r20231:ee3fa97a7874
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r5930:fccc06495c0e
r5930:fccc06495c0e
r8083:8cd2123a0c7c
r5930:fccc06495c0e
r5930:fccc06495c0e
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r5930:fccc06495c0e
r5930:fccc06495c0e
r11725:57bc99fdc1bc
r5930:fccc06495c0e
r5584:545d748cc681
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r19939:167f99380426
r5930:fccc06495c0e
r19939:167f99380426
r19939:167f99380426
r5930:fccc06495c0e
r5584:545d748cc681
r23607:36c15679007d
r5930:fccc06495c0e
r5930:fccc06495c0e
r5930:fccc06495c0e
r11725:57bc99fdc1bc
r5930:fccc06495c0e
r5930:fccc06495c0e
r5930:fccc06495c0e
r5930:fccc06495c0e
r23698:1872cc5b7dd7
r11725:57bc99fdc1bc
r5930:fccc06495c0e
r5584:545d748cc681
r10207:a1fc2f2a33db
r20227:0f07e05b4228
r11725:57bc99fdc1bc
r5930:fccc06495c0e
r5584:545d748cc681
r24602:d0d308decaa4
r24602:d0d308decaa4
r12547:ebc9352127c6
r6708:8f38bbf425fc
r20227:0f07e05b4228
r20231:ee3fa97a7874
r20231:ee3fa97a7874
r5930:fccc06495c0e
r5930:fccc06495c0e
r5930:fccc06495c0e
r10696:8dfe83e30d01
r8371:32791d4d82d0
r5930:fccc06495c0e
r26118:2b515956558b
r14304:dc9cb5b9e881
r5930:fccc06495c0e
r5584:545d748cc681
r15542:f6c6d0f8689e
r8371:32791d4d82d0
r5584:545d748cc681
r5930:fccc06495c0e
r26118:2b515956558b
r14304:dc9cb5b9e881
r6950:1a54b1afb12a
r5930:fccc06495c0e
r6422:5983361e241a
r15542:f6c6d0f8689e
r8371:32791d4d82d0
r9491:1270a6ceeef0
r13086:71e929261037
r12547:ebc9352127c6
r21736:0da55aa599c8
r21736:0da55aa599c8
r5584:545d748cc681
r21736:0da55aa599c8
r5584:545d748cc681
r21736:0da55aa599c8
r21736:0da55aa599c8
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r18251:23e77d038c74
r12547:ebc9352127c6
r21739:3fa33d6e1d74
r21739:3fa33d6e1d74
r21739:3fa33d6e1d74
r21739:3fa33d6e1d74
r21739:3fa33d6e1d74
r21739:3fa33d6e1d74
r21739:3fa33d6e1d74
r21739:3fa33d6e1d74
r21739:3fa33d6e1d74
r21739:3fa33d6e1d74
r21736:0da55aa599c8
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r18251:23e77d038c74
r12547:ebc9352127c6
r12547:ebc9352127c6
r15734:ae8e2e185874
r15734:ae8e2e185874
r15665:8a1a5d5b328a
r18251:23e77d038c74
r12547:ebc9352127c6
r15665:8a1a5d5b328a
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r26118:2b515956558b
r14304:dc9cb5b9e881
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r12548:5e7f6e787227
r12548:5e7f6e787227
r19944:25a78576fb5e
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r12547:ebc9352127c6
r18771:b0bbffcb9160
r20231:ee3fa97a7874
r5584:545d748cc681
r5584:545d748cc681
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r22140:9217592fa081
r8530:f024ec651ac7
r8530:f024ec651ac7
r20231:ee3fa97a7874
r24601:dbb2ed121b40
r8625:a49c9c70551a
r8530:f024ec651ac7
r14784:4ff091d20873
r14784:4ff091d20873
r8530:f024ec651ac7
r8530:f024ec651ac7
r19956:cb96060ee88f
r20231:ee3fa97a7874
r20231:ee3fa97a7874
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r20231:ee3fa97a7874
r23607:36c15679007d
r18557:96a9c31d64d1
r23698:1872cc5b7dd7
r18557:96a9c31d64d1
r24601:dbb2ed121b40
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r24601:dbb2ed121b40
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r8530:f024ec651ac7
r19956:cb96060ee88f
r8531:c49e85243dd4
r9490:5cf190d39c21
r24601:dbb2ed121b40
r9490:5cf190d39c21
r9490:5cf190d39c21
r23760:58e1a032cdaf
r23760:58e1a032cdaf
r9490:5cf190d39c21
r9490:5cf190d39c21
r8531:c49e85243dd4
r8531:c49e85243dd4
r5584:545d748cc681
r12548:5e7f6e787227
r12548:5e7f6e787227
r22001:0d97ce3496a8
r22140:9217592fa081
r5584:545d748cc681
r5584:545d748cc681
r12077:baf868e4baf0
r5584:545d748cc681
r18771:b0bbffcb9160
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r24021:4da23ee44be4
r24021:4da23ee44be4
r24021:4da23ee44be4
r24021:4da23ee44be4
r18771:b0bbffcb9160
r24021:4da23ee44be4
r15236:52b8c9d62ef9
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r15236:52b8c9d62ef9
r15236:52b8c9d62ef9
r15236:52b8c9d62ef9
r15236:52b8c9d62ef9
r23607:36c15679007d
r5584:545d748cc681
r15081:ec58df7b6b94
r27737:728d55b97775
r15081:ec58df7b6b94
r15081:ec58df7b6b94
r27737:728d55b97775
r15081:ec58df7b6b94
r9492:2708969ab966
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r15610:623a23fb6560
r15610:623a23fb6560
r26095:00c14d52e378
r6484:7a9ab9f50ee4
r26114:91e053fa2e46
r26114:91e053fa2e46
r13057:58af81fcdcf8
r5584:545d748cc681
r26114:91e053fa2e46
r5584:545d748cc681
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r15012:f19fe03ea1c7
r23698:1872cc5b7dd7
r5584:545d748cc681
r15012:f19fe03ea1c7
r15012:f19fe03ea1c7
r26114:91e053fa2e46
r27896:3f48fccebe5f
r15012:f19fe03ea1c7
r15012:f19fe03ea1c7
r15012:f19fe03ea1c7
r26114:91e053fa2e46
r23698:1872cc5b7dd7
r15012:f19fe03ea1c7
r15012:f19fe03ea1c7
r15012:f19fe03ea1c7
r6661:a60bd28b4b57
r5584:545d748cc681
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r23607:36c15679007d
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r18260:9616113792ef
r18260:9616113792ef
r18252:2cba8d2d1409
r12547:ebc9352127c6
r11725:57bc99fdc1bc
r5584:545d748cc681
r16553:97a5aaaa977f
r8385:b9b4b8b2f2cc
r26118:2b515956558b
r14304:dc9cb5b9e881
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6950:1a54b1afb12a
r12547:ebc9352127c6
r7002:201ff6832d3a
r9224:0340c9af9930
r26787:a51c38e4aac5
r7002:201ff6832d3a
r26787:a51c38e4aac5
r7002:201ff6832d3a
r7002:201ff6832d3a
r12547:ebc9352127c6
r7095:b0eeea62f548
r19944:25a78576fb5e
r7095:b0eeea62f548
r12547:ebc9352127c6
r7095:b0eeea62f548
r12547:ebc9352127c6
r7308:700f8e251c2f
r7095:b0eeea62f548
r14880:4a8d29bc60a7
r12547:ebc9352127c6
r5584:545d748cc681
r5584:545d748cc681
r12622:202e83a6cee7
r18252:2cba8d2d1409
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r7002:201ff6832d3a
r11725:57bc99fdc1bc
r5584:545d748cc681
r5584:545d748cc681
r7095:b0eeea62f548
r7308:700f8e251c2f
r7308:700f8e251c2f
r7308:700f8e251c2f
r7308:700f8e251c2f
r7095:b0eeea62f548
r13476:add6db25d711
r7095:b0eeea62f548
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r13476:add6db25d711
r6950:1a54b1afb12a
r5584:545d748cc681
r6422:5983361e241a
r5584:545d748cc681
r5584:545d748cc681
r17210:893afe086e22
r17210:893afe086e22
r16553:97a5aaaa977f
r8385:b9b4b8b2f2cc
r16551:27c24a326035
r26118:2b515956558b
r16551:27c24a326035
r16551:27c24a326035
r16551:27c24a326035
r6422:5983361e241a
r5584:545d748cc681
r16551:27c24a326035
r16551:27c24a326035
r16551:27c24a326035
r23607:36c15679007d
r24434:1f13cf59de8a
r16551:27c24a326035
r16551:27c24a326035
r16551:27c24a326035
r16551:27c24a326035
r16551:27c24a326035
r22965:045fb638e860
r22965:045fb638e860
r22965:045fb638e860
r24534:7bcc54d7060f
r22965:045fb638e860
r22965:045fb638e860
r22965:045fb638e860
r22965:045fb638e860
r22965:045fb638e860
r22965:045fb638e860
r23536:ce42deb0b32d
r23536:ce42deb0b32d
r23536:ce42deb0b32d
r23103:dab285bdadbc
r23607:36c15679007d
r22965:045fb638e860
r26127:abb88237711d
r23103:dab285bdadbc
r14304:dc9cb5b9e881
r16551:27c24a326035
r5584:545d748cc681
r13476:add6db25d711
r5584:545d748cc681
r15236:52b8c9d62ef9
r15236:52b8c9d62ef9
r23698:1872cc5b7dd7
r15236:52b8c9d62ef9
r20998:c047af70b5bc
r15236:52b8c9d62ef9
r15236:52b8c9d62ef9
r5584:545d748cc681
r18771:b0bbffcb9160
r18556:3a067cfd3824
r8549:868ae7c78793
r23698:1872cc5b7dd7
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r9224:0340c9af9930
r5584:545d748cc681
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r5584:545d748cc681
r18771:b0bbffcb9160
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r15610:623a23fb6560
r15610:623a23fb6560
r14804:e5dbb4dc2a7e
r14804:e5dbb4dc2a7e
r14804:e5dbb4dc2a7e
r14804:e5dbb4dc2a7e
r5584:545d748cc681
r5584:545d748cc681
r14804:e5dbb4dc2a7e
r11247:c15ef8b37f5e
r11312:92ed0077d87f
r11312:92ed0077d87f
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r11312:92ed0077d87f
r11312:92ed0077d87f
r11312:92ed0077d87f
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r11247:c15ef8b37f5e
r11312:92ed0077d87f
r20164:ffdfd45e472c
r20164:ffdfd45e472c
r14888:176181db43bf
r14774:6075f6397e6f
r11328:69f316e17367
r11312:92ed0077d87f
r11312:92ed0077d87f
r14805:8c416234ced2
r14805:8c416234ced2
r14805:8c416234ced2
r11312:92ed0077d87f
r11247:c15ef8b37f5e
r11312:92ed0077d87f
r14888:176181db43bf
r11247:c15ef8b37f5e
r18002:c61bc6e40723
r18002:c61bc6e40723
r18002:c61bc6e40723
r18002:c61bc6e40723
r18002:c61bc6e40723
r18002:c61bc6e40723
r18002:c61bc6e40723
r11312:92ed0077d87f
r11312:92ed0077d87f
r5584:545d748cc681
r5584:545d748cc681
r15610:623a23fb6560
r15610:623a23fb6560
r14876:c971c4b731c8
r14876:c971c4b731c8
r14876:c971c4b731c8
r14876:c971c4b731c8
r11090:9276cea703d4
r5584:545d748cc681
r14804:e5dbb4dc2a7e
r14804:e5dbb4dc2a7e
r5584:545d748cc681
r14880:4a8d29bc60a7
r8072:7ee1932b46d8
r14804:e5dbb4dc2a7e
r14697:0b5e0f20b510
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r23607:36c15679007d
r5584:545d748cc681
r10236:993bcc06ffa8
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r26829:f1ebd010c392
r14800:3e915e992538
r5584:545d748cc681
r5584:545d748cc681
r8232:f2761d7ff77f
r8232:f2761d7ff77f
r8232:f2761d7ff77f
r11106:7af0cd6ebe11
r8232:f2761d7ff77f
r8232:f2761d7ff77f
r24602:d0d308decaa4
r18556:3a067cfd3824
r18556:3a067cfd3824
r5584:545d748cc681
r8300:4cfeeb3725a9
r8300:4cfeeb3725a9
r8300:4cfeeb3725a9
r9815:96f4a9d86b27
r8300:4cfeeb3725a9
r5584:545d748cc681
r23607:36c15679007d
r12460:1f2d22685cf3
r9815:96f4a9d86b27
r23607:36c15679007d
r9815:96f4a9d86b27
r9815:96f4a9d86b27
r18556:3a067cfd3824
r18556:3a067cfd3824
r18556:3a067cfd3824
r18556:3a067cfd3824
r18556:3a067cfd3824
r8300:4cfeeb3725a9
r8300:4cfeeb3725a9
r8297:4cf944e34d89
r8300:4cfeeb3725a9
r8625:a49c9c70551a
r8625:a49c9c70551a
r8297:4cf944e34d89
r8625:a49c9c70551a
r8297:4cf944e34d89
r9815:96f4a9d86b27
r23607:36c15679007d
r8300:4cfeeb3725a9
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r18557:96a9c31d64d1
r8300:4cfeeb3725a9
r8300:4cfeeb3725a9
r8297:4cf944e34d89
r5584:545d748cc681
r24602:d0d308decaa4
r24602:d0d308decaa4
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r15610:623a23fb6560
r15610:623a23fb6560
r14876:c971c4b731c8
r14876:c971c4b731c8
r14876:c971c4b731c8
r14876:c971c4b731c8
r11090:9276cea703d4
r5584:545d748cc681
r14804:e5dbb4dc2a7e
r14804:e5dbb4dc2a7e
r5584:545d748cc681
r14880:4a8d29bc60a7
r5584:545d748cc681
r14804:e5dbb4dc2a7e
r14697:0b5e0f20b510
r5584:545d748cc681
r14880:4a8d29bc60a7
r14880:4a8d29bc60a7
r5584:545d748cc681
r23607:36c15679007d
r5584:545d748cc681
r10236:993bcc06ffa8
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r26829:f1ebd010c392
r14800:3e915e992538
r5584:545d748cc681
r5584:545d748cc681
r8232:f2761d7ff77f
r8232:f2761d7ff77f
r8232:f2761d7ff77f
r11106:7af0cd6ebe11
r8232:f2761d7ff77f
r8232:f2761d7ff77f
r24602:d0d308decaa4
r18556:3a067cfd3824
r15091:ca0d009a9d80
r5584:545d748cc681
r8297:4cf944e34d89
r8297:4cf944e34d89
r8300:4cfeeb3725a9
r18264:ebfd7683aeb7
r23607:36c15679007d
r9815:96f4a9d86b27
r12460:1f2d22685cf3
r9815:96f4a9d86b27
r23607:36c15679007d
r9815:96f4a9d86b27
r5584:545d748cc681
r18556:3a067cfd3824
r18556:3a067cfd3824
r18556:3a067cfd3824
r18557:96a9c31d64d1
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r18558:0017880a5972
r18558:0017880a5972
r18556:3a067cfd3824
r18556:3a067cfd3824
r18556:3a067cfd3824
r5584:545d748cc681
r5584:545d748cc681
r23760:58e1a032cdaf
r8297:4cf944e34d89
r8589:02a107580b36
r8589:02a107580b36
r18264:ebfd7683aeb7
r8589:02a107580b36
r8589:02a107580b36
r8297:4cf944e34d89
r22001:0d97ce3496a8
r5584:545d748cc681
r5584:545d748cc681
r8297:4cf944e34d89
r8300:4cfeeb3725a9
r8625:a49c9c70551a
r8625:a49c9c70551a
r8297:4cf944e34d89
r9224:0340c9af9930
r8625:a49c9c70551a
r8297:4cf944e34d89
r9815:96f4a9d86b27
r23607:36c15679007d
r8297:4cf944e34d89
r5584:545d748cc681
r5584:545d748cc681
r18556:3a067cfd3824
r5584:545d748cc681
r5584:545d748cc681
r15610:623a23fb6560
r15610:623a23fb6560
r14876:c971c4b731c8
r14876:c971c4b731c8
r14876:c971c4b731c8
r14876:c971c4b731c8
r11090:9276cea703d4
r5584:545d748cc681
r5584:545d748cc681
r11725:57bc99fdc1bc
r5584:545d748cc681
r8390:ef5ec525d36d
r11725:57bc99fdc1bc
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6368:b0a38d4167ad
r16234:63c5973c2988
r16234:63c5973c2988
r16234:63c5973c2988
r16234:63c5973c2988
r16234:63c5973c2988
r16234:63c5973c2988
r16234:63c5973c2988
r16236:5e32661ad001
r16234:63c5973c2988
r16236:5e32661ad001
r16234:63c5973c2988
r16234:63c5973c2988
r16236:5e32661ad001
r16234:63c5973c2988
r16234:63c5973c2988
r16234:63c5973c2988
r16235:750325256b5c
r16235:750325256b5c
r16235:750325256b5c
r16235:750325256b5c
r16235:750325256b5c
r16235:750325256b5c
r16235:750325256b5c
r16235:750325256b5c
r16235:750325256b5c
r16235:750325256b5c
r16235:750325256b5c
r16235:750325256b5c
r16235:750325256b5c
r16235:750325256b5c
r23607:36c15679007d
r16235:750325256b5c
r16235:750325256b5c
r16235:750325256b5c
r16235:750325256b5c
r16235:750325256b5c
r7728:ec77c9b03910
r7728:ec77c9b03910
r7728:ec77c9b03910
r7728:ec77c9b03910
r7728:ec77c9b03910
r13060:e57594b0ca84
r7728:ec77c9b03910
r7728:ec77c9b03910
r7728:ec77c9b03910
r7728:ec77c9b03910
r10647:62911ec68e89
r5584:545d748cc681
r16232:444131f10b0a
r16232:444131f10b0a
r16232:444131f10b0a
r16236:5e32661ad001
r16236:5e32661ad001
r16236:5e32661ad001
r16236:5e32661ad001
r16236:5e32661ad001
r8806:1fc0d9e1c2bf
r16236:5e32661ad001
r5584:545d748cc681
r16233:65dd484c7832
r16236:5e32661ad001
r16236:5e32661ad001
r16236:5e32661ad001
r16236:5e32661ad001
r16236:5e32661ad001
r18245:fb370bf5a3c0
r18245:fb370bf5a3c0
r16236:5e32661ad001
r16236:5e32661ad001
r24597:afde5721a3b6
r24597:afde5721a3b6
r5584:545d748cc681
r16233:65dd484c7832
r16233:65dd484c7832
r16233:65dd484c7832
r16233:65dd484c7832
r16233:65dd484c7832
r16233:65dd484c7832
r5584:545d748cc681
r16235:750325256b5c
r16236:5e32661ad001
r16236:5e32661ad001
r16236:5e32661ad001
r5584:545d748cc681
r16235:750325256b5c
r16236:5e32661ad001
r16236:5e32661ad001
r16236:5e32661ad001
r16236:5e32661ad001
r16236:5e32661ad001
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r24100:c2d839fb3157
r24100:c2d839fb3157
r24100:c2d839fb3157
r24100:c2d839fb3157
r24100:c2d839fb3157
r24100:c2d839fb3157
r24100:c2d839fb3157
r24100:c2d839fb3157
r24100:c2d839fb3157
r24100:c2d839fb3157
r24100:c2d839fb3157
r24100:c2d839fb3157
r24100:c2d839fb3157
r24100:c2d839fb3157
r24100:c2d839fb3157
r24100:c2d839fb3157
r24101:6898ff80efc8
r24100:c2d839fb3157
r24100:c2d839fb3157
r24100:c2d839fb3157
r24101:6898ff80efc8
r24101:6898ff80efc8
r24100:c2d839fb3157
r24100:c2d839fb3157
r24100:c2d839fb3157
r24100:c2d839fb3157
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r6691:9c52dabf0c18
r23698:1872cc5b7dd7
r6691:9c52dabf0c18
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23838:bfeaabaa7b1d
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23838:bfeaabaa7b1d
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r24100:c2d839fb3157
r23698:1872cc5b7dd7
r24100:c2d839fb3157
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r6691:9c52dabf0c18
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r8865:3272b869c552
r6691:9c52dabf0c18
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r8865:3272b869c552
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r5584:545d748cc681
r19944:25a78576fb5e
r5584:545d748cc681
r5584:545d748cc681
r6422:5983361e241a
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8549:868ae7c78793
r8548:41ce2fbf1396
r5584:545d748cc681
r5584:545d748cc681
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r8548:41ce2fbf1396
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r14880:4a8d29bc60a7
r19084:082ddae0fb26
r8549:868ae7c78793
r27896:3f48fccebe5f
r19084:082ddae0fb26
r19084:082ddae0fb26
r19084:082ddae0fb26
r19084:082ddae0fb26
r19084:082ddae0fb26
r19084:082ddae0fb26
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r19084:082ddae0fb26
r5584:545d748cc681
r8548:41ce2fbf1396
r5668:e62c2fbafb7b
r9785:165707b7be50
r8549:868ae7c78793
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r26650:a3a9730bcdc8
r6691:9c52dabf0c18
r26650:a3a9730bcdc8
r26650:a3a9730bcdc8
r26650:a3a9730bcdc8
r26650:a3a9730bcdc8
r26650:a3a9730bcdc8
r26650:a3a9730bcdc8
r26650:a3a9730bcdc8
r26650:a3a9730bcdc8
r26650:a3a9730bcdc8
r26650:a3a9730bcdc8
r26650:a3a9730bcdc8
r26650:a3a9730bcdc8
r26650:a3a9730bcdc8
r26650:a3a9730bcdc8
r26650:a3a9730bcdc8
r26650:a3a9730bcdc8
r26650:a3a9730bcdc8
r26650:a3a9730bcdc8
r26650:a3a9730bcdc8
r26650:a3a9730bcdc8
r7601:2327d699b237
r23838:bfeaabaa7b1d
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r8806:1fc0d9e1c2bf
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r6691:9c52dabf0c18
r14477:752d803ed3be
r27896:3f48fccebe5f
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r10107:bcbf746656f1
r18726:6d5849476f85
r18726:6d5849476f85
r22047:cfe6e2f6daab
r22047:cfe6e2f6daab
r22047:cfe6e2f6daab
r22047:cfe6e2f6daab
r22047:cfe6e2f6daab
r22047:cfe6e2f6daab
r18726:6d5849476f85
r18726:6d5849476f85
r22469:27e3000e0fc8
r14477:752d803ed3be
r22469:27e3000e0fc8
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r22469:27e3000e0fc8
r14477:752d803ed3be
r6663:084fc9bc1095
r5584:545d748cc681
r19084:082ddae0fb26
r7601:2327d699b237
r19084:082ddae0fb26
r19084:082ddae0fb26
r19084:082ddae0fb26
r19084:082ddae0fb26
r19084:082ddae0fb26
r7601:2327d699b237
r16339:e90c1dadabf0
r13165:024ce8aa50e8
r7601:2327d699b237
r7601:2327d699b237
r5584:545d748cc681
r8390:ef5ec525d36d
r5668:e62c2fbafb7b
r5584:545d748cc681
r8083:8cd2123a0c7c
r5584:545d748cc681
r8549:868ae7c78793
r5584:545d748cc681
r6422:5983361e241a
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8548:41ce2fbf1396
r5584:545d748cc681
r6422:5983361e241a
r8548:41ce2fbf1396
r5584:545d748cc681
r9642:0489dee9f080
r9490:5cf190d39c21
r21031:52ba3c85974a
r9642:0489dee9f080
r9490:5cf190d39c21
r9490:5cf190d39c21
r9490:5cf190d39c21
r5584:545d748cc681
r5584:545d748cc681
r16997:e322f047824d
r16997:e322f047824d
r16997:e322f047824d
r16997:e322f047824d
r16997:e322f047824d
r16997:e322f047824d
r5584:545d748cc681
r15518:e589c4f3f9c1
r5584:545d748cc681
r5584:545d748cc681
r6422:5983361e241a
r5668:e62c2fbafb7b
r12110:ce9471c6e357
r12110:ce9471c6e357
r7601:2327d699b237
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8806:1fc0d9e1c2bf
r8806:1fc0d9e1c2bf
r5584:545d748cc681
r8549:868ae7c78793
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r6691:9c52dabf0c18
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r7601:2327d699b237
r10014:86dbfdd159ca
r27896:3f48fccebe5f
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r18728:912bce382eb9
r18728:912bce382eb9
r18728:912bce382eb9
r22047:cfe6e2f6daab
r22047:cfe6e2f6daab
r22047:cfe6e2f6daab
r22047:cfe6e2f6daab
r22047:cfe6e2f6daab
r22047:cfe6e2f6daab
r22047:cfe6e2f6daab
r22047:cfe6e2f6daab
r14477:752d803ed3be
r22047:cfe6e2f6daab
r22047:cfe6e2f6daab
r22047:cfe6e2f6daab
r22047:cfe6e2f6daab
r22047:cfe6e2f6daab
r14477:752d803ed3be
r14477:752d803ed3be
r18728:912bce382eb9
r12110:ce9471c6e357
r22469:27e3000e0fc8
r22469:27e3000e0fc8
r10014:86dbfdd159ca
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r15610:623a23fb6560
r15610:623a23fb6560
r9642:0489dee9f080
r9642:0489dee9f080
r9642:0489dee9f080
r9642:0489dee9f080
r9642:0489dee9f080
r9642:0489dee9f080
r9642:0489dee9f080
r9642:0489dee9f080
r9642:0489dee9f080
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r9642:0489dee9f080
r5584:545d748cc681
r5584:545d748cc681
r9642:0489dee9f080
r5584:545d748cc681
r9642:0489dee9f080
r5584:545d748cc681
r9642:0489dee9f080
r5584:545d748cc681
r9642:0489dee9f080
r5584:545d748cc681
r9642:0489dee9f080
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r17632:92f095eb81a2
r17632:92f095eb81a2
r17632:92f095eb81a2
r17632:92f095eb81a2
r10647:62911ec68e89
r5584:545d748cc681
r7601:2327d699b237
r7601:2327d699b237
r22469:27e3000e0fc8
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r7601:2327d699b237
r5584:545d748cc681
r5584:545d748cc681
r9498:789e6631bf2f
r9498:789e6631bf2f
r9498:789e6631bf2f
r5584:545d748cc681
r9498:789e6631bf2f
r9642:0489dee9f080
r8398:cf5cc32ab397
r8398:cf5cc32ab397
r5584:545d748cc681
r5584:545d748cc681
r9498:789e6631bf2f
r9498:789e6631bf2f
r9490:5cf190d39c21
r9498:789e6631bf2f
r9498:789e6631bf2f
r9498:789e6631bf2f
r9498:789e6631bf2f
r9490:5cf190d39c21
r9490:5cf190d39c21
r9490:5cf190d39c21
r9490:5cf190d39c21
r9490:5cf190d39c21
r9490:5cf190d39c21
r9490:5cf190d39c21
r5584:545d748cc681
r9498:789e6631bf2f
r9490:5cf190d39c21
r5584:545d748cc681
r9498:789e6631bf2f
r5668:e62c2fbafb7b
r5584:545d748cc681
r9498:789e6631bf2f
r9498:789e6631bf2f
r18245:fb370bf5a3c0
r18262:3bc00eb1e3da
r7601:2327d699b237
r16339:e90c1dadabf0
r7601:2327d699b237
r5584:545d748cc681
r7601:2327d699b237
r14477:752d803ed3be
r7601:2327d699b237
r7601:2327d699b237
r8806:1fc0d9e1c2bf
r8806:1fc0d9e1c2bf
r8806:1fc0d9e1c2bf
r8806:1fc0d9e1c2bf
r8806:1fc0d9e1c2bf
r8806:1fc0d9e1c2bf
r5668:e62c2fbafb7b
r5668:e62c2fbafb7b
r5668:e62c2fbafb7b
r5584:545d748cc681
r8549:868ae7c78793
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r10014:86dbfdd159ca
r27896:3f48fccebe5f
r18998:8e6e575c042a
r15747:606d1ec00369
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r22048:48340dbb02c2
r22048:48340dbb02c2
r22048:48340dbb02c2
r22048:48340dbb02c2
r22048:48340dbb02c2
r22048:48340dbb02c2
r22048:48340dbb02c2
r22048:48340dbb02c2
r22048:48340dbb02c2
r22048:48340dbb02c2
r14477:752d803ed3be
r14477:752d803ed3be
r22469:27e3000e0fc8
r22469:27e3000e0fc8
r10014:86dbfdd159ca
r6687:aaacb8e424b1
r6687:aaacb8e424b1
r6422:5983361e241a
r8806:1fc0d9e1c2bf
r8806:1fc0d9e1c2bf
r8806:1fc0d9e1c2bf
r8806:1fc0d9e1c2bf
r8806:1fc0d9e1c2bf
r8806:1fc0d9e1c2bf
r8806:1fc0d9e1c2bf
r8806:1fc0d9e1c2bf
r5584:545d748cc681
r5584:545d748cc681
r7601:2327d699b237
r8549:868ae7c78793
r7601:2327d699b237
r8806:1fc0d9e1c2bf
r8806:1fc0d9e1c2bf
r8806:1fc0d9e1c2bf
r5668:e62c2fbafb7b
r24295:ae0dcc3a6609
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r27056:ac04ccbeb86c
r5584:545d748cc681
r18260:9616113792ef
r18245:fb370bf5a3c0
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6422:5983361e241a
r27056:ac04ccbeb86c
r8390:ef5ec525d36d
r8083:8cd2123a0c7c
r18245:fb370bf5a3c0
r7335:93bf5f4b6ce4
r6422:5983361e241a
r27056:ac04ccbeb86c
r8379:853fb668feea
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r27058:f196a4b1ea62
r27058:f196a4b1ea62
r27058:f196a4b1ea62
r27058:f196a4b1ea62
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r18245:fb370bf5a3c0
r5584:545d748cc681
r5584:545d748cc681
r7335:93bf5f4b6ce4
r5584:545d748cc681
r8083:8cd2123a0c7c
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r9497:a6ff3c8ecdf5
r9497:a6ff3c8ecdf5
r5584:545d748cc681
r12622:202e83a6cee7
r9497:a6ff3c8ecdf5
r12622:202e83a6cee7
r5584:545d748cc681
r9322:3f83b0034795
r11247:c15ef8b37f5e
r11247:c15ef8b37f5e
r11247:c15ef8b37f5e
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r11247:c15ef8b37f5e
r11247:c15ef8b37f5e
r11247:c15ef8b37f5e
r11247:c15ef8b37f5e
r11247:c15ef8b37f5e
r11247:c15ef8b37f5e
r11725:57bc99fdc1bc
r11247:c15ef8b37f5e
r11247:c15ef8b37f5e
r11247:c15ef8b37f5e
r11247:c15ef8b37f5e
r11725:57bc99fdc1bc
r11247:c15ef8b37f5e
r11247:c15ef8b37f5e
r11247:c15ef8b37f5e
r14832:61030b59a8f3
r14832:61030b59a8f3
r27896:3f48fccebe5f
r14832:61030b59a8f3
r22479:b6106f114b30
r14832:61030b59a8f3
r14832:61030b59a8f3
r27737:728d55b97775
r26780:68ae5eb97708
r26780:68ae5eb97708
r14832:61030b59a8f3
r14832:61030b59a8f3
r14832:61030b59a8f3
r14832:61030b59a8f3
r21190:7bb64f2faa42
r27737:728d55b97775
r26780:68ae5eb97708
r26780:68ae5eb97708
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r14832:61030b59a8f3
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8088:0596dcb18b35
r9413:fcf267325763
r15744:6f723a16b26d
r15744:6f723a16b26d
r19944:25a78576fb5e
r15744:6f723a16b26d
r18262:3bc00eb1e3da
r15744:6f723a16b26d
r8088:0596dcb18b35
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r15744:6f723a16b26d
r5584:545d748cc681
r6357:de4229337c35
r5584:545d748cc681
r8088:0596dcb18b35
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8088:0596dcb18b35
r8088:0596dcb18b35
r8088:0596dcb18b35
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8616:656db5986c9e
r5584:545d748cc681
r8549:868ae7c78793
r23698:1872cc5b7dd7
r8596:8d17f7fccce1
r8596:8d17f7fccce1
r8596:8d17f7fccce1
r9224:0340c9af9930
r5584:545d748cc681
r5584:545d748cc681
r10207:a1fc2f2a33db
r5584:545d748cc681
r18556:3a067cfd3824
r18556:3a067cfd3824
r18556:3a067cfd3824
r18556:3a067cfd3824
r18556:3a067cfd3824
r25379:98a0c3d6dc80
r11247:c15ef8b37f5e
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r23698:1872cc5b7dd7
r11247:c15ef8b37f5e
r11247:c15ef8b37f5e
r11247:c15ef8b37f5e
r10207:a1fc2f2a33db
r5584:545d748cc681
r18556:3a067cfd3824
r18556:3a067cfd3824
r18556:3a067cfd3824
r18556:3a067cfd3824
r18556:3a067cfd3824
r18556:3a067cfd3824
r18556:3a067cfd3824
r18558:0017880a5972
r18558:0017880a5972
r18558:0017880a5972
r18556:3a067cfd3824
r18556:3a067cfd3824
r10207:a1fc2f2a33db
r10207:a1fc2f2a33db
r5584:545d748cc681
r18556:3a067cfd3824
r17033:a96db9bd8041
r17033:a96db9bd8041
r26118:2b515956558b
r17033:a96db9bd8041
r17033:a96db9bd8041
r17033:a96db9bd8041
r6734:f8fec7dde1f2
r6734:f8fec7dde1f2
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r16413:6d42b4af85f2
r27058:f196a4b1ea62
r27058:f196a4b1ea62
r27058:f196a4b1ea62
r27058:f196a4b1ea62
r27058:f196a4b1ea62
r27058:f196a4b1ea62
r27058:f196a4b1ea62
r27058:f196a4b1ea62
r27058:f196a4b1ea62
r27058:f196a4b1ea62
r27058:f196a4b1ea62
r27058:f196a4b1ea62
r27058:f196a4b1ea62
r27058:f196a4b1ea62
r27058:f196a4b1ea62
r27058:f196a4b1ea62
r27058:f196a4b1ea62
r27058:f196a4b1ea62
r27058:f196a4b1ea62
r27058:f196a4b1ea62
r27058:f196a4b1ea62
r27058:f196a4b1ea62
r27058:f196a4b1ea62
r16413:6d42b4af85f2
r16413:6d42b4af85f2
r16413:6d42b4af85f2
r16413:6d42b4af85f2
r16413:6d42b4af85f2
r5584:545d748cc681
r16413:6d42b4af85f2
r16427:f6ed1b934b78
r16413:6d42b4af85f2
r16413:6d42b4af85f2
r16427:f6ed1b934b78
r16427:f6ed1b934b78
r16413:6d42b4af85f2
r16413:6d42b4af85f2
r16427:f6ed1b934b78
r5584:545d748cc681
r8119:8fdb3a371896
r5584:545d748cc681
r27056:ac04ccbeb86c
r5584:545d748cc681
r7923:a6f3bc7003dc
r16294:f97c9cd4ff1e
r8548:41ce2fbf1396
r16294:f97c9cd4ff1e
r16294:f97c9cd4ff1e
r16412:3785137aceac
r16412:3785137aceac
r16412:3785137aceac
r16412:3785137aceac
r5584:545d748cc681
r5584:545d748cc681
r6259:e2dba394134b
r12109:90df01928018
r5584:545d748cc681
r11981:3840cc07cbe4
r16413:6d42b4af85f2
r11980:193f7a6b6e37
r5584:545d748cc681
r5584:545d748cc681
r5991:254bad51c6b2
r5584:545d748cc681
r16427:f6ed1b934b78
r11980:193f7a6b6e37
r11981:3840cc07cbe4
r11980:193f7a6b6e37
r5991:254bad51c6b2
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r16427:f6ed1b934b78
r5584:545d748cc681
r11980:193f7a6b6e37
r16295:3f3b0e040b26
r11981:3840cc07cbe4
r11980:193f7a6b6e37
r5991:254bad51c6b2
r5584:545d748cc681
r6259:e2dba394134b
r12109:90df01928018
r5584:545d748cc681
r6422:5983361e241a
r11979:a450390d0f16
r16427:f6ed1b934b78
r16414:400537a27ef8
r16414:400537a27ef8
r11979:a450390d0f16
r11979:a450390d0f16
r11979:a450390d0f16
r5991:254bad51c6b2
r5584:545d748cc681
r5991:254bad51c6b2
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r16414:400537a27ef8
r16427:f6ed1b934b78
r11979:a450390d0f16
r16295:3f3b0e040b26
r16414:400537a27ef8
r11979:a450390d0f16
r5991:254bad51c6b2
r5584:545d748cc681
r5584:545d748cc681
r8390:ef5ec525d36d
r16410:3bdb530fe738
r5584:545d748cc681
r27737:728d55b97775
r5584:545d748cc681
r6259:e2dba394134b
r16410:3bdb530fe738
r24597:afde5721a3b6
r5584:545d748cc681
r5584:545d748cc681
r16294:f97c9cd4ff1e
r16415:aa056fa4035a
r16415:aa056fa4035a
r9490:5cf190d39c21
r11980:193f7a6b6e37
r12109:90df01928018
r11981:3840cc07cbe4
r27058:f196a4b1ea62
r15608:7b580ec7448a
r15608:7b580ec7448a
r9490:5cf190d39c21
r14747:a465914ccbff
r14747:a465914ccbff
r14747:a465914ccbff
r27058:f196a4b1ea62
r15608:7b580ec7448a
r15608:7b580ec7448a
r9490:5cf190d39c21
r9490:5cf190d39c21
r12109:90df01928018
r9490:5cf190d39c21
r9490:5cf190d39c21
r9490:5cf190d39c21
r5584:545d748cc681
r5991:254bad51c6b2
r16294:f97c9cd4ff1e
r5584:545d748cc681
r9490:5cf190d39c21
r11980:193f7a6b6e37
r12109:90df01928018
r11981:3840cc07cbe4
r16295:3f3b0e040b26
r9490:5cf190d39c21
r9490:5cf190d39c21
r15608:7b580ec7448a
r15608:7b580ec7448a
r9490:5cf190d39c21
r11979:a450390d0f16
r12109:90df01928018
r11979:a450390d0f16
r16295:3f3b0e040b26
r11979:a450390d0f16
r9490:5cf190d39c21
r9490:5cf190d39c21
r15608:7b580ec7448a
r15608:7b580ec7448a
r9490:5cf190d39c21
r11979:a450390d0f16
r12109:90df01928018
r11979:a450390d0f16
r16295:3f3b0e040b26
r9490:5cf190d39c21
r9490:5cf190d39c21
r15608:7b580ec7448a
r15608:7b580ec7448a
r9490:5cf190d39c21
r9490:5cf190d39c21
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5991:254bad51c6b2
r5584:545d748cc681
r5584:545d748cc681
r18261:0aa61ca7490f
r7494:2e43e3339051
r9492:2708969ab966
r8083:8cd2123a0c7c
r7582:dfefb1216e6f
r7582:dfefb1216e6f
r18260:9616113792ef
r18251:23e77d038c74
r7582:dfefb1216e6f
r10017:0fde3332744e
r7582:dfefb1216e6f
r23028:0602ed02c6b4
r23028:0602ed02c6b4
r7582:dfefb1216e6f
r23028:0602ed02c6b4
r23028:0602ed02c6b4
r7582:dfefb1216e6f
r7582:dfefb1216e6f
r8371:32791d4d82d0
r14304:dc9cb5b9e881
r7582:dfefb1216e6f
r7582:dfefb1216e6f
r26118:2b515956558b
r7494:2e43e3339051
r7494:2e43e3339051
r5587:034e5e185dc2
r11363:6906c490a00e
r18245:fb370bf5a3c0
r11363:6906c490a00e
r23607:36c15679007d
r11363:6906c490a00e
r11363:6906c490a00e
r23607:36c15679007d
r23607:36c15679007d
r18314:21a3c3233272
r18314:21a3c3233272
r23607:36c15679007d
r11363:6906c490a00e
r11363:6906c490a00e
r11363:6906c490a00e
r5584:545d748cc681
/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * @file tunnelbridge_cmd.cpp
 * This file deals with tunnels and bridges (non-gui stuff)
 * @todo separate this file into two
 */

#include "stdafx.h"
#include "newgrf_object.h"
#include "viewport_func.h"
#include "command_func.h"
#include "town.h"
#include "train.h"
#include "ship.h"
#include "roadveh.h"
#include "pathfinder/yapf/yapf_cache.h"
#include "newgrf_sound.h"
#include "autoslope.h"
#include "tunnelbridge_map.h"
#include "strings_func.h"
#include "timer/timer_game_calendar.h"
#include "clear_func.h"
#include "vehicle_func.h"
#include "sound_func.h"
#include "tunnelbridge.h"
#include "cheat_type.h"
#include "elrail_func.h"
#include "pbs.h"
#include "company_base.h"
#include "newgrf_railtype.h"
#include "newgrf_roadtype.h"
#include "object_base.h"
#include "water.h"
#include "company_gui.h"
#include "station_func.h"
#include "tunnelbridge_cmd.h"
#include "landscape_cmd.h"
#include "terraform_cmd.h"

#include "table/strings.h"
#include "table/bridge_land.h"

#include "safeguards.h"

BridgeSpec _bridge[MAX_BRIDGES]; ///< The specification of all bridges.
TileIndex _build_tunnel_endtile; ///< The end of a tunnel; as hidden return from the tunnel build command for GUI purposes.

/** Z position of the bridge sprites relative to bridge height (downwards) */
static const int BRIDGE_Z_START = 3;


/**
 * Mark bridge tiles dirty.
 * Note: The bridge does not need to exist, everything is passed via parameters.
 * @param begin Start tile.
 * @param end End tile.
 * @param direction Direction from \a begin to \a end.
 * @param bridge_height Bridge height level.
 */
void MarkBridgeDirty(TileIndex begin, TileIndex end, DiagDirection direction, uint bridge_height)
{
	TileIndexDiff delta = TileOffsByDiagDir(direction);
	for (TileIndex t = begin; t != end; t += delta) {
		MarkTileDirtyByTile(t, bridge_height - TileHeight(t));
	}
	MarkTileDirtyByTile(end);
}

/**
 * Mark bridge tiles dirty.
 * @param tile Bridge head.
 */
void MarkBridgeDirty(TileIndex tile)
{
	MarkBridgeDirty(tile, GetOtherTunnelBridgeEnd(tile), GetTunnelBridgeDirection(tile), GetBridgeHeight(tile));
}

/** Reset the data been eventually changed by the grf loaded. */
void ResetBridges()
{
	/* First, free sprite table data */
	for (BridgeType i = 0; i < MAX_BRIDGES; i++) {
		if (_bridge[i].sprite_table != nullptr) {
			for (BridgePieces j = BRIDGE_PIECE_NORTH; j < BRIDGE_PIECE_INVALID; j++) free(_bridge[i].sprite_table[j]);
			free(_bridge[i].sprite_table);
		}
	}

	/* Then, wipe out current bridges */
	memset(&_bridge, 0, sizeof(_bridge));
	/* And finally, reinstall default data */
	memcpy(&_bridge, &_orig_bridge, sizeof(_orig_bridge));
}

/**
 * Calculate the price factor for building a long bridge.
 * Basically the cost delta is 1,1, 1, 2,2, 3,3,3, 4,4,4,4, 5,5,5,5,5, 6,6,6,6,6,6,  7,7,7,7,7,7,7,  8,8,8,8,8,8,8,8,
 * @param length Length of the bridge.
 * @return Price factor for the bridge.
 */
int CalcBridgeLenCostFactor(int length)
{
	if (length < 2) return length;

	length -= 2;
	int sum = 2;
	for (int delta = 1;; delta++) {
		for (int count = 0; count < delta; count++) {
			if (length == 0) return sum;
			sum += delta;
			length--;
		}
	}
}

/**
 * Get the foundation for a bridge.
 * @param tileh The slope to build the bridge on.
 * @param axis The axis of the bridge entrance.
 * @return The foundation required.
 */
Foundation GetBridgeFoundation(Slope tileh, Axis axis)
{
	if (tileh == SLOPE_FLAT ||
			((tileh == SLOPE_NE || tileh == SLOPE_SW) && axis == AXIS_X) ||
			((tileh == SLOPE_NW || tileh == SLOPE_SE) && axis == AXIS_Y)) return FOUNDATION_NONE;

	return (HasSlopeHighestCorner(tileh) ? InclinedFoundation(axis) : FlatteningFoundation(tileh));
}

/**
 * Determines if the track on a bridge ramp is flat or goes up/down.
 *
 * @param tileh Slope of the tile under the bridge head
 * @param axis Orientation of bridge
 * @return true iff the track is flat.
 */
bool HasBridgeFlatRamp(Slope tileh, Axis axis)
{
	ApplyFoundationToSlope(GetBridgeFoundation(tileh, axis), &tileh);
	/* If the foundation slope is flat the bridge has a non-flat ramp and vice versa. */
	return (tileh != SLOPE_FLAT);
}

static inline const PalSpriteID *GetBridgeSpriteTable(int index, BridgePieces table)
{
	const BridgeSpec *bridge = GetBridgeSpec(index);
	assert(table < BRIDGE_PIECE_INVALID);
	if (bridge->sprite_table == nullptr || bridge->sprite_table[table] == nullptr) {
		return _bridge_sprite_table[index][table];
	} else {
		return bridge->sprite_table[table];
	}
}


/**
 * Determines the foundation for the bridge head, and tests if the resulting slope is valid.
 *
 * @param bridge_piece Direction of the bridge head.
 * @param axis Axis of the bridge
 * @param tileh Slope of the tile under the north bridge head; returns slope on top of foundation
 * @param z TileZ corresponding to tileh, gets modified as well
 * @return Error or cost for bridge foundation
 */
static CommandCost CheckBridgeSlope(BridgePieces bridge_piece, Axis axis, Slope *tileh, int *z)
{
	assert(bridge_piece == BRIDGE_PIECE_NORTH || bridge_piece == BRIDGE_PIECE_SOUTH);

	Foundation f = GetBridgeFoundation(*tileh, axis);
	*z += ApplyFoundationToSlope(f, tileh);

	Slope valid_inclined;
	if (bridge_piece == BRIDGE_PIECE_NORTH) {
		valid_inclined = (axis == AXIS_X ? SLOPE_NE : SLOPE_NW);
	} else {
		valid_inclined = (axis == AXIS_X ? SLOPE_SW : SLOPE_SE);
	}
	if ((*tileh != SLOPE_FLAT) && (*tileh != valid_inclined)) return CMD_ERROR;

	if (f == FOUNDATION_NONE) return CommandCost();

	return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_FOUNDATION]);
}

/**
 * Is a bridge of the specified type and length available?
 * @param bridge_type Wanted type of bridge.
 * @param bridge_len  Wanted length of the bridge.
 * @param flags       Type of operation.
 * @return A succeeded (the requested bridge is available) or failed (it cannot be built) command.
 */
CommandCost CheckBridgeAvailability(BridgeType bridge_type, uint bridge_len, DoCommandFlag flags)
{
	if (flags & DC_QUERY_COST) {
		if (bridge_len <= _settings_game.construction.max_bridge_length) return CommandCost();
		return_cmd_error(STR_ERROR_BRIDGE_TOO_LONG);
	}

	if (bridge_type >= MAX_BRIDGES) return CMD_ERROR;

	const BridgeSpec *b = GetBridgeSpec(bridge_type);
	if (b->avail_year > TimerGameCalendar::year) return CMD_ERROR;

	uint max = std::min(b->max_length, _settings_game.construction.max_bridge_length);

	if (b->min_length > bridge_len) return CMD_ERROR;
	if (bridge_len <= max) return CommandCost();
	return_cmd_error(STR_ERROR_BRIDGE_TOO_LONG);
}

/**
 * Calculate the base cost of clearing a tunnel/bridge per tile.
 * @param tile Start tile of the tunnel/bridge.
 * @return How much clearing this tunnel/bridge costs per tile.
 */
static Money TunnelBridgeClearCost(TileIndex tile, Price base_price)
{
	Money base_cost = _price[base_price];

	/* Add the cost of the transport that is on the tunnel/bridge. */
	switch (GetTunnelBridgeTransportType(tile)) {
		case TRANSPORT_ROAD: {
			RoadType road_rt = GetRoadTypeRoad(tile);
			RoadType tram_rt = GetRoadTypeTram(tile);

			if (road_rt != INVALID_ROADTYPE) {
				base_cost += 2 * RoadClearCost(road_rt);
			}
			if (tram_rt != INVALID_ROADTYPE) {
				base_cost += 2 * RoadClearCost(tram_rt);
			}
		} break;

		case TRANSPORT_RAIL: base_cost += RailClearCost(GetRailType(tile)); break;
		/* Aquaducts have their own clear price. */
		case TRANSPORT_WATER: base_cost = _price[PR_CLEAR_AQUEDUCT]; break;
		default: break;
	}

	return base_cost;
}

/**
 * Build a Bridge
 * @param flags type of operation
 * @param tile_end end tile
 * @param tile_start start tile
 * @param transport_type transport type.
 * @param bridge_type bridge type (hi bh)
 * @param road_rail_type rail type or road types.
 * @return the cost of this operation or an error
 */
CommandCost CmdBuildBridge(DoCommandFlag flags, TileIndex tile_end, TileIndex tile_start, TransportType transport_type, BridgeType bridge_type, byte road_rail_type)
{
	CompanyID company = _current_company;

	RailType railtype = INVALID_RAILTYPE;
	RoadType roadtype = INVALID_ROADTYPE;

	if (!IsValidTile(tile_start)) return_cmd_error(STR_ERROR_BRIDGE_THROUGH_MAP_BORDER);

	/* type of bridge */
	switch (transport_type) {
		case TRANSPORT_ROAD:
			roadtype = (RoadType)road_rail_type;
			if (!ValParamRoadType(roadtype)) return CMD_ERROR;
			break;

		case TRANSPORT_RAIL:
			railtype = (RailType)road_rail_type;
			if (!ValParamRailType(railtype)) return CMD_ERROR;
			break;

		case TRANSPORT_WATER:
			break;

		default:
			/* Airports don't have bridges. */
			return CMD_ERROR;
	}

	if (company == OWNER_DEITY) {
		if (transport_type != TRANSPORT_ROAD) return CMD_ERROR;
		const Town *town = CalcClosestTownFromTile(tile_start);

		company = OWNER_TOWN;

		/* If we are not within a town, we are not owned by the town */
		if (town == nullptr || DistanceSquare(tile_start, town->xy) > town->cache.squared_town_zone_radius[HZB_TOWN_EDGE]) {
			company = OWNER_NONE;
		}
	}

	if (tile_start == tile_end) {
		return_cmd_error(STR_ERROR_CAN_T_START_AND_END_ON);
	}

	Axis direction;
	if (TileX(tile_start) == TileX(tile_end)) {
		direction = AXIS_Y;
	} else if (TileY(tile_start) == TileY(tile_end)) {
		direction = AXIS_X;
	} else {
		return_cmd_error(STR_ERROR_START_AND_END_MUST_BE_IN);
	}

	if (tile_end < tile_start) Swap(tile_start, tile_end);

	uint bridge_len = GetTunnelBridgeLength(tile_start, tile_end);
	if (transport_type != TRANSPORT_WATER) {
		/* set and test bridge length, availability */
		CommandCost ret = CheckBridgeAvailability(bridge_type, bridge_len, flags);
		if (ret.Failed()) return ret;
	} else {
		if (bridge_len > _settings_game.construction.max_bridge_length) return_cmd_error(STR_ERROR_BRIDGE_TOO_LONG);
	}
	bridge_len += 2; // begin and end tiles/ramps

	int z_start;
	int z_end;
	Slope tileh_start = GetTileSlope(tile_start, &z_start);
	Slope tileh_end = GetTileSlope(tile_end, &z_end);
	bool pbs_reservation = false;

	CommandCost terraform_cost_north = CheckBridgeSlope(BRIDGE_PIECE_NORTH, direction, &tileh_start, &z_start);
	CommandCost terraform_cost_south = CheckBridgeSlope(BRIDGE_PIECE_SOUTH, direction, &tileh_end,   &z_end);

	/* Aqueducts can't be built of flat land. */
	if (transport_type == TRANSPORT_WATER && (tileh_start == SLOPE_FLAT || tileh_end == SLOPE_FLAT)) return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
	if (z_start != z_end) return_cmd_error(STR_ERROR_BRIDGEHEADS_NOT_SAME_HEIGHT);

	CommandCost cost(EXPENSES_CONSTRUCTION);
	Owner owner;
	bool is_new_owner;
	RoadType road_rt = INVALID_ROADTYPE;
	RoadType tram_rt = INVALID_ROADTYPE;
	if (IsBridgeTile(tile_start) && IsBridgeTile(tile_end) &&
			GetOtherBridgeEnd(tile_start) == tile_end &&
			GetTunnelBridgeTransportType(tile_start) == transport_type) {
		/* Replace a current bridge. */

		switch (transport_type) {
			case TRANSPORT_RAIL:
				/* Keep the reservation, the path stays valid. */
				pbs_reservation = HasTunnelBridgeReservation(tile_start);
				break;

			case TRANSPORT_ROAD:
				/* Do not remove road types when upgrading a bridge */
				road_rt = GetRoadTypeRoad(tile_start);
				tram_rt = GetRoadTypeTram(tile_start);
				break;

			default: break;
		}

		/* If this is a railway bridge, make sure the railtypes match. */
		if (transport_type == TRANSPORT_RAIL && GetRailType(tile_start) != railtype) {
			return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);
		}

		/* If this is a road bridge, make sure the roadtype matches. */
		if (transport_type == TRANSPORT_ROAD) {
			RoadType existing_rt = RoadTypeIsRoad(roadtype) ? road_rt : tram_rt;
			if (existing_rt != roadtype && existing_rt != INVALID_ROADTYPE) {
				return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);
			}
		}

		/* Do not replace town bridges with lower speed bridges, unless in scenario editor. */
		if (!(flags & DC_QUERY_COST) && IsTileOwner(tile_start, OWNER_TOWN) &&
				GetBridgeSpec(bridge_type)->speed < GetBridgeSpec(GetBridgeType(tile_start))->speed &&
				_game_mode != GM_EDITOR) {
			Town *t = ClosestTownFromTile(tile_start, UINT_MAX);

			if (t == nullptr) {
				return CMD_ERROR;
			} else {
				SetDParam(0, t->index);
				return_cmd_error(STR_ERROR_LOCAL_AUTHORITY_REFUSES_TO_ALLOW_THIS);
			}
		}

		/* Do not replace the bridge with the same bridge type. */
		if (!(flags & DC_QUERY_COST) && (bridge_type == GetBridgeType(tile_start)) && (transport_type != TRANSPORT_ROAD || road_rt == roadtype || tram_rt == roadtype)) {
			return_cmd_error(STR_ERROR_ALREADY_BUILT);
		}

		/* Do not allow replacing another company's bridges. */
		if (!IsTileOwner(tile_start, company) && !IsTileOwner(tile_start, OWNER_TOWN) && !IsTileOwner(tile_start, OWNER_NONE)) {
			return_cmd_error(STR_ERROR_AREA_IS_OWNED_BY_ANOTHER);
		}

		/* The cost of clearing the current bridge. */
		cost.AddCost(bridge_len * TunnelBridgeClearCost(tile_start, PR_CLEAR_BRIDGE));
		owner = GetTileOwner(tile_start);

		/* If bridge belonged to bankrupt company, it has a new owner now */
		is_new_owner = (owner == OWNER_NONE);
		if (is_new_owner) owner = company;
	} else {
		/* Build a new bridge. */

		bool allow_on_slopes = (_settings_game.construction.build_on_slopes && transport_type != TRANSPORT_WATER);

		/* Try and clear the start landscape */
		CommandCost ret = Command<CMD_LANDSCAPE_CLEAR>::Do(flags, tile_start);
		if (ret.Failed()) return ret;
		cost = ret;

		if (terraform_cost_north.Failed() || (terraform_cost_north.GetCost() != 0 && !allow_on_slopes)) return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
		cost.AddCost(terraform_cost_north);

		/* Try and clear the end landscape */
		ret = Command<CMD_LANDSCAPE_CLEAR>::Do(flags, tile_end);
		if (ret.Failed()) return ret;
		cost.AddCost(ret);

		/* false - end tile slope check */
		if (terraform_cost_south.Failed() || (terraform_cost_south.GetCost() != 0 && !allow_on_slopes)) return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
		cost.AddCost(terraform_cost_south);

		const TileIndex heads[] = {tile_start, tile_end};
		for (int i = 0; i < 2; i++) {
			if (IsBridgeAbove(heads[i])) {
				TileIndex north_head = GetNorthernBridgeEnd(heads[i]);

				if (direction == GetBridgeAxis(heads[i])) return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);

				if (z_start + 1 == GetBridgeHeight(north_head)) {
					return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);
				}
			}
		}

		TileIndexDiff delta = (direction == AXIS_X ? TileDiffXY(1, 0) : TileDiffXY(0, 1));
		for (TileIndex tile = tile_start + delta; tile != tile_end; tile += delta) {
			if (GetTileMaxZ(tile) > z_start) return_cmd_error(STR_ERROR_BRIDGE_TOO_LOW_FOR_TERRAIN);

			if (z_start >= (GetTileZ(tile) + _settings_game.construction.max_bridge_height)) {
				/*
				 * Disallow too high bridges.
				 * Properly rendering a map where very high bridges (might) exist is expensive.
				 * See http://www.tt-forums.net/viewtopic.php?f=33&t=40844&start=980#p1131762
				 * for a detailed discussion. z_start here is one heightlevel below the bridge level.
				 */
				return_cmd_error(STR_ERROR_BRIDGE_TOO_HIGH_FOR_TERRAIN);
			}

			if (IsBridgeAbove(tile)) {
				/* Disallow crossing bridges for the time being */
				return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);
			}

			switch (GetTileType(tile)) {
				case MP_WATER:
					if (!IsWater(tile) && !IsCoast(tile)) goto not_valid_below;
					break;

				case MP_RAILWAY:
					if (!IsPlainRail(tile)) goto not_valid_below;
					break;

				case MP_ROAD:
					if (IsRoadDepot(tile)) goto not_valid_below;
					break;

				case MP_TUNNELBRIDGE:
					if (IsTunnel(tile)) break;
					if (direction == DiagDirToAxis(GetTunnelBridgeDirection(tile))) goto not_valid_below;
					if (z_start < GetBridgeHeight(tile)) goto not_valid_below;
					break;

				case MP_OBJECT: {
					const ObjectSpec *spec = ObjectSpec::GetByTile(tile);
					if ((spec->flags & OBJECT_FLAG_ALLOW_UNDER_BRIDGE) == 0) goto not_valid_below;
					if (GetTileMaxZ(tile) + spec->height > z_start) goto not_valid_below;
					break;
				}

				case MP_CLEAR:
					break;

				default:
	not_valid_below:;
					/* try and clear the middle landscape */
					ret = Command<CMD_LANDSCAPE_CLEAR>::Do(flags, tile);
					if (ret.Failed()) return ret;
					cost.AddCost(ret);
					break;
			}

			if (flags & DC_EXEC) {
				/* We do this here because when replacing a bridge with another
				 * type calling SetBridgeMiddle isn't needed. After all, the
				 * tile already has the has_bridge_above bits set. */
				SetBridgeMiddle(tile, direction);
			}
		}

		owner = company;
		is_new_owner = true;
	}

	bool hasroad = road_rt != INVALID_ROADTYPE;
	bool hastram = tram_rt != INVALID_ROADTYPE;
	if (transport_type == TRANSPORT_ROAD) {
		if (RoadTypeIsRoad(roadtype)) road_rt = roadtype;
		if (RoadTypeIsTram(roadtype)) tram_rt = roadtype;
	}

	/* do the drill? */
	if (flags & DC_EXEC) {
		DiagDirection dir = AxisToDiagDir(direction);

		Company *c = Company::GetIfValid(company);
		switch (transport_type) {
			case TRANSPORT_RAIL:
				/* Add to company infrastructure count if required. */
				if (is_new_owner && c != nullptr) c->infrastructure.rail[railtype] += bridge_len * TUNNELBRIDGE_TRACKBIT_FACTOR;
				MakeRailBridgeRamp(tile_start, owner, bridge_type, dir,                 railtype);
				MakeRailBridgeRamp(tile_end,   owner, bridge_type, ReverseDiagDir(dir), railtype);
				SetTunnelBridgeReservation(tile_start, pbs_reservation);
				SetTunnelBridgeReservation(tile_end,   pbs_reservation);
				break;

			case TRANSPORT_ROAD: {
				if (is_new_owner) {
					/* Also give unowned present roadtypes to new owner */
					if (hasroad && GetRoadOwner(tile_start, RTT_ROAD) == OWNER_NONE) hasroad = false;
					if (hastram && GetRoadOwner(tile_start, RTT_TRAM) == OWNER_NONE) hastram = false;
				}
				if (c != nullptr) {
					/* Add all new road types to the company infrastructure counter. */
					if (!hasroad && road_rt != INVALID_ROADTYPE) {
						/* A full diagonal road tile has two road bits. */
						c->infrastructure.road[road_rt] += bridge_len * 2 * TUNNELBRIDGE_TRACKBIT_FACTOR;
					}
					if (!hastram && tram_rt != INVALID_ROADTYPE) {
						/* A full diagonal road tile has two road bits. */
						c->infrastructure.road[tram_rt] += bridge_len * 2 * TUNNELBRIDGE_TRACKBIT_FACTOR;
					}
				}
				Owner owner_road = hasroad ? GetRoadOwner(tile_start, RTT_ROAD) : company;
				Owner owner_tram = hastram ? GetRoadOwner(tile_start, RTT_TRAM) : company;
				MakeRoadBridgeRamp(tile_start, owner, owner_road, owner_tram, bridge_type, dir, road_rt, tram_rt);
				MakeRoadBridgeRamp(tile_end,   owner, owner_road, owner_tram, bridge_type, ReverseDiagDir(dir), road_rt, tram_rt);
				break;
			}

			case TRANSPORT_WATER:
				if (is_new_owner && c != nullptr) c->infrastructure.water += bridge_len * TUNNELBRIDGE_TRACKBIT_FACTOR;
				MakeAqueductBridgeRamp(tile_start, owner, dir);
				MakeAqueductBridgeRamp(tile_end,   owner, ReverseDiagDir(dir));
				CheckForDockingTile(tile_start);
				CheckForDockingTile(tile_end);
				break;

			default:
				NOT_REACHED();
		}

		/* Mark all tiles dirty */
		MarkBridgeDirty(tile_start, tile_end, AxisToDiagDir(direction), z_start);
		DirtyCompanyInfrastructureWindows(company);
	}

	if ((flags & DC_EXEC) && transport_type == TRANSPORT_RAIL) {
		Track track = AxisToTrack(direction);
		AddSideToSignalBuffer(tile_start, INVALID_DIAGDIR, company);
		YapfNotifyTrackLayoutChange(tile_start, track);
	}

	/* Human players that build bridges get a selection to choose from (DC_QUERY_COST)
	 * It's unnecessary to execute this command every time for every bridge.
	 * So it is done only for humans and cost is computed in bridge_gui.cpp.
	 * For (non-spectated) AI, Towns this has to be of course calculated. */
	Company *c = Company::GetIfValid(company);
	if (!(flags & DC_QUERY_COST) || (c != nullptr && c->is_ai && company != _local_company)) {
		switch (transport_type) {
			case TRANSPORT_ROAD:
				if (road_rt != INVALID_ROADTYPE) {
					cost.AddCost(bridge_len * 2 * RoadBuildCost(road_rt));
				}
				if (tram_rt != INVALID_ROADTYPE) {
					cost.AddCost(bridge_len * 2 * RoadBuildCost(tram_rt));
				}
				break;

			case TRANSPORT_RAIL: cost.AddCost(bridge_len * RailBuildCost(railtype)); break;
			default: break;
		}

		if (c != nullptr) bridge_len = CalcBridgeLenCostFactor(bridge_len);

		if (transport_type != TRANSPORT_WATER) {
			cost.AddCost((int64_t)bridge_len * _price[PR_BUILD_BRIDGE] * GetBridgeSpec(bridge_type)->price >> 8);
		} else {
			/* Aqueducts use a separate base cost. */
			cost.AddCost((int64_t)bridge_len * _price[PR_BUILD_AQUEDUCT]);
		}

	}

	return cost;
}


/**
 * Build Tunnel.
 * @param flags type of operation
 * @param start_tile start tile of tunnel
 * @param transport_type transport type
 * @param road_rail_type railtype or roadtype
 * @return the cost of this operation or an error
 */
CommandCost CmdBuildTunnel(DoCommandFlag flags, TileIndex start_tile, TransportType transport_type, byte road_rail_type)
{
	CompanyID company = _current_company;

	RailType railtype = INVALID_RAILTYPE;
	RoadType roadtype = INVALID_ROADTYPE;
	_build_tunnel_endtile = 0;
	switch (transport_type) {
		case TRANSPORT_RAIL:
			railtype = (RailType)road_rail_type;
			if (!ValParamRailType(railtype)) return CMD_ERROR;
			break;

		case TRANSPORT_ROAD:
			roadtype = (RoadType)road_rail_type;
			if (!ValParamRoadType(roadtype)) return CMD_ERROR;
			break;

		default: return CMD_ERROR;
	}

	if (company == OWNER_DEITY) {
		if (transport_type != TRANSPORT_ROAD) return CMD_ERROR;
		const Town *town = CalcClosestTownFromTile(start_tile);

		company = OWNER_TOWN;

		/* If we are not within a town, we are not owned by the town */
		if (town == nullptr || DistanceSquare(start_tile, town->xy) > town->cache.squared_town_zone_radius[HZB_TOWN_EDGE]) {
			company = OWNER_NONE;
		}
	}

	int start_z;
	int end_z;
	Slope start_tileh = GetTileSlope(start_tile, &start_z);
	DiagDirection direction = GetInclinedSlopeDirection(start_tileh);
	if (direction == INVALID_DIAGDIR) return_cmd_error(STR_ERROR_SITE_UNSUITABLE_FOR_TUNNEL);

	if (HasTileWaterGround(start_tile)) return_cmd_error(STR_ERROR_CAN_T_BUILD_ON_WATER);

	CommandCost ret = Command<CMD_LANDSCAPE_CLEAR>::Do(flags, start_tile);
	if (ret.Failed()) return ret;

	/* XXX - do NOT change 'ret' in the loop, as it is used as the price
	 * for the clearing of the entrance of the tunnel. Assigning it to
	 * cost before the loop will yield different costs depending on start-
	 * position, because of increased-cost-by-length: 'cost += cost >> 3' */

	TileIndexDiff delta = TileOffsByDiagDir(direction);
	DiagDirection tunnel_in_way_dir;
	if (DiagDirToAxis(direction) == AXIS_Y) {
		tunnel_in_way_dir = (TileX(start_tile) < (Map::MaxX() / 2)) ? DIAGDIR_SW : DIAGDIR_NE;
	} else {
		tunnel_in_way_dir = (TileY(start_tile) < (Map::MaxX() / 2)) ? DIAGDIR_SE : DIAGDIR_NW;
	}

	TileIndex end_tile = start_tile;

	/* Tile shift coefficient. Will decrease for very long tunnels to avoid exponential growth of price*/
	int tiles_coef = 3;
	/* Number of tiles from start of tunnel */
	int tiles = 0;
	/* Number of tiles at which the cost increase coefficient per tile is halved */
	int tiles_bump = 25;

	CommandCost cost(EXPENSES_CONSTRUCTION);
	Slope end_tileh;
	for (;;) {
		end_tile += delta;
		if (!IsValidTile(end_tile)) return_cmd_error(STR_ERROR_TUNNEL_THROUGH_MAP_BORDER);
		end_tileh = GetTileSlope(end_tile, &end_z);

		if (start_z == end_z) break;

		if (!_cheats.crossing_tunnels.value && IsTunnelInWayDir(end_tile, start_z, tunnel_in_way_dir)) {
			return_cmd_error(STR_ERROR_ANOTHER_TUNNEL_IN_THE_WAY);
		}

		tiles++;
		if (tiles == tiles_bump) {
			tiles_coef++;
			tiles_bump *= 2;
		}

		cost.AddCost(_price[PR_BUILD_TUNNEL]);
		cost.AddCost(cost.GetCost() >> tiles_coef); // add a multiplier for longer tunnels
	}

	/* Add the cost of the entrance */
	cost.AddCost(_price[PR_BUILD_TUNNEL]);
	cost.AddCost(ret);

	/* if the command fails from here on we want the end tile to be highlighted */
	_build_tunnel_endtile = end_tile;

	if (tiles > _settings_game.construction.max_tunnel_length) return_cmd_error(STR_ERROR_TUNNEL_TOO_LONG);

	if (HasTileWaterGround(end_tile)) return_cmd_error(STR_ERROR_CAN_T_BUILD_ON_WATER);

	/* Clear the tile in any case */
	ret = Command<CMD_LANDSCAPE_CLEAR>::Do(flags, end_tile);
	if (ret.Failed()) return_cmd_error(STR_ERROR_UNABLE_TO_EXCAVATE_LAND);
	cost.AddCost(ret);

	/* slope of end tile must be complementary to the slope of the start tile */
	if (end_tileh != ComplementSlope(start_tileh)) {
		/* Mark the tile as already cleared for the terraform command.
		 * Do this for all tiles (like trees), not only objects. */
		ClearedObjectArea *coa = FindClearedObject(end_tile);
		if (coa == nullptr) {
			coa = &_cleared_object_areas.emplace_back(ClearedObjectArea{ end_tile, TileArea(end_tile, 1, 1) });
		}

		/* Hide the tile from the terraforming command */
		TileIndex old_first_tile = coa->first_tile;
		coa->first_tile = INVALID_TILE;

		/* CMD_TERRAFORM_LAND may append further items to _cleared_object_areas,
		 * however it will never erase or re-order existing items.
		 * _cleared_object_areas is a value-type self-resizing vector, therefore appending items
		 * may result in a backing-store re-allocation, which would invalidate the coa pointer.
		 * The index of the coa pointer into the _cleared_object_areas vector remains valid,
		 * and can be used safely after the CMD_TERRAFORM_LAND operation.
		 * Deliberately clear the coa pointer to avoid leaving dangling pointers which could
		 * inadvertently be dereferenced.
		 */
		ClearedObjectArea *begin = _cleared_object_areas.data();
		assert(coa >= begin && coa < begin + _cleared_object_areas.size());
		size_t coa_index = coa - begin;
		assert(coa_index < UINT_MAX); // more than 2**32 cleared areas would be a bug in itself
		coa = nullptr;

		ret = std::get<0>(Command<CMD_TERRAFORM_LAND>::Do(flags, end_tile, end_tileh & start_tileh, false));
		_cleared_object_areas[(uint)coa_index].first_tile = old_first_tile;
		if (ret.Failed()) return_cmd_error(STR_ERROR_UNABLE_TO_EXCAVATE_LAND);
		cost.AddCost(ret);
	}
	cost.AddCost(_price[PR_BUILD_TUNNEL]);

	/* Pay for the rail/road in the tunnel including entrances */
	switch (transport_type) {
		case TRANSPORT_ROAD: cost.AddCost((tiles + 2) * RoadBuildCost(roadtype) * 2); break;
		case TRANSPORT_RAIL: cost.AddCost((tiles + 2) * RailBuildCost(railtype)); break;
		default: NOT_REACHED();
	}

	if (flags & DC_EXEC) {
		Company *c = Company::GetIfValid(company);
		uint num_pieces = (tiles + 2) * TUNNELBRIDGE_TRACKBIT_FACTOR;
		if (transport_type == TRANSPORT_RAIL) {
			if (c != nullptr) c->infrastructure.rail[railtype] += num_pieces;
			MakeRailTunnel(start_tile, company, direction,                 railtype);
			MakeRailTunnel(end_tile,   company, ReverseDiagDir(direction), railtype);
			AddSideToSignalBuffer(start_tile, INVALID_DIAGDIR, company);
			YapfNotifyTrackLayoutChange(start_tile, DiagDirToDiagTrack(direction));
		} else {
			if (c != nullptr) c->infrastructure.road[roadtype] += num_pieces * 2; // A full diagonal road has two road bits.
			RoadType road_rt = RoadTypeIsRoad(roadtype) ? roadtype : INVALID_ROADTYPE;
			RoadType tram_rt = RoadTypeIsTram(roadtype) ? roadtype : INVALID_ROADTYPE;
			MakeRoadTunnel(start_tile, company, direction,                 road_rt, tram_rt);
			MakeRoadTunnel(end_tile,   company, ReverseDiagDir(direction), road_rt, tram_rt);
		}
		DirtyCompanyInfrastructureWindows(company);
	}

	return cost;
}


/**
 * Are we allowed to remove the tunnel or bridge at \a tile?
 * @param tile End point of the tunnel or bridge.
 * @return A succeeded command if the tunnel or bridge may be removed, a failed command otherwise.
 */
static inline CommandCost CheckAllowRemoveTunnelBridge(TileIndex tile)
{
	/* Floods can remove anything as well as the scenario editor */
	if (_current_company == OWNER_WATER || _game_mode == GM_EDITOR) return CommandCost();

	switch (GetTunnelBridgeTransportType(tile)) {
		case TRANSPORT_ROAD: {
			RoadType road_rt = GetRoadTypeRoad(tile);
			RoadType tram_rt = GetRoadTypeTram(tile);
			Owner road_owner = _current_company;
			Owner tram_owner = _current_company;

			if (road_rt != INVALID_ROADTYPE) road_owner = GetRoadOwner(tile, RTT_ROAD);
			if (tram_rt != INVALID_ROADTYPE) tram_owner = GetRoadOwner(tile, RTT_TRAM);

			/* We can remove unowned road and if the town allows it */
			if (road_owner == OWNER_TOWN && _current_company != OWNER_TOWN && !(_settings_game.construction.extra_dynamite || _cheats.magic_bulldozer.value)) {
				/* Town does not allow */
				return CheckTileOwnership(tile);
			}
			if (road_owner == OWNER_NONE || road_owner == OWNER_TOWN) road_owner = _current_company;
			if (tram_owner == OWNER_NONE) tram_owner = _current_company;

			CommandCost ret = CheckOwnership(road_owner, tile);
			if (ret.Succeeded()) ret = CheckOwnership(tram_owner, tile);
			return ret;
		}

		case TRANSPORT_RAIL:
			return CheckOwnership(GetTileOwner(tile));

		case TRANSPORT_WATER: {
			/* Always allow to remove aqueducts without owner. */
			Owner aqueduct_owner = GetTileOwner(tile);
			if (aqueduct_owner == OWNER_NONE) aqueduct_owner = _current_company;
			return CheckOwnership(aqueduct_owner);
		}

		default: NOT_REACHED();
	}
}

/**
 * Remove a tunnel from the game, update town rating, etc.
 * @param tile Tile containing one of the endpoints of the tunnel.
 * @param flags Command flags.
 * @return Succeeded or failed command.
 */
static CommandCost DoClearTunnel(TileIndex tile, DoCommandFlag flags)
{
	CommandCost ret = CheckAllowRemoveTunnelBridge(tile);
	if (ret.Failed()) return ret;

	TileIndex endtile = GetOtherTunnelEnd(tile);

	ret = TunnelBridgeIsFree(tile, endtile);
	if (ret.Failed()) return ret;

	_build_tunnel_endtile = endtile;

	Town *t = nullptr;
	if (IsTileOwner(tile, OWNER_TOWN) && _game_mode != GM_EDITOR) {
		t = ClosestTownFromTile(tile, UINT_MAX); // town penalty rating

		/* Check if you are allowed to remove the tunnel owned by a town
		 * Removal depends on difficulty settings */
		ret = CheckforTownRating(flags, t, TUNNELBRIDGE_REMOVE);
		if (ret.Failed()) return ret;
	}

	/* checks if the owner is town then decrease town rating by RATING_TUNNEL_BRIDGE_DOWN_STEP until
	 * you have a "Poor" (0) town rating */
	if (IsTileOwner(tile, OWNER_TOWN) && _game_mode != GM_EDITOR) {
		ChangeTownRating(t, RATING_TUNNEL_BRIDGE_DOWN_STEP, RATING_TUNNEL_BRIDGE_MINIMUM, flags);
	}

	Money base_cost = TunnelBridgeClearCost(tile, PR_CLEAR_TUNNEL);
	uint len = GetTunnelBridgeLength(tile, endtile) + 2; // Don't forget the end tiles.

	if (flags & DC_EXEC) {
		if (GetTunnelBridgeTransportType(tile) == TRANSPORT_RAIL) {
			/* We first need to request values before calling DoClearSquare */
			DiagDirection dir = GetTunnelBridgeDirection(tile);
			Track track = DiagDirToDiagTrack(dir);
			Owner owner = GetTileOwner(tile);

			Train *v = nullptr;
			if (HasTunnelBridgeReservation(tile)) {
				v = GetTrainForReservation(tile, track);
				if (v != nullptr) FreeTrainTrackReservation(v);
			}

			if (Company::IsValidID(owner)) {
				Company::Get(owner)->infrastructure.rail[GetRailType(tile)] -= len * TUNNELBRIDGE_TRACKBIT_FACTOR;
				DirtyCompanyInfrastructureWindows(owner);
			}

			DoClearSquare(tile);
			DoClearSquare(endtile);

			/* cannot use INVALID_DIAGDIR for signal update because the tunnel doesn't exist anymore */
			AddSideToSignalBuffer(tile,    ReverseDiagDir(dir), owner);
			AddSideToSignalBuffer(endtile, dir,                 owner);

			YapfNotifyTrackLayoutChange(tile,    track);
			YapfNotifyTrackLayoutChange(endtile, track);

			if (v != nullptr) TryPathReserve(v);
		} else {
			/* A full diagonal road tile has two road bits. */
			UpdateCompanyRoadInfrastructure(GetRoadTypeRoad(tile), GetRoadOwner(tile, RTT_ROAD), -(int)(len * 2 * TUNNELBRIDGE_TRACKBIT_FACTOR));
			UpdateCompanyRoadInfrastructure(GetRoadTypeTram(tile), GetRoadOwner(tile, RTT_TRAM), -(int)(len * 2 * TUNNELBRIDGE_TRACKBIT_FACTOR));

			DoClearSquare(tile);
			DoClearSquare(endtile);
		}
	}

	return CommandCost(EXPENSES_CONSTRUCTION, len * base_cost);
}


/**
 * Remove a bridge from the game, update town rating, etc.
 * @param tile Tile containing one of the endpoints of the bridge.
 * @param flags Command flags.
 * @return Succeeded or failed command.
 */
static CommandCost DoClearBridge(TileIndex tile, DoCommandFlag flags)
{
	CommandCost ret = CheckAllowRemoveTunnelBridge(tile);
	if (ret.Failed()) return ret;

	TileIndex endtile = GetOtherBridgeEnd(tile);

	ret = TunnelBridgeIsFree(tile, endtile);
	if (ret.Failed()) return ret;

	DiagDirection direction = GetTunnelBridgeDirection(tile);
	TileIndexDiff delta = TileOffsByDiagDir(direction);

	Town *t = nullptr;
	if (IsTileOwner(tile, OWNER_TOWN) && _game_mode != GM_EDITOR) {
		t = ClosestTownFromTile(tile, UINT_MAX); // town penalty rating

		/* Check if you are allowed to remove the bridge owned by a town
		 * Removal depends on difficulty settings */
		ret = CheckforTownRating(flags, t, TUNNELBRIDGE_REMOVE);
		if (ret.Failed()) return ret;
	}

	/* checks if the owner is town then decrease town rating by RATING_TUNNEL_BRIDGE_DOWN_STEP until
	 * you have a "Poor" (0) town rating */
	if (IsTileOwner(tile, OWNER_TOWN) && _game_mode != GM_EDITOR) {
		ChangeTownRating(t, RATING_TUNNEL_BRIDGE_DOWN_STEP, RATING_TUNNEL_BRIDGE_MINIMUM, flags);
	}

	Money base_cost = TunnelBridgeClearCost(tile, PR_CLEAR_BRIDGE);
	uint len = GetTunnelBridgeLength(tile, endtile) + 2; // Don't forget the end tiles.

	if (flags & DC_EXEC) {
		/* read this value before actual removal of bridge */
		bool rail = GetTunnelBridgeTransportType(tile) == TRANSPORT_RAIL;
		Owner owner = GetTileOwner(tile);
		int height = GetBridgeHeight(tile);
		Train *v = nullptr;

		if (rail && HasTunnelBridgeReservation(tile)) {
			v = GetTrainForReservation(tile, DiagDirToDiagTrack(direction));
			if (v != nullptr) FreeTrainTrackReservation(v);
		}

		/* Update company infrastructure counts. */
		if (rail) {
			if (Company::IsValidID(owner)) Company::Get(owner)->infrastructure.rail[GetRailType(tile)] -= len * TUNNELBRIDGE_TRACKBIT_FACTOR;
		} else if (GetTunnelBridgeTransportType(tile) == TRANSPORT_ROAD) {
			/* A full diagonal road tile has two road bits. */
			UpdateCompanyRoadInfrastructure(GetRoadTypeRoad(tile), GetRoadOwner(tile, RTT_ROAD), -(int)(len * 2 * TUNNELBRIDGE_TRACKBIT_FACTOR));
			UpdateCompanyRoadInfrastructure(GetRoadTypeTram(tile), GetRoadOwner(tile, RTT_TRAM), -(int)(len * 2 * TUNNELBRIDGE_TRACKBIT_FACTOR));
		} else { // Aqueduct
			if (Company::IsValidID(owner)) Company::Get(owner)->infrastructure.water -= len * TUNNELBRIDGE_TRACKBIT_FACTOR;
		}
		DirtyCompanyInfrastructureWindows(owner);

		DoClearSquare(tile);
		DoClearSquare(endtile);

		for (TileIndex c = tile + delta; c != endtile; c += delta) {
			/* do not let trees appear from 'nowhere' after removing bridge */
			if (IsNormalRoadTile(c) && GetRoadside(c) == ROADSIDE_TREES) {
				int minz = GetTileMaxZ(c) + 3;
				if (height < minz) SetRoadside(c, ROADSIDE_PAVED);
			}
			ClearBridgeMiddle(c);
			MarkTileDirtyByTile(c, height - TileHeight(c));
		}

		if (rail) {
			/* cannot use INVALID_DIAGDIR for signal update because the bridge doesn't exist anymore */
			AddSideToSignalBuffer(tile,    ReverseDiagDir(direction), owner);
			AddSideToSignalBuffer(endtile, direction,                 owner);

			Track track = DiagDirToDiagTrack(direction);
			YapfNotifyTrackLayoutChange(tile,    track);
			YapfNotifyTrackLayoutChange(endtile, track);

			if (v != nullptr) TryPathReserve(v, true);
		}
	}

	return CommandCost(EXPENSES_CONSTRUCTION, len * base_cost);
}

/**
 * Remove a tunnel or a bridge from the game.
 * @param tile Tile containing one of the endpoints.
 * @param flags Command flags.
 * @return Succeeded or failed command.
 */
static CommandCost ClearTile_TunnelBridge(TileIndex tile, DoCommandFlag flags)
{
	if (IsTunnel(tile)) {
		if (flags & DC_AUTO) return_cmd_error(STR_ERROR_MUST_DEMOLISH_TUNNEL_FIRST);
		return DoClearTunnel(tile, flags);
	} else { // IsBridge(tile)
		if (flags & DC_AUTO) return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);
		return DoClearBridge(tile, flags);
	}
}

/**
 * Draw a single pillar sprite.
 * @param psid      Pillarsprite
 * @param x         Pillar X
 * @param y         Pillar Y
 * @param z         Pillar Z
 * @param w         Bounding box size in X direction
 * @param h         Bounding box size in Y direction
 * @param subsprite Optional subsprite for drawing halfpillars
 */
static inline void DrawPillar(const PalSpriteID *psid, int x, int y, int z, int w, int h, const SubSprite *subsprite)
{
	static const int PILLAR_Z_OFFSET = TILE_HEIGHT - BRIDGE_Z_START; ///< Start offset of pillar wrt. bridge (downwards)
	AddSortableSpriteToDraw(psid->sprite, psid->pal, x, y, w, h, BB_HEIGHT_UNDER_BRIDGE - PILLAR_Z_OFFSET, z, IsTransparencySet(TO_BRIDGES), 0, 0, -PILLAR_Z_OFFSET, subsprite);
}

/**
 * Draw two bridge pillars (north and south).
 * @param z_bottom Bottom Z
 * @param z_top    Top Z
 * @param psid     Pillarsprite
 * @param x        Pillar X
 * @param y        Pillar Y
 * @param w        Bounding box size in X direction
 * @param h        Bounding box size in Y direction
 * @return Reached Z at the bottom
 */
static int DrawPillarColumn(int z_bottom, int z_top, const PalSpriteID *psid, int x, int y, int w, int h)
{
	int cur_z;
	for (cur_z = z_top; cur_z >= z_bottom; cur_z -= TILE_HEIGHT) {
		DrawPillar(psid, x, y, cur_z, w, h, nullptr);
	}
	return cur_z;
}

/**
 * Draws the pillars under high bridges.
 *
 * @param psid Image and palette of a bridge pillar.
 * @param ti #TileInfo of current bridge-middle-tile.
 * @param axis Orientation of bridge.
 * @param drawfarpillar Whether to draw the pillar at the back
 * @param x Sprite X position of front pillar.
 * @param y Sprite Y position of front pillar.
 * @param z_bridge Absolute height of bridge bottom.
 */
static void DrawBridgePillars(const PalSpriteID *psid, const TileInfo *ti, Axis axis, bool drawfarpillar, int x, int y, int z_bridge)
{
	static const int bounding_box_size[2]  = {16, 2}; ///< bounding box size of pillars along bridge direction
	static const int back_pillar_offset[2] = { 0, 9}; ///< sprite position offset of back facing pillar

	static const int INF = 1000; ///< big number compared to sprite size
	static const SubSprite half_pillar_sub_sprite[2][2] = {
		{ {  -14, -INF, INF, INF }, { -INF, -INF, -15, INF } }, // X axis, north and south
		{ { -INF, -INF,  15, INF }, {   16, -INF, INF, INF } }, // Y axis, north and south
	};

	if (psid->sprite == 0) return;

	/* Determine ground height under pillars */
	DiagDirection south_dir = AxisToDiagDir(axis);
	int z_front_north = ti->z;
	int z_back_north = ti->z;
	int z_front_south = ti->z;
	int z_back_south = ti->z;
	GetSlopePixelZOnEdge(ti->tileh, south_dir, &z_front_south, &z_back_south);
	GetSlopePixelZOnEdge(ti->tileh, ReverseDiagDir(south_dir), &z_front_north, &z_back_north);

	/* Shared height of pillars */
	int z_front = std::max(z_front_north, z_front_south);
	int z_back = std::max(z_back_north, z_back_south);

	/* x and y size of bounding-box of pillars */
	int w = bounding_box_size[axis];
	int h = bounding_box_size[OtherAxis(axis)];
	/* sprite position of back facing pillar */
	int x_back = x - back_pillar_offset[axis];
	int y_back = y - back_pillar_offset[OtherAxis(axis)];

	/* Draw front pillars */
	int bottom_z = DrawPillarColumn(z_front, z_bridge, psid, x, y, w, h);
	if (z_front_north < z_front) DrawPillar(psid, x, y, bottom_z, w, h, &half_pillar_sub_sprite[axis][0]);
	if (z_front_south < z_front) DrawPillar(psid, x, y, bottom_z, w, h, &half_pillar_sub_sprite[axis][1]);

	/* Draw back pillars, skip top two parts, which are hidden by the bridge */
	int z_bridge_back = z_bridge - 2 * (int)TILE_HEIGHT;
	if (drawfarpillar && (z_back_north <= z_bridge_back || z_back_south <= z_bridge_back)) {
		bottom_z = DrawPillarColumn(z_back, z_bridge_back, psid, x_back, y_back, w, h);
		if (z_back_north < z_back) DrawPillar(psid, x_back, y_back, bottom_z, w, h, &half_pillar_sub_sprite[axis][0]);
		if (z_back_south < z_back) DrawPillar(psid, x_back, y_back, bottom_z, w, h, &half_pillar_sub_sprite[axis][1]);
	}
}

/**
 * Retrieve the sprites required for catenary on a road/tram bridge.
 * @param rti              RoadTypeInfo for the road or tram type to get catenary for
 * @param head_tile        Bridge head tile with roadtype information
 * @param offset           Sprite offset identifying flat to sloped bridge tiles
 * @param head             Are we drawing bridge head?
 * @param[out] spr_back    Back catenary sprite to use
 * @param[out] spr_front   Front catenary sprite to use
 */
static void GetBridgeRoadCatenary(const RoadTypeInfo *rti, TileIndex head_tile, int offset, bool head, SpriteID &spr_back, SpriteID &spr_front)
{
	static const SpriteID back_offsets[6]  = { 95,  96,  99, 102, 100, 101 };
	static const SpriteID front_offsets[6] = { 97,  98, 103, 106, 104, 105 };

	/* Simplified from DrawRoadTypeCatenary() to remove all the special cases required for regular ground road */
	spr_back = GetCustomRoadSprite(rti, head_tile, ROTSG_CATENARY_BACK, head ? TCX_NORMAL : TCX_ON_BRIDGE);
	spr_front = GetCustomRoadSprite(rti, head_tile, ROTSG_CATENARY_FRONT, head ? TCX_NORMAL : TCX_ON_BRIDGE);
	if (spr_back == 0 && spr_front == 0) {
		spr_back = SPR_TRAMWAY_BASE + back_offsets[offset];
		spr_front = SPR_TRAMWAY_BASE + front_offsets[offset];
	} else {
		if (spr_back != 0) spr_back += 23 + offset;
		if (spr_front != 0) spr_front += 23 + offset;
	}
}

/**
 * Draws the road and trambits over an already drawn (lower end) of a bridge.
 * @param head_tile    bridge head tile with roadtype information
 * @param x            the x of the bridge
 * @param y            the y of the bridge
 * @param z            the z of the bridge
 * @param offset       sprite offset identifying flat to sloped bridge tiles
 * @param head         are we drawing bridge head?
 */
static void DrawBridgeRoadBits(TileIndex head_tile, int x, int y, int z, int offset, bool head)
{
	RoadType road_rt = GetRoadTypeRoad(head_tile);
	RoadType tram_rt = GetRoadTypeTram(head_tile);
	const RoadTypeInfo *road_rti = road_rt == INVALID_ROADTYPE ? nullptr : GetRoadTypeInfo(road_rt);
	const RoadTypeInfo *tram_rti = tram_rt == INVALID_ROADTYPE ? nullptr : GetRoadTypeInfo(tram_rt);

	SpriteID seq_back[4] = { 0 };
	bool trans_back[4] = { false };
	SpriteID seq_front[4] = { 0 };
	bool trans_front[4] = { false };

	static const SpriteID overlay_offsets[6] = {   0,   1,  11,  12,  13,  14 };
	if (head || !IsInvisibilitySet(TO_BRIDGES)) {
		/* Road underlay takes precedence over tram */
		trans_back[0] = !head && IsTransparencySet(TO_BRIDGES);
		if (road_rti != nullptr) {
			if (road_rti->UsesOverlay()) {
				seq_back[0] = GetCustomRoadSprite(road_rti, head_tile, ROTSG_BRIDGE, head ? TCX_NORMAL : TCX_ON_BRIDGE) + offset;
			}
		} else if (tram_rti != nullptr) {
			if (tram_rti->UsesOverlay()) {
				seq_back[0] = GetCustomRoadSprite(tram_rti, head_tile, ROTSG_BRIDGE, head ? TCX_NORMAL : TCX_ON_BRIDGE) + offset;
			} else {
				seq_back[0] = SPR_TRAMWAY_BRIDGE + offset;
			}
		}

		/* Draw road overlay */
		trans_back[1] = !head && IsTransparencySet(TO_BRIDGES);
		if (road_rti != nullptr) {
			if (road_rti->UsesOverlay()) {
				seq_back[1] = GetCustomRoadSprite(road_rti, head_tile, ROTSG_OVERLAY, head ? TCX_NORMAL : TCX_ON_BRIDGE);
				if (seq_back[1] != 0) seq_back[1] += overlay_offsets[offset];
			}
		}

		/* Draw tram overlay */
		trans_back[2] = !head && IsTransparencySet(TO_BRIDGES);
		if (tram_rti != nullptr) {
			if (tram_rti->UsesOverlay()) {
				seq_back[2] = GetCustomRoadSprite(tram_rti, head_tile, ROTSG_OVERLAY, head ? TCX_NORMAL : TCX_ON_BRIDGE);
				if (seq_back[2] != 0) seq_back[2] += overlay_offsets[offset];
			} else if (road_rti != nullptr) {
				seq_back[2] = SPR_TRAMWAY_OVERLAY + overlay_offsets[offset];
			}
		}

		/* Road catenary takes precedence over tram */
		trans_back[3] = IsTransparencySet(TO_CATENARY);
		trans_front[0] = IsTransparencySet(TO_CATENARY);
		if (road_rti != nullptr && HasRoadCatenaryDrawn(road_rt)) {
			GetBridgeRoadCatenary(road_rti, head_tile, offset, head, seq_back[3], seq_front[0]);
		} else if (tram_rti != nullptr && HasRoadCatenaryDrawn(tram_rt)) {
			GetBridgeRoadCatenary(tram_rti, head_tile, offset, head, seq_back[3], seq_front[0]);
		}
	}

	static const uint size_x[6] = {  1, 16, 16,  1, 16,  1 };
	static const uint size_y[6] = { 16,  1,  1, 16,  1, 16 };
	static const uint front_bb_offset_x[6] = { 15,  0,  0, 15,  0, 15 };
	static const uint front_bb_offset_y[6] = {  0, 15, 15,  0, 15,  0 };

	/* The sprites under the vehicles are drawn as SpriteCombine. StartSpriteCombine() has already been called
	 * The bounding boxes here are the same as for bridge front/roof */
	for (uint i = 0; i < lengthof(seq_back); ++i) {
		if (seq_back[i] != 0) {
			AddSortableSpriteToDraw(seq_back[i], PAL_NONE,
				x, y, size_x[offset], size_y[offset], 0x28, z,
				trans_back[i]);
		}
	}

	/* Start a new SpriteCombine for the front part */
	EndSpriteCombine();
	StartSpriteCombine();

	for (uint i = 0; i < lengthof(seq_front); ++i) {
		if (seq_front[i] != 0) {
			AddSortableSpriteToDraw(seq_front[i], PAL_NONE,
				x, y, size_x[offset] + front_bb_offset_x[offset], size_y[offset] + front_bb_offset_y[offset], 0x28, z,
				trans_front[i],
				front_bb_offset_x[offset], front_bb_offset_y[offset]);
		}
	}
}

/**
 * Draws a tunnel of bridge tile.
 * For tunnels, this is rather simple, as you only need to draw the entrance.
 * Bridges are a bit more complex. base_offset is where the sprite selection comes into play
 * and it works a bit like a bitmask.<p> For bridge heads:
 * @param ti TileInfo of the structure to draw
 * <ul><li>Bit 0: direction</li>
 * <li>Bit 1: northern or southern heads</li>
 * <li>Bit 2: Set if the bridge head is sloped</li>
 * <li>Bit 3 and more: Railtype Specific subset</li>
 * </ul>
 * Please note that in this code, "roads" are treated as railtype 1, whilst the real railtypes are 0, 2 and 3
 */
static void DrawTile_TunnelBridge(TileInfo *ti)
{
	TransportType transport_type = GetTunnelBridgeTransportType(ti->tile);
	DiagDirection tunnelbridge_direction = GetTunnelBridgeDirection(ti->tile);

	if (IsTunnel(ti->tile)) {
		/* Front view of tunnel bounding boxes:
		 *
		 *   122223  <- BB_Z_SEPARATOR
		 *   1    3
		 *   1    3                1,3 = empty helper BB
		 *   1    3                  2 = SpriteCombine of tunnel-roof and catenary (tram & elrail)
		 *
		 */

		static const int _tunnel_BB[4][12] = {
			/*  tunnnel-roof  |  Z-separator  | tram-catenary
			 * w  h  bb_x bb_y| x   y   w   h |bb_x bb_y w h */
			{  1,  0, -15, -14,  0, 15, 16,  1, 0, 1, 16, 15 }, // NE
			{  0,  1, -14, -15, 15,  0,  1, 16, 1, 0, 15, 16 }, // SE
			{  1,  0, -15, -14,  0, 15, 16,  1, 0, 1, 16, 15 }, // SW
			{  0,  1, -14, -15, 15,  0,  1, 16, 1, 0, 15, 16 }, // NW
		};
		const int *BB_data = _tunnel_BB[tunnelbridge_direction];

		bool catenary = false;

		SpriteID image;
		SpriteID railtype_overlay = 0;
		if (transport_type == TRANSPORT_RAIL) {
			const RailTypeInfo *rti = GetRailTypeInfo(GetRailType(ti->tile));
			image = rti->base_sprites.tunnel;
			if (rti->UsesOverlay()) {
				/* Check if the railtype has custom tunnel portals. */
				railtype_overlay = GetCustomRailSprite(rti, ti->tile, RTSG_TUNNEL_PORTAL);
				if (railtype_overlay != 0) image = SPR_RAILTYPE_TUNNEL_BASE; // Draw blank grass tunnel base.
			}
		} else {
			image = SPR_TUNNEL_ENTRY_REAR_ROAD;
		}

		if (HasTunnelBridgeSnowOrDesert(ti->tile)) image += railtype_overlay != 0 ? 8 : 32;

		image += tunnelbridge_direction * 2;
		DrawGroundSprite(image, PAL_NONE);

		if (transport_type == TRANSPORT_ROAD) {
			RoadType road_rt = GetRoadTypeRoad(ti->tile);
			RoadType tram_rt = GetRoadTypeTram(ti->tile);
			const RoadTypeInfo *road_rti = road_rt == INVALID_ROADTYPE ? nullptr : GetRoadTypeInfo(road_rt);
			const RoadTypeInfo *tram_rti = tram_rt == INVALID_ROADTYPE ? nullptr : GetRoadTypeInfo(tram_rt);
			uint sprite_offset = DiagDirToAxis(tunnelbridge_direction) == AXIS_X ? 1 : 0;
			bool draw_underlay = true;

			/* Road underlay takes precedence over tram */
			if (road_rti != nullptr) {
				if (road_rti->UsesOverlay()) {
					SpriteID ground = GetCustomRoadSprite(road_rti, ti->tile, ROTSG_TUNNEL);
					if (ground != 0) {
						DrawGroundSprite(ground + tunnelbridge_direction, PAL_NONE);
						draw_underlay = false;
					}
				}
			} else {
				if (tram_rti->UsesOverlay()) {
					SpriteID ground = GetCustomRoadSprite(tram_rti, ti->tile, ROTSG_TUNNEL);
					if (ground != 0) {
						DrawGroundSprite(ground + tunnelbridge_direction, PAL_NONE);
						draw_underlay = false;
					}
				}
			}

			DrawRoadOverlays(ti, PAL_NONE, road_rti, tram_rti, sprite_offset, sprite_offset, draw_underlay);

			/* Road catenary takes precedence over tram */
			SpriteID catenary_sprite_base = 0;
			if (road_rti != nullptr && HasRoadCatenaryDrawn(road_rt)) {
				catenary_sprite_base = GetCustomRoadSprite(road_rti, ti->tile, ROTSG_CATENARY_FRONT);
				if (catenary_sprite_base == 0) {
					catenary_sprite_base = SPR_TRAMWAY_TUNNEL_WIRES;
				} else {
					catenary_sprite_base += 19;
				}
			} else if (tram_rti != nullptr && HasRoadCatenaryDrawn(tram_rt)) {
				catenary_sprite_base = GetCustomRoadSprite(tram_rti, ti->tile, ROTSG_CATENARY_FRONT);
				if (catenary_sprite_base == 0) {
					catenary_sprite_base = SPR_TRAMWAY_TUNNEL_WIRES;
				} else {
					catenary_sprite_base += 19;
				}
			}

			if (catenary_sprite_base != 0) {
				catenary = true;
				StartSpriteCombine();
				AddSortableSpriteToDraw(catenary_sprite_base + tunnelbridge_direction, PAL_NONE, ti->x, ti->y, BB_data[10], BB_data[11], TILE_HEIGHT, ti->z, IsTransparencySet(TO_CATENARY), BB_data[8], BB_data[9], BB_Z_SEPARATOR);
			}
		} else {
			const RailTypeInfo *rti = GetRailTypeInfo(GetRailType(ti->tile));
			if (rti->UsesOverlay()) {
				SpriteID surface = GetCustomRailSprite(rti, ti->tile, RTSG_TUNNEL);
				if (surface != 0) DrawGroundSprite(surface + tunnelbridge_direction, PAL_NONE);
			}

			/* PBS debugging, draw reserved tracks darker */
			if (_game_mode != GM_MENU && _settings_client.gui.show_track_reservation && HasTunnelBridgeReservation(ti->tile)) {
				if (rti->UsesOverlay()) {
					SpriteID overlay = GetCustomRailSprite(rti, ti->tile, RTSG_OVERLAY);
					DrawGroundSprite(overlay + RTO_X + DiagDirToAxis(tunnelbridge_direction), PALETTE_CRASH);
				} else {
					DrawGroundSprite(DiagDirToAxis(tunnelbridge_direction) == AXIS_X ? rti->base_sprites.single_x : rti->base_sprites.single_y, PALETTE_CRASH);
				}
			}

			if (HasRailCatenaryDrawn(GetRailType(ti->tile))) {
				/* Maybe draw pylons on the entry side */
				DrawRailCatenary(ti);

				catenary = true;
				StartSpriteCombine();
				/* Draw wire above the ramp */
				DrawRailCatenaryOnTunnel(ti);
			}
		}

		if (railtype_overlay != 0 && !catenary) StartSpriteCombine();

		AddSortableSpriteToDraw(image + 1, PAL_NONE, ti->x + TILE_SIZE - 1, ti->y + TILE_SIZE - 1, BB_data[0], BB_data[1], TILE_HEIGHT, ti->z, false, BB_data[2], BB_data[3], BB_Z_SEPARATOR);
		/* Draw railtype tunnel portal overlay if defined. */
		if (railtype_overlay != 0) AddSortableSpriteToDraw(railtype_overlay + tunnelbridge_direction, PAL_NONE, ti->x + TILE_SIZE - 1, ti->y + TILE_SIZE - 1, BB_data[0], BB_data[1], TILE_HEIGHT, ti->z, false, BB_data[2], BB_data[3], BB_Z_SEPARATOR);

		if (catenary || railtype_overlay != 0) EndSpriteCombine();

		/* Add helper BB for sprite sorting that separates the tunnel from things beside of it. */
		AddSortableSpriteToDraw(SPR_EMPTY_BOUNDING_BOX, PAL_NONE, ti->x,              ti->y,              BB_data[6], BB_data[7], TILE_HEIGHT, ti->z);
		AddSortableSpriteToDraw(SPR_EMPTY_BOUNDING_BOX, PAL_NONE, ti->x + BB_data[4], ti->y + BB_data[5], BB_data[6], BB_data[7], TILE_HEIGHT, ti->z);

		DrawBridgeMiddle(ti);
	} else { // IsBridge(ti->tile)
		const PalSpriteID *psid;
		int base_offset;
		bool ice = HasTunnelBridgeSnowOrDesert(ti->tile);

		if (transport_type == TRANSPORT_RAIL) {
			base_offset = GetRailTypeInfo(GetRailType(ti->tile))->bridge_offset;
			assert(base_offset != 8); // This one is used for roads
		} else {
			base_offset = 8;
		}

		/* as the lower 3 bits are used for other stuff, make sure they are clear */
		assert( (base_offset & 0x07) == 0x00);

		DrawFoundation(ti, GetBridgeFoundation(ti->tileh, DiagDirToAxis(tunnelbridge_direction)));

		/* HACK Wizardry to convert the bridge ramp direction into a sprite offset */
		base_offset += (6 - tunnelbridge_direction) % 4;

		/* Table number BRIDGE_PIECE_HEAD always refers to the bridge heads for any bridge type */
		if (transport_type != TRANSPORT_WATER) {
			if (ti->tileh == SLOPE_FLAT) base_offset += 4; // sloped bridge head
			psid = &GetBridgeSpriteTable(GetBridgeType(ti->tile), BRIDGE_PIECE_HEAD)[base_offset];
		} else {
			psid = _aqueduct_sprites + base_offset;
		}

		if (!ice) {
			TileIndex next = ti->tile + TileOffsByDiagDir(tunnelbridge_direction);
			if (ti->tileh != SLOPE_FLAT && ti->z == 0 && HasTileWaterClass(next) && GetWaterClass(next) == WATER_CLASS_SEA) {
				DrawShoreTile(ti->tileh);
			} else {
				DrawClearLandTile(ti, 3);
			}
		} else {
			DrawGroundSprite(SPR_FLAT_SNOW_DESERT_TILE + SlopeToSpriteOffset(ti->tileh), PAL_NONE);
		}

		/* draw ramp */

		/* Draw Trambits and PBS Reservation as SpriteCombine */
		if (transport_type == TRANSPORT_ROAD || transport_type == TRANSPORT_RAIL) StartSpriteCombine();

		/* HACK set the height of the BB of a sloped ramp to 1 so a vehicle on
		 * it doesn't disappear behind it
		 */
		/* Bridge heads are drawn solid no matter how invisibility/transparency is set */
		AddSortableSpriteToDraw(psid->sprite, psid->pal, ti->x, ti->y, 16, 16, ti->tileh == SLOPE_FLAT ? 0 : 8, ti->z);

		if (transport_type == TRANSPORT_ROAD) {
			uint offset = tunnelbridge_direction;
			int z = ti->z;
			if (ti->tileh != SLOPE_FLAT) {
				offset = (offset + 1) & 1;
				z += TILE_HEIGHT;
			} else {
				offset += 2;
			}

			/* DrawBridgeRoadBits() calls EndSpriteCombine() and StartSpriteCombine() */
			DrawBridgeRoadBits(ti->tile, ti->x, ti->y, z, offset, true);

			EndSpriteCombine();
		} else if (transport_type == TRANSPORT_RAIL) {
			const RailTypeInfo *rti = GetRailTypeInfo(GetRailType(ti->tile));
			if (rti->UsesOverlay()) {
				SpriteID surface = GetCustomRailSprite(rti, ti->tile, RTSG_BRIDGE);
				if (surface != 0) {
					if (HasBridgeFlatRamp(ti->tileh, DiagDirToAxis(tunnelbridge_direction))) {
						AddSortableSpriteToDraw(surface + ((DiagDirToAxis(tunnelbridge_direction) == AXIS_X) ? RTBO_X : RTBO_Y), PAL_NONE, ti->x, ti->y, 16, 16, 0, ti->z + 8);
					} else {
						AddSortableSpriteToDraw(surface + RTBO_SLOPE + tunnelbridge_direction, PAL_NONE, ti->x, ti->y, 16, 16, 8, ti->z);
					}
				}
				/* Don't fallback to non-overlay sprite -- the spec states that
				 * if an overlay is present then the bridge surface must be
				 * present. */
			}

			/* PBS debugging, draw reserved tracks darker */
			if (_game_mode != GM_MENU && _settings_client.gui.show_track_reservation && HasTunnelBridgeReservation(ti->tile)) {
				if (rti->UsesOverlay()) {
					SpriteID overlay = GetCustomRailSprite(rti, ti->tile, RTSG_OVERLAY);
					if (HasBridgeFlatRamp(ti->tileh, DiagDirToAxis(tunnelbridge_direction))) {
						AddSortableSpriteToDraw(overlay + RTO_X + DiagDirToAxis(tunnelbridge_direction), PALETTE_CRASH, ti->x, ti->y, 16, 16, 0, ti->z + 8);
					} else {
						AddSortableSpriteToDraw(overlay + RTO_SLOPE_NE + tunnelbridge_direction, PALETTE_CRASH, ti->x, ti->y, 16, 16, 8, ti->z);
					}
				} else {
					if (HasBridgeFlatRamp(ti->tileh, DiagDirToAxis(tunnelbridge_direction))) {
						AddSortableSpriteToDraw(DiagDirToAxis(tunnelbridge_direction) == AXIS_X ? rti->base_sprites.single_x : rti->base_sprites.single_y, PALETTE_CRASH, ti->x, ti->y, 16, 16, 0, ti->z + 8);
					} else {
						AddSortableSpriteToDraw(rti->base_sprites.single_sloped + tunnelbridge_direction, PALETTE_CRASH, ti->x, ti->y, 16, 16, 8, ti->z);
					}
				}
			}

			EndSpriteCombine();
			if (HasRailCatenaryDrawn(GetRailType(ti->tile))) {
				DrawRailCatenary(ti);
			}
		}

		DrawBridgeMiddle(ti);
	}
}


/**
 * Compute bridge piece. Computes the bridge piece to display depending on the position inside the bridge.
 * bridges pieces sequence (middle parts).
 * Note that it is not covering the bridge heads, which are always referenced by the same sprite table.
 * bridge len 1: BRIDGE_PIECE_NORTH
 * bridge len 2: BRIDGE_PIECE_NORTH  BRIDGE_PIECE_SOUTH
 * bridge len 3: BRIDGE_PIECE_NORTH  BRIDGE_PIECE_MIDDLE_ODD   BRIDGE_PIECE_SOUTH
 * bridge len 4: BRIDGE_PIECE_NORTH  BRIDGE_PIECE_INNER_NORTH  BRIDGE_PIECE_INNER_SOUTH  BRIDGE_PIECE_SOUTH
 * bridge len 5: BRIDGE_PIECE_NORTH  BRIDGE_PIECE_INNER_NORTH  BRIDGE_PIECE_MIDDLE_EVEN  BRIDGE_PIECE_INNER_SOUTH  BRIDGE_PIECE_SOUTH
 * bridge len 6: BRIDGE_PIECE_NORTH  BRIDGE_PIECE_INNER_NORTH  BRIDGE_PIECE_INNER_SOUTH  BRIDGE_PIECE_INNER_NORTH  BRIDGE_PIECE_INNER_SOUTH  BRIDGE_PIECE_SOUTH
 * bridge len 7: BRIDGE_PIECE_NORTH  BRIDGE_PIECE_INNER_NORTH  BRIDGE_PIECE_INNER_SOUTH  BRIDGE_PIECE_MIDDLE_ODD   BRIDGE_PIECE_INNER_NORTH  BRIDGE_PIECE_INNER_SOUTH  BRIDGE_PIECE_SOUTH
 * #0 - always as first, #1 - always as last (if len>1)
 * #2,#3 are to pair in order
 * for odd bridges: #5 is going in the bridge middle if on even position, #4 on odd (counting from 0)
 * @param north Northernmost tile of bridge
 * @param south Southernmost tile of bridge
 * @return Index of bridge piece
 */
static BridgePieces CalcBridgePiece(uint north, uint south)
{
	if (north == 1) {
		return BRIDGE_PIECE_NORTH;
	} else if (south == 1) {
		return BRIDGE_PIECE_SOUTH;
	} else if (north < south) {
		return north & 1 ? BRIDGE_PIECE_INNER_SOUTH : BRIDGE_PIECE_INNER_NORTH;
	} else if (north > south) {
		return south & 1 ? BRIDGE_PIECE_INNER_NORTH : BRIDGE_PIECE_INNER_SOUTH;
	} else {
		return north & 1 ? BRIDGE_PIECE_MIDDLE_EVEN : BRIDGE_PIECE_MIDDLE_ODD;
	}
}

/**
 * Draw the middle bits of a bridge.
 * @param ti Tile information of the tile to draw it on.
 */
void DrawBridgeMiddle(const TileInfo *ti)
{
	/* Sectional view of bridge bounding boxes:
	 *
	 *  1           2                                1,2 = SpriteCombine of Bridge front/(back&floor) and RoadCatenary
	 *  1           2                                  3 = empty helper BB
	 *  1     7     2                                4,5 = pillars under higher bridges
	 *  1 6 88888 6 2                                  6 = elrail-pylons
	 *  1 6 88888 6 2                                  7 = elrail-wire
	 *  1 6 88888 6 2  <- TILE_HEIGHT                  8 = rail-vehicle on bridge
	 *  3333333333333  <- BB_Z_SEPARATOR
	 *                 <- unused
	 *    4       5    <- BB_HEIGHT_UNDER_BRIDGE
	 *    4       5
	 *    4       5
	 *
	 */

	if (!IsBridgeAbove(ti->tile)) return;

	TileIndex rampnorth = GetNorthernBridgeEnd(ti->tile);
	TileIndex rampsouth = GetSouthernBridgeEnd(ti->tile);
	TransportType transport_type = GetTunnelBridgeTransportType(rampsouth);

	Axis axis = GetBridgeAxis(ti->tile);
	BridgePieces piece = CalcBridgePiece(
		GetTunnelBridgeLength(ti->tile, rampnorth) + 1,
		GetTunnelBridgeLength(ti->tile, rampsouth) + 1
	);

	const PalSpriteID *psid;
	bool drawfarpillar;
	if (transport_type != TRANSPORT_WATER) {
		BridgeType type =  GetBridgeType(rampsouth);
		drawfarpillar = !HasBit(GetBridgeSpec(type)->flags, 0);

		uint base_offset;
		if (transport_type == TRANSPORT_RAIL) {
			base_offset = GetRailTypeInfo(GetRailType(rampsouth))->bridge_offset;
		} else {
			base_offset = 8;
		}

		psid = base_offset + GetBridgeSpriteTable(type, piece);
	} else {
		drawfarpillar = true;
		psid = _aqueduct_sprites;
	}

	if (axis != AXIS_X) psid += 4;

	int x = ti->x;
	int y = ti->y;
	uint bridge_z = GetBridgePixelHeight(rampsouth);
	int z = bridge_z - BRIDGE_Z_START;

	/* Add a bounding box that separates the bridge from things below it. */
	AddSortableSpriteToDraw(SPR_EMPTY_BOUNDING_BOX, PAL_NONE, x, y, 16, 16, 1, bridge_z - TILE_HEIGHT + BB_Z_SEPARATOR);

	/* Draw Trambits as SpriteCombine */
	if (transport_type == TRANSPORT_ROAD || transport_type == TRANSPORT_RAIL) StartSpriteCombine();

	/* Draw floor and far part of bridge*/
	if (!IsInvisibilitySet(TO_BRIDGES)) {
		if (axis == AXIS_X) {
			AddSortableSpriteToDraw(psid->sprite, psid->pal, x, y, 16, 1, 0x28, z, IsTransparencySet(TO_BRIDGES), 0, 0, BRIDGE_Z_START);
		} else {
			AddSortableSpriteToDraw(psid->sprite, psid->pal, x, y, 1, 16, 0x28, z, IsTransparencySet(TO_BRIDGES), 0, 0, BRIDGE_Z_START);
		}
	}

	psid++;

	if (transport_type == TRANSPORT_ROAD) {
		/* DrawBridgeRoadBits() calls EndSpriteCombine() and StartSpriteCombine() */
		DrawBridgeRoadBits(rampsouth, x, y, bridge_z, axis ^ 1, false);
	} else if (transport_type == TRANSPORT_RAIL) {
		const RailTypeInfo *rti = GetRailTypeInfo(GetRailType(rampsouth));
		if (rti->UsesOverlay() && !IsInvisibilitySet(TO_BRIDGES)) {
			SpriteID surface = GetCustomRailSprite(rti, rampsouth, RTSG_BRIDGE, TCX_ON_BRIDGE);
			if (surface != 0) {
				AddSortableSpriteToDraw(surface + axis, PAL_NONE, x, y, 16, 16, 0, bridge_z, IsTransparencySet(TO_BRIDGES));
			}
		}

		if (_game_mode != GM_MENU && _settings_client.gui.show_track_reservation && !IsInvisibilitySet(TO_BRIDGES) && HasTunnelBridgeReservation(rampnorth)) {
			if (rti->UsesOverlay()) {
				SpriteID overlay = GetCustomRailSprite(rti, ti->tile, RTSG_OVERLAY);
				AddSortableSpriteToDraw(overlay + RTO_X + axis, PALETTE_CRASH, ti->x, ti->y, 16, 16, 0, bridge_z, IsTransparencySet(TO_BRIDGES));
			} else {
				AddSortableSpriteToDraw(axis == AXIS_X ? rti->base_sprites.single_x : rti->base_sprites.single_y, PALETTE_CRASH, ti->x, ti->y, 16, 16, 0, bridge_z, IsTransparencySet(TO_BRIDGES));
			}
		}

		EndSpriteCombine();

		if (HasRailCatenaryDrawn(GetRailType(rampsouth))) {
			DrawRailCatenaryOnBridge(ti);
		}
	}

	/* draw roof, the component of the bridge which is logically between the vehicle and the camera */
	if (!IsInvisibilitySet(TO_BRIDGES)) {
		if (axis == AXIS_X) {
			y += 12;
			if (psid->sprite & SPRITE_MASK) AddSortableSpriteToDraw(psid->sprite, psid->pal, x, y, 16, 4, 0x28, z, IsTransparencySet(TO_BRIDGES), 0, 3, BRIDGE_Z_START);
		} else {
			x += 12;
			if (psid->sprite & SPRITE_MASK) AddSortableSpriteToDraw(psid->sprite, psid->pal, x, y, 4, 16, 0x28, z, IsTransparencySet(TO_BRIDGES), 3, 0, BRIDGE_Z_START);
		}
	}

	/* Draw TramFront as SpriteCombine */
	if (transport_type == TRANSPORT_ROAD) EndSpriteCombine();

	/* Do not draw anything more if bridges are invisible */
	if (IsInvisibilitySet(TO_BRIDGES)) return;

	psid++;
	DrawBridgePillars(psid, ti, axis, drawfarpillar, x, y, z);
}


static int GetSlopePixelZ_TunnelBridge(TileIndex tile, uint x, uint y, bool ground_vehicle)
{
	int z;
	Slope tileh = GetTilePixelSlope(tile, &z);

	x &= 0xF;
	y &= 0xF;

	if (IsTunnel(tile)) {
		/* In the tunnel entrance? */
		if (ground_vehicle) return z;
	} else { // IsBridge(tile)
		DiagDirection dir = GetTunnelBridgeDirection(tile);
		z += ApplyPixelFoundationToSlope(GetBridgeFoundation(tileh, DiagDirToAxis(dir)), &tileh);

		/* On the bridge ramp? */
		if (ground_vehicle) {
			if (tileh != SLOPE_FLAT) return z + TILE_HEIGHT;

			switch (dir) {
				default: NOT_REACHED();
				case DIAGDIR_NE: tileh = SLOPE_NE; break;
				case DIAGDIR_SE: tileh = SLOPE_SE; break;
				case DIAGDIR_SW: tileh = SLOPE_SW; break;
				case DIAGDIR_NW: tileh = SLOPE_NW; break;
			}
		}
	}

	return z + GetPartialPixelZ(x, y, tileh);
}

static Foundation GetFoundation_TunnelBridge(TileIndex tile, Slope tileh)
{
	return IsTunnel(tile) ? FOUNDATION_NONE : GetBridgeFoundation(tileh, DiagDirToAxis(GetTunnelBridgeDirection(tile)));
}

static void GetTileDesc_TunnelBridge(TileIndex tile, TileDesc *td)
{
	TransportType tt = GetTunnelBridgeTransportType(tile);

	if (IsTunnel(tile)) {
		td->str = (tt == TRANSPORT_RAIL) ? STR_LAI_TUNNEL_DESCRIPTION_RAILROAD : STR_LAI_TUNNEL_DESCRIPTION_ROAD;
	} else { // IsBridge(tile)
		td->str = (tt == TRANSPORT_WATER) ? STR_LAI_BRIDGE_DESCRIPTION_AQUEDUCT : GetBridgeSpec(GetBridgeType(tile))->transport_name[tt];
	}
	td->owner[0] = GetTileOwner(tile);

	Owner road_owner = INVALID_OWNER;
	Owner tram_owner = INVALID_OWNER;
	RoadType road_rt = GetRoadTypeRoad(tile);
	RoadType tram_rt = GetRoadTypeTram(tile);
	if (road_rt != INVALID_ROADTYPE) {
		const RoadTypeInfo *rti = GetRoadTypeInfo(road_rt);
		td->roadtype = rti->strings.name;
		td->road_speed = rti->max_speed / 2;
		road_owner = GetRoadOwner(tile, RTT_ROAD);
	}
	if (tram_rt != INVALID_ROADTYPE) {
		const RoadTypeInfo *rti = GetRoadTypeInfo(tram_rt);
		td->tramtype = rti->strings.name;
		td->tram_speed = rti->max_speed / 2;
		tram_owner = GetRoadOwner(tile, RTT_TRAM);
	}

	/* Is there a mix of owners? */
	if ((tram_owner != INVALID_OWNER && tram_owner != td->owner[0]) ||
			(road_owner != INVALID_OWNER && road_owner != td->owner[0])) {
		uint i = 1;
		if (road_owner != INVALID_OWNER) {
			td->owner_type[i] = STR_LAND_AREA_INFORMATION_ROAD_OWNER;
			td->owner[i] = road_owner;
			i++;
		}
		if (tram_owner != INVALID_OWNER) {
			td->owner_type[i] = STR_LAND_AREA_INFORMATION_TRAM_OWNER;
			td->owner[i] = tram_owner;
		}
	}

	if (tt == TRANSPORT_RAIL) {
		const RailTypeInfo *rti = GetRailTypeInfo(GetRailType(tile));
		td->rail_speed = rti->max_speed;
		td->railtype = rti->strings.name;

		if (!IsTunnel(tile)) {
			uint16_t spd = GetBridgeSpec(GetBridgeType(tile))->speed;
			/* rail speed special-cases 0 as unlimited, hides display of limit etc. */
			if (spd == UINT16_MAX) spd = 0;
			if (td->rail_speed == 0 || spd < td->rail_speed) {
				td->rail_speed = spd;
			}
		}
	} else if (tt == TRANSPORT_ROAD && !IsTunnel(tile)) {
		uint16_t spd = GetBridgeSpec(GetBridgeType(tile))->speed;
		/* road speed special-cases 0 as unlimited, hides display of limit etc. */
		if (spd == UINT16_MAX) spd = 0;
		if (road_rt != INVALID_ROADTYPE && (td->road_speed == 0 || spd < td->road_speed)) td->road_speed = spd;
		if (tram_rt != INVALID_ROADTYPE && (td->tram_speed == 0 || spd < td->tram_speed)) td->tram_speed = spd;
	}
}


static void TileLoop_TunnelBridge(TileIndex tile)
{
	bool snow_or_desert = HasTunnelBridgeSnowOrDesert(tile);
	switch (_settings_game.game_creation.landscape) {
		case LT_ARCTIC: {
			/* As long as we do not have a snow density, we want to use the density
			 * from the entry edge. For tunnels this is the lowest point for bridges the highest point.
			 * (Independent of foundations) */
			int z = IsBridge(tile) ? GetTileMaxZ(tile) : GetTileZ(tile);
			if (snow_or_desert != (z > GetSnowLine())) {
				SetTunnelBridgeSnowOrDesert(tile, !snow_or_desert);
				MarkTileDirtyByTile(tile);
			}
			break;
		}

		case LT_TROPIC:
			if (GetTropicZone(tile) == TROPICZONE_DESERT && !snow_or_desert) {
				SetTunnelBridgeSnowOrDesert(tile, true);
				MarkTileDirtyByTile(tile);
			}
			break;

		default:
			break;
	}
}

static TrackStatus GetTileTrackStatus_TunnelBridge(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
{
	TransportType transport_type = GetTunnelBridgeTransportType(tile);
	if (transport_type != mode || (transport_type == TRANSPORT_ROAD && !HasTileRoadType(tile, (RoadTramType)sub_mode))) return 0;

	DiagDirection dir = GetTunnelBridgeDirection(tile);
	if (side != INVALID_DIAGDIR && side != ReverseDiagDir(dir)) return 0;
	return CombineTrackStatus(TrackBitsToTrackdirBits(DiagDirToDiagTrackBits(dir)), TRACKDIR_BIT_NONE);
}

static void ChangeTileOwner_TunnelBridge(TileIndex tile, Owner old_owner, Owner new_owner)
{
	TileIndex other_end = GetOtherTunnelBridgeEnd(tile);
	/* Set number of pieces to zero if it's the southern tile as we
	 * don't want to update the infrastructure counts twice. */
	uint num_pieces = tile < other_end ? (GetTunnelBridgeLength(tile, other_end) + 2) * TUNNELBRIDGE_TRACKBIT_FACTOR : 0;

	for (RoadTramType rtt : _roadtramtypes) {
		/* Update all roadtypes, no matter if they are present */
		if (GetRoadOwner(tile, rtt) == old_owner) {
			RoadType rt = GetRoadType(tile, rtt);
			if (rt != INVALID_ROADTYPE) {
				/* Update company infrastructure counts. A full diagonal road tile has two road bits.
				 * No need to dirty windows here, we'll redraw the whole screen anyway. */
				Company::Get(old_owner)->infrastructure.road[rt] -= num_pieces * 2;
				if (new_owner != INVALID_OWNER) Company::Get(new_owner)->infrastructure.road[rt] += num_pieces * 2;
			}

			SetRoadOwner(tile, rtt, new_owner == INVALID_OWNER ? OWNER_NONE : new_owner);
		}
	}

	if (!IsTileOwner(tile, old_owner)) return;

	/* Update company infrastructure counts for rail and water as well.
	 * No need to dirty windows here, we'll redraw the whole screen anyway. */
	TransportType tt = GetTunnelBridgeTransportType(tile);
	Company *old = Company::Get(old_owner);
	if (tt == TRANSPORT_RAIL) {
		old->infrastructure.rail[GetRailType(tile)] -= num_pieces;
		if (new_owner != INVALID_OWNER) Company::Get(new_owner)->infrastructure.rail[GetRailType(tile)] += num_pieces;
	} else if (tt == TRANSPORT_WATER) {
		old->infrastructure.water -= num_pieces;
		if (new_owner != INVALID_OWNER) Company::Get(new_owner)->infrastructure.water += num_pieces;
	}

	if (new_owner != INVALID_OWNER) {
		SetTileOwner(tile, new_owner);
	} else {
		if (tt == TRANSPORT_RAIL) {
			/* Since all of our vehicles have been removed, it is safe to remove the rail
			 * bridge / tunnel. */
			[[maybe_unused]] CommandCost ret = Command<CMD_LANDSCAPE_CLEAR>::Do(DC_EXEC | DC_BANKRUPT, tile);
			assert(ret.Succeeded());
		} else {
			/* In any other case, we can safely reassign the ownership to OWNER_NONE. */
			SetTileOwner(tile, OWNER_NONE);
		}
	}
}

/**
 * Helper to prepare the ground vehicle when entering a bridge. This get called
 * when entering the bridge, at the last frame of travel on the bridge head.
 * Our calling function gets called before UpdateInclination/UpdateZPosition,
 * which normally controls the Z-coordinate. However, in the wormhole of the
 * bridge the vehicle is in a strange state so UpdateInclination does not get
 * called for the wormhole of the bridge and as such the going up/down bits
 * would remain set. As such, this function clears those. In doing so, the call
 * to UpdateInclination will not update the Z-coordinate, so that has to be
 * done here as well.
 * @param gv The ground vehicle entering the bridge.
 */
template <typename T>
static void PrepareToEnterBridge(T *gv)
{
	if (HasBit(gv->gv_flags, GVF_GOINGUP_BIT)) {
		gv->z_pos++;
		ClrBit(gv->gv_flags, GVF_GOINGUP_BIT);
	} else {
		ClrBit(gv->gv_flags, GVF_GOINGDOWN_BIT);
	}
}

/**
 * Frame when the 'enter tunnel' sound should be played. This is the second
 * frame on a tile, so the sound is played shortly after entering the tunnel
 * tile, while the vehicle is still visible.
 */
static const byte TUNNEL_SOUND_FRAME = 1;

/**
 * Frame when a vehicle should be hidden in a tunnel with a certain direction.
 * This differs per direction, because of visibility / bounding box issues.
 * Note that direction, in this case, is the direction leading into the tunnel.
 * When entering a tunnel, hide the vehicle when it reaches the given frame.
 * When leaving a tunnel, show the vehicle when it is one frame further
 * to the 'outside', i.e. at (TILE_SIZE-1) - (frame) + 1
 */
extern const byte _tunnel_visibility_frame[DIAGDIR_END] = {12, 8, 8, 12};

static VehicleEnterTileStatus VehicleEnter_TunnelBridge(Vehicle *v, TileIndex tile, int x, int y)
{
	int z = GetSlopePixelZ(x, y, true) - v->z_pos;

	if (abs(z) > 2) return VETSB_CANNOT_ENTER;
	/* Direction into the wormhole */
	const DiagDirection dir = GetTunnelBridgeDirection(tile);
	/* Direction of the vehicle */
	const DiagDirection vdir = DirToDiagDir(v->direction);
	/* New position of the vehicle on the tile */
	byte pos = (DiagDirToAxis(vdir) == AXIS_X ? x : y) & TILE_UNIT_MASK;
	/* Number of units moved by the vehicle since entering the tile */
	byte frame = (vdir == DIAGDIR_NE || vdir == DIAGDIR_NW) ? TILE_SIZE - 1 - pos : pos;

	if (IsTunnel(tile)) {
		if (v->type == VEH_TRAIN) {
			Train *t = Train::From(v);

			if (t->track != TRACK_BIT_WORMHOLE && dir == vdir) {
				if (t->IsFrontEngine() && frame == TUNNEL_SOUND_FRAME) {
					if (!PlayVehicleSound(t, VSE_TUNNEL) && RailVehInfo(t->engine_type)->engclass == 0) {
						SndPlayVehicleFx(SND_05_TRAIN_THROUGH_TUNNEL, v);
					}
					return VETSB_CONTINUE;
				}
				if (frame == _tunnel_visibility_frame[dir]) {
					t->tile = tile;
					t->track = TRACK_BIT_WORMHOLE;
					t->vehstatus |= VS_HIDDEN;
					return VETSB_ENTERED_WORMHOLE;
				}
			}

			if (dir == ReverseDiagDir(vdir) && frame == TILE_SIZE - _tunnel_visibility_frame[dir] && z == 0) {
				/* We're at the tunnel exit ?? */
				t->tile = tile;
				t->track = DiagDirToDiagTrackBits(vdir);
				assert(t->track);
				t->vehstatus &= ~VS_HIDDEN;
				return VETSB_ENTERED_WORMHOLE;
			}
		} else if (v->type == VEH_ROAD) {
			RoadVehicle *rv = RoadVehicle::From(v);

			/* Enter tunnel? */
			if (rv->state != RVSB_WORMHOLE && dir == vdir) {
				if (frame == _tunnel_visibility_frame[dir]) {
					/* Frame should be equal to the next frame number in the RV's movement */
					assert(frame == rv->frame + 1);
					rv->tile = tile;
					rv->state = RVSB_WORMHOLE;
					rv->vehstatus |= VS_HIDDEN;
					return VETSB_ENTERED_WORMHOLE;
				} else {
					return VETSB_CONTINUE;
				}
			}

			/* We're at the tunnel exit ?? */
			if (dir == ReverseDiagDir(vdir) && frame == TILE_SIZE - _tunnel_visibility_frame[dir] && z == 0) {
				rv->tile = tile;
				rv->state = DiagDirToDiagTrackdir(vdir);
				rv->frame = frame;
				rv->vehstatus &= ~VS_HIDDEN;
				return VETSB_ENTERED_WORMHOLE;
			}
		}
	} else { // IsBridge(tile)
		if (v->type != VEH_SHIP) {
			/* modify speed of vehicle */
			uint16_t spd = GetBridgeSpec(GetBridgeType(tile))->speed;

			if (v->type == VEH_ROAD) spd *= 2;
			Vehicle *first = v->First();
			first->cur_speed = std::min(first->cur_speed, spd);
		}

		if (vdir == dir) {
			/* Vehicle enters bridge at the last frame inside this tile. */
			if (frame != TILE_SIZE - 1) return VETSB_CONTINUE;
			switch (v->type) {
				case VEH_TRAIN: {
					Train *t = Train::From(v);
					t->track = TRACK_BIT_WORMHOLE;
					PrepareToEnterBridge(t);
					break;
				}

				case VEH_ROAD: {
					RoadVehicle *rv = RoadVehicle::From(v);
					rv->state = RVSB_WORMHOLE;
					PrepareToEnterBridge(rv);
					break;
				}

				case VEH_SHIP:
					Ship::From(v)->state = TRACK_BIT_WORMHOLE;
					break;

				default: NOT_REACHED();
			}
			return VETSB_ENTERED_WORMHOLE;
		} else if (vdir == ReverseDiagDir(dir)) {
			v->tile = tile;
			switch (v->type) {
				case VEH_TRAIN: {
					Train *t = Train::From(v);
					if (t->track == TRACK_BIT_WORMHOLE) {
						t->track = DiagDirToDiagTrackBits(vdir);
						return VETSB_ENTERED_WORMHOLE;
					}
					break;
				}

				case VEH_ROAD: {
					RoadVehicle *rv = RoadVehicle::From(v);
					if (rv->state == RVSB_WORMHOLE) {
						rv->state = DiagDirToDiagTrackdir(vdir);
						rv->frame = 0;
						return VETSB_ENTERED_WORMHOLE;
					}
					break;
				}

				case VEH_SHIP: {
					Ship *ship = Ship::From(v);
					if (ship->state == TRACK_BIT_WORMHOLE) {
						ship->state = DiagDirToDiagTrackBits(vdir);
						return VETSB_ENTERED_WORMHOLE;
					}
					break;
				}

				default: NOT_REACHED();
			}
		}
	}
	return VETSB_CONTINUE;
}

static CommandCost TerraformTile_TunnelBridge(TileIndex tile, DoCommandFlag flags, int z_new, Slope tileh_new)
{
	if (_settings_game.construction.build_on_slopes && AutoslopeEnabled() && IsBridge(tile) && GetTunnelBridgeTransportType(tile) != TRANSPORT_WATER) {
		DiagDirection direction = GetTunnelBridgeDirection(tile);
		Axis axis = DiagDirToAxis(direction);
		CommandCost res;
		int z_old;
		Slope tileh_old = GetTileSlope(tile, &z_old);

		/* Check if new slope is valid for bridges in general (so we can safely call GetBridgeFoundation()) */
		if ((direction == DIAGDIR_NW) || (direction == DIAGDIR_NE)) {
			CheckBridgeSlope(BRIDGE_PIECE_SOUTH, axis, &tileh_old, &z_old);
			res = CheckBridgeSlope(BRIDGE_PIECE_SOUTH, axis, &tileh_new, &z_new);
		} else {
			CheckBridgeSlope(BRIDGE_PIECE_NORTH, axis, &tileh_old, &z_old);
			res = CheckBridgeSlope(BRIDGE_PIECE_NORTH, axis, &tileh_new, &z_new);
		}

		/* Surface slope is valid and remains unchanged? */
		if (res.Succeeded() && (z_old == z_new) && (tileh_old == tileh_new)) return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_FOUNDATION]);
	}

	return Command<CMD_LANDSCAPE_CLEAR>::Do(flags, tile);
}

extern const TileTypeProcs _tile_type_tunnelbridge_procs = {
	DrawTile_TunnelBridge,           // draw_tile_proc
	GetSlopePixelZ_TunnelBridge,     // get_slope_z_proc
	ClearTile_TunnelBridge,          // clear_tile_proc
	nullptr,                            // add_accepted_cargo_proc
	GetTileDesc_TunnelBridge,        // get_tile_desc_proc
	GetTileTrackStatus_TunnelBridge, // get_tile_track_status_proc
	nullptr,                            // click_tile_proc
	nullptr,                            // animate_tile_proc
	TileLoop_TunnelBridge,           // tile_loop_proc
	ChangeTileOwner_TunnelBridge,    // change_tile_owner_proc
	nullptr,                            // add_produced_cargo_proc
	VehicleEnter_TunnelBridge,       // vehicle_enter_tile_proc
	GetFoundation_TunnelBridge,      // get_foundation_proc
	TerraformTile_TunnelBridge,      // terraform_tile_proc
};