Files @ r19580:3dd5fc9bd797
Branch filter:

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

translators
(svn r24511) -Update from WebTranslator v3.0:
latvian - 3 changes by Parastais
vietnamese - 1 changes by nglekhoi
   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
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
r5584:545d748cc681
r5584:545d748cc681
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r9111:983de9c5a848
r6351:0ad6f06c84a9
r5584:545d748cc681
r10546:a4ec290c1c46
r15027:bb71fdfcc554
r8116:df67d3c5e4fd
r10208:ef8fcc3dc4ca
r8763:c2c776621d56
r8114:866ed489ed98
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8962:cfbdc736c8db
r11967:df0600d2c7e7
r11976:ae6aa97461b7
r12109:90df01928018
r12218:9b04ff1ad183
r12465:c1b760a56db7
r14248:a9050881acd7
r18607:7724313c61c6
r5584:545d748cc681
r8264:d493cb51fe8a
r8264:d493cb51fe8a
r8767:3a0af1ef8ea8
r8767:3a0af1ef8ea8
r8767:3a0af1ef8ea8
r8767:3a0af1ef8ea8
r8767:3a0af1ef8ea8
r8767:3a0af1ef8ea8
r11967:df0600d2c7e7
r11967:df0600d2c7e7
r11967:df0600d2c7e7
r11967:df0600d2c7e7
r8848:6bd9c22eb5ec
r18353:55e21e815cc4
r18353:55e21e815cc4
r18353:55e21e815cc4
r18353:55e21e815cc4
r18353:55e21e815cc4
r18353:55e21e815cc4
r18353:55e21e815cc4
r18353:55e21e815cc4
r18353:55e21e815cc4
r18353:55e21e815cc4
r18353:55e21e815cc4
r18353:55e21e815cc4
r18353:55e21e815cc4
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r8834:3c81f564ad98
r8834:3c81f564ad98
r8834:3c81f564ad98
r8834:3c81f564ad98
r8834:3c81f564ad98
r8834:3c81f564ad98
r8834:3c81f564ad98
r8834:3c81f564ad98
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r8836:911846a8cfa6
r8836:911846a8cfa6
r8836:911846a8cfa6
r8836:911846a8cfa6
r8836:911846a8cfa6
r8836:911846a8cfa6
r8836:911846a8cfa6
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r11804:b557a467d2ad
r8836:911846a8cfa6
r8836:911846a8cfa6
r8853:c56f6dec859b
r10350:e5de21f93a9e
r11804:b557a467d2ad
r8836:911846a8cfa6
r8838:ab02a7e7aabf
r8836:911846a8cfa6
r8836:911846a8cfa6
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r12528:f4d1c0776108
r8836:911846a8cfa6
r8836:911846a8cfa6
r8836:911846a8cfa6
r8836:911846a8cfa6
r8836:911846a8cfa6
r8836:911846a8cfa6
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r8843:e138882e90db
r8836:911846a8cfa6
r8836:911846a8cfa6
r8843:e138882e90db
r8836:911846a8cfa6
r8836:911846a8cfa6
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r8836:911846a8cfa6
r8836:911846a8cfa6
r8836:911846a8cfa6
r8836:911846a8cfa6
r8836:911846a8cfa6
r8836:911846a8cfa6
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r8836:911846a8cfa6
r8836:911846a8cfa6
r8836:911846a8cfa6
r8836:911846a8cfa6
r8836:911846a8cfa6
r8836:911846a8cfa6
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8901:329de9f160db
r8901:329de9f160db
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r17099:f140f6165f35
r17683:ed148d83dec5
r17099:f140f6165f35
r17099:f140f6165f35
r17683:ed148d83dec5
r16897:d3b3d1abd708
r17683:ed148d83dec5
r16897:d3b3d1abd708
r16897:d3b3d1abd708
r16897:d3b3d1abd708
r17099:f140f6165f35
r18241:a4322e3af754
r17099:f140f6165f35
r17099:f140f6165f35
r18241:a4322e3af754
r17099:f140f6165f35
r8838:ab02a7e7aabf
r8838:ab02a7e7aabf
r8838:ab02a7e7aabf
r8838:ab02a7e7aabf
r8838:ab02a7e7aabf
r8838:ab02a7e7aabf
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r8835:86b7d0c27ddf
r8835:86b7d0c27ddf
r10365:bda64136820d
r10365:bda64136820d
r10365:bda64136820d
r10365:bda64136820d
r10365:bda64136820d
r15809:eb2b7fdb724e
r10365:bda64136820d
r10365:bda64136820d
r16537:b136370bd3c2
r16537:b136370bd3c2
r10365:bda64136820d
r10365:bda64136820d
r16537:b136370bd3c2
r8835:86b7d0c27ddf
r8835:86b7d0c27ddf
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r8839:479975d442dd
r8834:3c81f564ad98
r8839:479975d442dd
r8834:3c81f564ad98
r8834:3c81f564ad98
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r8839:479975d442dd
r8834:3c81f564ad98
r8839:479975d442dd
r8839:479975d442dd
r8839:479975d442dd
r8839:479975d442dd
r8839:479975d442dd
r8839:479975d442dd
r8839:479975d442dd
r8839:479975d442dd
r19079:a1a4921bfd39
r8839:479975d442dd
r8839:479975d442dd
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r10184:9c5fe3a1bdab
r5584:545d748cc681
r13024:48c81d0b078a
r10184:9c5fe3a1bdab
r10184:9c5fe3a1bdab
r10184:9c5fe3a1bdab
r10184:9c5fe3a1bdab
r10184:9c5fe3a1bdab
r10184:9c5fe3a1bdab
r10184:9c5fe3a1bdab
r10184:9c5fe3a1bdab
r13024:48c81d0b078a
r13024:48c81d0b078a
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r14126:f23988064e74
r5584:545d748cc681
r17099:f140f6165f35
r5584:545d748cc681
r5584:545d748cc681
r8835:86b7d0c27ddf
r5584:545d748cc681
r8835:86b7d0c27ddf
r8835:86b7d0c27ddf
r8835:86b7d0c27ddf
r5584:545d748cc681
r8835:86b7d0c27ddf
r8835:86b7d0c27ddf
r6980:3b43790d6e21
r8835:86b7d0c27ddf
r8835:86b7d0c27ddf
r19079:a1a4921bfd39
r5584:545d748cc681
r5584:545d748cc681
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r11967:df0600d2c7e7
r11967:df0600d2c7e7
r11967:df0600d2c7e7
r11967:df0600d2c7e7
r5584:545d748cc681
r11967:df0600d2c7e7
r16899:d7758bff8ae6
r11967:df0600d2c7e7
r11967:df0600d2c7e7
r11967:df0600d2c7e7
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r17683:ed148d83dec5
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r11967:df0600d2c7e7
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r11967:df0600d2c7e7
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r16899:d7758bff8ae6
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r15542:f6c6d0f8689e
r10546:a4ec290c1c46
r15542:f6c6d0f8689e
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r17683:ed148d83dec5
r10546:a4ec290c1c46
r18353:55e21e815cc4
r18353:55e21e815cc4
r18353:55e21e815cc4
r18353:55e21e815cc4
r18353:55e21e815cc4
r18353:55e21e815cc4
r18353:55e21e815cc4
r18353:55e21e815cc4
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r17683:ed148d83dec5
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r17683:ed148d83dec5
r17683:ed148d83dec5
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r16899:d7758bff8ae6
r10556:998eabe6aeec
r13669:e6a289a6ec06
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r17683:ed148d83dec5
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r16899:d7758bff8ae6
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r16899:d7758bff8ae6
r16899:d7758bff8ae6
r16899:d7758bff8ae6
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r5584:545d748cc681
r10652:af72ab0998c3
r10652:af72ab0998c3
r10652:af72ab0998c3
r10652:af72ab0998c3
r10652:af72ab0998c3
r10652:af72ab0998c3
r10652:af72ab0998c3
r10652:af72ab0998c3
r10652:af72ab0998c3
r10652:af72ab0998c3
r10652:af72ab0998c3
r10652:af72ab0998c3
r10652:af72ab0998c3
r5584:545d748cc681
r5584:545d748cc681
r10207:a1fc2f2a33db
r5584:545d748cc681
r5584:545d748cc681
r10647:62911ec68e89
r5584:545d748cc681
r12609:70f427be341a
r12609:70f427be341a
r12609:70f427be341a
r12609:70f427be341a
r5584:545d748cc681
r5584:545d748cc681
r14628:bce316ff6597
r14628:bce316ff6597
r14628:bce316ff6597
r18646:67fc6c803d34
r14628:bce316ff6597
r14628:bce316ff6597
r18646:67fc6c803d34
r6071:3dcae6ddc2c7
r14628:bce316ff6597
r14628:bce316ff6597
r14628:bce316ff6597
r17683:ed148d83dec5
r18646:67fc6c803d34
r14628:bce316ff6597
r14628:bce316ff6597
r14623:266e11d5b76f
r14628:bce316ff6597
r14628:bce316ff6597
r14628:bce316ff6597
r14628:bce316ff6597
r14628:bce316ff6597
r6071:3dcae6ddc2c7
r6071:3dcae6ddc2c7
r6071:3dcae6ddc2c7
r18647:b388bd59d544
r18647:b388bd59d544
r18647:b388bd59d544
r18647:b388bd59d544
r18647:b388bd59d544
r18647:b388bd59d544
r18647:b388bd59d544
r18647:b388bd59d544
r18647:b388bd59d544
r18647:b388bd59d544
r9609:1610a18f7e00
r9609:1610a18f7e00
r10544:3093e218ea50
r9609:1610a18f7e00
r9609:1610a18f7e00
r10131:6d911336e994
r11986:6596046384a5
r10546:a4ec290c1c46
r10131:6d911336e994
r9609:1610a18f7e00
r9609:1610a18f7e00
r18646:67fc6c803d34
r18646:67fc6c803d34
r14623:266e11d5b76f
r18646:67fc6c803d34
r9609:1610a18f7e00
r6071:3dcae6ddc2c7
r15610:623a23fb6560
r15610:623a23fb6560
r5584:545d748cc681
r6481:534c9f0317ec
r5584:545d748cc681
r15879:7bd5b8110aa0
r15879:7bd5b8110aa0
r5584:545d748cc681
r10993:8340c8d9cda1
r5584:545d748cc681
r13057:58af81fcdcf8
r13057:58af81fcdcf8
r5584:545d748cc681
r11090:9276cea703d4
r5584:545d748cc681
r15879:7bd5b8110aa0
r15879:7bd5b8110aa0
r8839:479975d442dd
r5584:545d748cc681
r11944:3b8f9f948e8d
r15030:fa70ec3747c6
r14805:8c416234ced2
r14805:8c416234ced2
r14805:8c416234ced2
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8836:911846a8cfa6
r5584:545d748cc681
r11944:3b8f9f948e8d
r11944:3b8f9f948e8d
r5584:545d748cc681
r14805:8c416234ced2
r14805:8c416234ced2
r14805:8c416234ced2
r14805:8c416234ced2
r10652:af72ab0998c3
r11725:57bc99fdc1bc
r10652:af72ab0998c3
r11725:57bc99fdc1bc
r10652:af72ab0998c3
r5584:545d748cc681
r16773:b3301f1d5bbb
r16773:b3301f1d5bbb
r8845:10f2102fafcf
r8856:846424694ca4
r8873:ef1fcefc792a
r9090:fc6e30260626
r8873:ef1fcefc792a
r8873:ef1fcefc792a
r9090:fc6e30260626
r9090:fc6e30260626
r9090:fc6e30260626
r9090:fc6e30260626
r11652:5c73940aeb94
r11652:5c73940aeb94
r11652:5c73940aeb94
r11652:5c73940aeb94
r11652:5c73940aeb94
r11652:5c73940aeb94
r11652:5c73940aeb94
r11652:5c73940aeb94
r11652:5c73940aeb94
r11652:5c73940aeb94
r11652:5c73940aeb94
r11652:5c73940aeb94
r11652:5c73940aeb94
r11652:5c73940aeb94
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r15757:9578ceb50877
r8894:9a9fa8db264e
r11944:3b8f9f948e8d
r8894:9a9fa8db264e
r14805:8c416234ced2
r14805:8c416234ced2
r14805:8c416234ced2
r14805:8c416234ced2
r14805:8c416234ced2
r14857:f3d94ff987c7
r8894:9a9fa8db264e
r8894:9a9fa8db264e
r8894:9a9fa8db264e
r11944:3b8f9f948e8d
r8894:9a9fa8db264e
r14805:8c416234ced2
r14805:8c416234ced2
r14805:8c416234ced2
r14805:8c416234ced2
r8894:9a9fa8db264e
r8894:9a9fa8db264e
r8894:9a9fa8db264e
r8961:7da2b7436c69
r8894:9a9fa8db264e
r8894:9a9fa8db264e
r8894:9a9fa8db264e
r8961:7da2b7436c69
r8894:9a9fa8db264e
r8894:9a9fa8db264e
r8894:9a9fa8db264e
r8961:7da2b7436c69
r8894:9a9fa8db264e
r8894:9a9fa8db264e
r8894:9a9fa8db264e
r8894:9a9fa8db264e
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r16773:b3301f1d5bbb
r9593:bca96abe7879
r11714:378da769bda0
r11714:378da769bda0
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r12462:a7cb564c6c56
r12462:a7cb564c6c56
r12462:a7cb564c6c56
r12351:edd77a5b715f
r12351:edd77a5b715f
r5584:545d748cc681
r14805:8c416234ced2
r13873:1aa967a95d88
r14805:8c416234ced2
r14805:8c416234ced2
r14805:8c416234ced2
r12462:a7cb564c6c56
r14805:8c416234ced2
r12351:edd77a5b715f
r12462:a7cb564c6c56
r13873:1aa967a95d88
r14805:8c416234ced2
r14805:8c416234ced2
r14805:8c416234ced2
r14805:8c416234ced2
r12462:a7cb564c6c56
r12351:edd77a5b715f
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8881:c1ed3a9d37b7
r8863:2dd3b588477d
r5584:545d748cc681
r5584:545d748cc681
r8900:dfe0b94b8d96
r9665:f312055347cc
r10544:3093e218ea50
r18020:2cc4cd085970
r9665:f312055347cc
r9665:f312055347cc
r18020:2cc4cd085970
r9665:f312055347cc
r9665:f312055347cc
r9666:4bceb5cec251
r9665:f312055347cc
r8900:dfe0b94b8d96
r9665:f312055347cc
r9666:4bceb5cec251
r9666:4bceb5cec251
r9665:f312055347cc
r9665:f312055347cc
r9665:f312055347cc
r9665:f312055347cc
r9666:4bceb5cec251
r9665:f312055347cc
r9665:f312055347cc
r9666:4bceb5cec251
r9665:f312055347cc
r9665:f312055347cc
r15608:7b580ec7448a
r15608:7b580ec7448a
r8900:dfe0b94b8d96
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r10544:3093e218ea50
r5584:545d748cc681
r11725:57bc99fdc1bc
r11725:57bc99fdc1bc
r11725:57bc99fdc1bc
r5584:545d748cc681
r10993:8340c8d9cda1
r8551:25fc15391278
r6071:3dcae6ddc2c7
r6071:3dcae6ddc2c7
r5584:545d748cc681
r6071:3dcae6ddc2c7
r6071:3dcae6ddc2c7
r6071:3dcae6ddc2c7
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r12351:edd77a5b715f
r12351:edd77a5b715f
r12351:edd77a5b715f
r12351:edd77a5b715f
r12351:edd77a5b715f
r12351:edd77a5b715f
r12351:edd77a5b715f
r12351:edd77a5b715f
r12351:edd77a5b715f
r6071:3dcae6ddc2c7
r6071:3dcae6ddc2c7
r6071:3dcae6ddc2c7
r18993:1dc8309d2baf
r18993:1dc8309d2baf
r18993:1dc8309d2baf
r18993:1dc8309d2baf
r18993:1dc8309d2baf
r18993:1dc8309d2baf
r18993:1dc8309d2baf
r18993:1dc8309d2baf
r6071:3dcae6ddc2c7
r11725:57bc99fdc1bc
r6071:3dcae6ddc2c7
r6071:3dcae6ddc2c7
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r7391:506daecaaa9a
r8835:86b7d0c27ddf
r16858:6fad1695dab1
r5584:545d748cc681
r5584:545d748cc681
r6950:1a54b1afb12a
r5584:545d748cc681
r5584:545d748cc681
r15610:623a23fb6560
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r17683:ed148d83dec5
r17683:ed148d83dec5
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r16858:6fad1695dab1
r16858:6fad1695dab1
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17683:ed148d83dec5
r17683:ed148d83dec5
r17683:ed148d83dec5
r17683:ed148d83dec5
r17557:93c06b0d1431
r17683:ed148d83dec5
r17557:93c06b0d1431
r17683:ed148d83dec5
r17683:ed148d83dec5
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17683:ed148d83dec5
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r15610:623a23fb6560
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r11090:9276cea703d4
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r10184:9c5fe3a1bdab
r9297:6cd3e74fc38e
r5584:545d748cc681
r6950:1a54b1afb12a
r5584:545d748cc681
r5584:545d748cc681
r15610:623a23fb6560
r15610:623a23fb6560
r5584:545d748cc681
r6481:534c9f0317ec
r5584:545d748cc681
r5584:545d748cc681
r13057:58af81fcdcf8
r13057:58af81fcdcf8
r5584:545d748cc681
r11090:9276cea703d4
r5584:545d748cc681
r15879:7bd5b8110aa0
r15879:7bd5b8110aa0
r5584:545d748cc681
r11944:3b8f9f948e8d
r5584:545d748cc681
r15030:fa70ec3747c6
r14805:8c416234ced2
r14805:8c416234ced2
r14805:8c416234ced2
r5584:545d748cc681
r5584:545d748cc681
r15542:f6c6d0f8689e
r5584:545d748cc681
r16859:99ba0b4ec534
r5584:545d748cc681
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r5584:545d748cc681
r16858:6fad1695dab1
r17295:2648861aae5f
r17295:2648861aae5f
r17295:2648861aae5f
r17295:2648861aae5f
r17295:2648861aae5f
r17295:2648861aae5f
r17295:2648861aae5f
r17295:2648861aae5f
r17295:2648861aae5f
r17295:2648861aae5f
r17295:2648861aae5f
r17295:2648861aae5f
r17295:2648861aae5f
r17295:2648861aae5f
r17295:2648861aae5f
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r5584:545d748cc681
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r5584:545d748cc681
r17184:a6dd7165a9b8
r17295:2648861aae5f
r5584:545d748cc681
r5584:545d748cc681
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17683:ed148d83dec5
r17683:ed148d83dec5
r17683:ed148d83dec5
r17184:a6dd7165a9b8
r17683:ed148d83dec5
r17184:a6dd7165a9b8
r17683:ed148d83dec5
r17683:ed148d83dec5
r17683:ed148d83dec5
r17683:ed148d83dec5
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r16991:bb053a16bbe8
r16858:6fad1695dab1
r16858:6fad1695dab1
r5584:545d748cc681
r5584:545d748cc681
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r17552:13c0523fa0e6
r16858:6fad1695dab1
r16858:6fad1695dab1
r17552:13c0523fa0e6
r16858:6fad1695dab1
r17552:13c0523fa0e6
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r16858:6fad1695dab1
r5584:545d748cc681
r5584:545d748cc681
r15610:623a23fb6560
r15610:623a23fb6560
r5584:545d748cc681
r6481:534c9f0317ec
r5584:545d748cc681
r6794:e8e14e10467b
r13057:58af81fcdcf8
r13057:58af81fcdcf8
r5584:545d748cc681
r11090:9276cea703d4
r5584:545d748cc681
r15879:7bd5b8110aa0
r15879:7bd5b8110aa0
r5584:545d748cc681
r11944:3b8f9f948e8d
r5584:545d748cc681
r17683:ed148d83dec5
r14805:8c416234ced2
r14805:8c416234ced2
r14805:8c416234ced2
r5584:545d748cc681
r5584:545d748cc681
r17683:ed148d83dec5
r17184:a6dd7165a9b8
r5584:545d748cc681
r8843:e138882e90db
r5584:545d748cc681
r12882:f4dfec701fee
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r13024:48c81d0b078a
r13024:48c81d0b078a
r5584:545d748cc681
r6950:1a54b1afb12a
r5584:545d748cc681
r5584:545d748cc681
r6832:856e7cea465f
r6832:856e7cea465f
r6832:856e7cea465f
r13057:58af81fcdcf8
r6832:856e7cea465f
r6832:856e7cea465f
r6832:856e7cea465f
r6832:856e7cea465f
r13057:58af81fcdcf8
r13057:58af81fcdcf8
r6832:856e7cea465f
r6832:856e7cea465f
r6832:856e7cea465f
r11090:9276cea703d4
r6832:856e7cea465f
r15879:7bd5b8110aa0
r6832:856e7cea465f
r6832:856e7cea465f
r6832:856e7cea465f
r11944:3b8f9f948e8d
r15030:fa70ec3747c6
r14805:8c416234ced2
r14805:8c416234ced2
r14805:8c416234ced2
r6832:856e7cea465f
r6832:856e7cea465f
r10544:3093e218ea50
r14877:8260fce9fd4a
r6832:856e7cea465f
r11986:6596046384a5
r6832:856e7cea465f
r6832:856e7cea465f
r6832:856e7cea465f
r6832:856e7cea465f
r10546:a4ec290c1c46
r6832:856e7cea465f
r6832:856e7cea465f
r9941:945cc0c6ccbc
r6832:856e7cea465f
r6832:856e7cea465f
r6832:856e7cea465f
r9941:945cc0c6ccbc
r17184:a6dd7165a9b8
r17683:ed148d83dec5
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17683:ed148d83dec5
r17683:ed148d83dec5
r17683:ed148d83dec5
r17683:ed148d83dec5
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17683:ed148d83dec5
r17683:ed148d83dec5
r17683:ed148d83dec5
r17683:ed148d83dec5
r17683:ed148d83dec5
r17683:ed148d83dec5
r6832:856e7cea465f
r6832:856e7cea465f
r10546:a4ec290c1c46
r6832:856e7cea465f
r10184:9c5fe3a1bdab
r6832:856e7cea465f
r6832:856e7cea465f
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r12695:e3d3f57fdea8
r8900:dfe0b94b8d96
r12695:e3d3f57fdea8
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r6832:856e7cea465f
r9297:6cd3e74fc38e
r6832:856e7cea465f
r6832:856e7cea465f
r6950:1a54b1afb12a
r6832:856e7cea465f
r5584:545d748cc681
r15610:623a23fb6560
r15610:623a23fb6560
r5584:545d748cc681
r6481:534c9f0317ec
r5584:545d748cc681
r15879:7bd5b8110aa0
r15879:7bd5b8110aa0
r5584:545d748cc681
r15879:7bd5b8110aa0
r8869:e2e8b17142d9
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r13057:58af81fcdcf8
r13057:58af81fcdcf8
r5584:545d748cc681
r11090:9276cea703d4
r5584:545d748cc681
r15879:7bd5b8110aa0
r15879:7bd5b8110aa0
r15027:bb71fdfcc554
r15879:7bd5b8110aa0
r5584:545d748cc681
r8900:dfe0b94b8d96
r5584:545d748cc681
r11944:3b8f9f948e8d
r15030:fa70ec3747c6
r14805:8c416234ced2
r14805:8c416234ced2
r14805:8c416234ced2
r5584:545d748cc681
r5584:545d748cc681
r10544:3093e218ea50
r5584:545d748cc681
r11986:6596046384a5
r8869:e2e8b17142d9
r8869:e2e8b17142d9
r12351:edd77a5b715f
r8869:e2e8b17142d9
r8869:e2e8b17142d9
r8869:e2e8b17142d9
r8900:dfe0b94b8d96
r8869:e2e8b17142d9
r8869:e2e8b17142d9
r8869:e2e8b17142d9
r8869:e2e8b17142d9
r8869:e2e8b17142d9
r8869:e2e8b17142d9
r8900:dfe0b94b8d96
r11675:15b867746410
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8869:e2e8b17142d9
r8869:e2e8b17142d9
r8869:e2e8b17142d9
r8869:e2e8b17142d9
r8869:e2e8b17142d9
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8869:e2e8b17142d9
r16773:b3301f1d5bbb
r8869:e2e8b17142d9
r8869:e2e8b17142d9
r8869:e2e8b17142d9
r8869:e2e8b17142d9
r11652:5c73940aeb94
r11652:5c73940aeb94
r11652:5c73940aeb94
r11652:5c73940aeb94
r11652:5c73940aeb94
r8869:e2e8b17142d9
r8883:d4a834db67ba
r8883:d4a834db67ba
r8883:d4a834db67ba
r8869:e2e8b17142d9
r8869:e2e8b17142d9
r8869:e2e8b17142d9
r8869:e2e8b17142d9
r8883:d4a834db67ba
r8869:e2e8b17142d9
r8869:e2e8b17142d9
r8869:e2e8b17142d9
r8869:e2e8b17142d9
r10285:43923f0738a2
r8869:e2e8b17142d9
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8903:9c0d5a75fa24
r8903:9c0d5a75fa24
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8903:9c0d5a75fa24
r8903:9c0d5a75fa24
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r9665:f312055347cc
r9665:f312055347cc
r10544:3093e218ea50
r9665:f312055347cc
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8869:e2e8b17142d9
r8869:e2e8b17142d9
r8869:e2e8b17142d9
r18241:a4322e3af754
r8869:e2e8b17142d9
r8869:e2e8b17142d9
r11652:5c73940aeb94
r11652:5c73940aeb94
r11652:5c73940aeb94
r11652:5c73940aeb94
r8869:e2e8b17142d9
r8869:e2e8b17142d9
r8869:e2e8b17142d9
r8869:e2e8b17142d9
r8869:e2e8b17142d9
r8869:e2e8b17142d9
r18241:a4322e3af754
r8845:10f2102fafcf
r8869:e2e8b17142d9
r10285:43923f0738a2
r10285:43923f0738a2
r10285:43923f0738a2
r10285:43923f0738a2
r10285:43923f0738a2
r10285:43923f0738a2
r10285:43923f0738a2
r10285:43923f0738a2
r10285:43923f0738a2
r10285:43923f0738a2
r17819:976cd38ca2d1
r10285:43923f0738a2
r10285:43923f0738a2
r10285:43923f0738a2
r10285:43923f0738a2
r10285:43923f0738a2
r17819:976cd38ca2d1
r10285:43923f0738a2
r10285:43923f0738a2
r10285:43923f0738a2
r10285:43923f0738a2
r10285:43923f0738a2
r15608:7b580ec7448a
r15608:7b580ec7448a
r8869:e2e8b17142d9
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8903:9c0d5a75fa24
r8903:9c0d5a75fa24
r8903:9c0d5a75fa24
r8903:9c0d5a75fa24
r8903:9c0d5a75fa24
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r15608:7b580ec7448a
r15608:7b580ec7448a
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r9665:f312055347cc
r9665:f312055347cc
r9665:f312055347cc
r9665:f312055347cc
r8845:10f2102fafcf
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r9941:945cc0c6ccbc
r8869:e2e8b17142d9
r9941:945cc0c6ccbc
r8872:8de9f271596f
r8872:8de9f271596f
r8872:8de9f271596f
r8872:8de9f271596f
r8872:8de9f271596f
r8872:8de9f271596f
r8872:8de9f271596f
r8872:8de9f271596f
r8872:8de9f271596f
r17184:a6dd7165a9b8
r8872:8de9f271596f
r8872:8de9f271596f
r8872:8de9f271596f
r5584:545d748cc681
r12882:f4dfec701fee
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6950:1a54b1afb12a
r5584:545d748cc681
r5584:545d748cc681
r15610:623a23fb6560
r18646:67fc6c803d34
r19192:be03904bc822
r19192:be03904bc822
r18646:67fc6c803d34
r18646:67fc6c803d34
r18646:67fc6c803d34
r19192:be03904bc822
r18646:67fc6c803d34
r19192:be03904bc822
r18646:67fc6c803d34
r18646:67fc6c803d34
r18646:67fc6c803d34
r18646:67fc6c803d34
r18646:67fc6c803d34
r18646:67fc6c803d34
r18646:67fc6c803d34
r18646:67fc6c803d34
r18646:67fc6c803d34
r19192:be03904bc822
r18646:67fc6c803d34
r18646:67fc6c803d34
r18646:67fc6c803d34
r18646:67fc6c803d34
r18646:67fc6c803d34
r18646:67fc6c803d34
r18646:67fc6c803d34
r18646:67fc6c803d34
r18646:67fc6c803d34
r18646:67fc6c803d34
r15610:623a23fb6560
r6481:534c9f0317ec
r6481:534c9f0317ec
r5584:545d748cc681
r15879:7bd5b8110aa0
r15879:7bd5b8110aa0
r15879:7bd5b8110aa0
r13057:58af81fcdcf8
r13057:58af81fcdcf8
r5584:545d748cc681
r11090:9276cea703d4
r5584:545d748cc681
r15879:7bd5b8110aa0
r15879:7bd5b8110aa0
r5584:545d748cc681
r11944:3b8f9f948e8d
r15030:fa70ec3747c6
r5584:545d748cc681
r14805:8c416234ced2
r14805:8c416234ced2
r5584:545d748cc681
r15879:7bd5b8110aa0
r5584:545d748cc681
r11944:3b8f9f948e8d
r5584:545d748cc681
r5584:545d748cc681
r15030:fa70ec3747c6
r14805:8c416234ced2
r14805:8c416234ced2
r14805:8c416234ced2
r5584:545d748cc681
r5584:545d748cc681
r13842:5f8f28d5f86b
r13841:f0b647e42935
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r9941:945cc0c6ccbc
r5584:545d748cc681
r10652:af72ab0998c3
r10652:af72ab0998c3
r10652:af72ab0998c3
r19473:714c71f6bce9
r19473:714c71f6bce9
r19473:714c71f6bce9
r19473:714c71f6bce9
r19473:714c71f6bce9
r19473:714c71f6bce9
r19473:714c71f6bce9
r11725:57bc99fdc1bc
r10652:af72ab0998c3
r10652:af72ab0998c3
r10652:af72ab0998c3
r18646:67fc6c803d34
r19192:be03904bc822
r18646:67fc6c803d34
r18646:67fc6c803d34
r18646:67fc6c803d34
r17274:cb8beb8dd070
r17274:cb8beb8dd070
r17274:cb8beb8dd070
r17274:cb8beb8dd070
r5584:545d748cc681
r17296:56a65652cc58
r17296:56a65652cc58
r17296:56a65652cc58
r17296:56a65652cc58
r5584:545d748cc681
r10546:a4ec290c1c46
r5584:545d748cc681
r5584:545d748cc681
r9941:945cc0c6ccbc
r5584:545d748cc681
r10184:9c5fe3a1bdab
r12882:f4dfec701fee
r5584:545d748cc681
r9297:6cd3e74fc38e
r5584:545d748cc681
r15608:7b580ec7448a
r15608:7b580ec7448a
r5584:545d748cc681
r5584:545d748cc681
r11944:3b8f9f948e8d
r5584:545d748cc681
r5584:545d748cc681
r15030:fa70ec3747c6
r14805:8c416234ced2
r14805:8c416234ced2
r14805:8c416234ced2
r5584:545d748cc681
r10652:af72ab0998c3
r10652:af72ab0998c3
r10652:af72ab0998c3
r10652:af72ab0998c3
r10652:af72ab0998c3
r11917:612c11f7ab47
r11725:57bc99fdc1bc
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r18646:67fc6c803d34
r19192:be03904bc822
r18646:67fc6c803d34
r18646:67fc6c803d34
r18646:67fc6c803d34
r5584:545d748cc681
r18983:b54fb9b82ec1
r11725:57bc99fdc1bc
r10304:5c0367102ee6
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r10546:a4ec290c1c46
r5584:545d748cc681
r5584:545d748cc681
r17296:56a65652cc58
r17296:56a65652cc58
r17296:56a65652cc58
r17296:56a65652cc58
r5584:545d748cc681
r10546:a4ec290c1c46
r5584:545d748cc681
r7391:506daecaaa9a
r8835:86b7d0c27ddf
r5584:545d748cc681
r5584:545d748cc681
r11967:df0600d2c7e7
r11967:df0600d2c7e7
r11967:df0600d2c7e7
r10546:a4ec290c1c46
r11967:df0600d2c7e7
r11967:df0600d2c7e7
r17349:39dc89585a33
r11967:df0600d2c7e7
r10546:a4ec290c1c46
r5584:545d748cc681
r10184:9c5fe3a1bdab
r5584:545d748cc681
r9297:6cd3e74fc38e
r5584:545d748cc681
r15608:7b580ec7448a
r15608:7b580ec7448a
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6950:1a54b1afb12a
r5584:545d748cc681
r5584:545d748cc681
r15610:623a23fb6560
r15610:623a23fb6560
r5584:545d748cc681
r6481:534c9f0317ec
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r13057:58af81fcdcf8
r13057:58af81fcdcf8
r5584:545d748cc681
r11090:9276cea703d4
r5584:545d748cc681
r15879:7bd5b8110aa0
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r18241:a4322e3af754
r15030:fa70ec3747c6
r11944:3b8f9f948e8d
r15030:fa70ec3747c6
r14805:8c416234ced2
r14805:8c416234ced2
r14805:8c416234ced2
r5584:545d748cc681
r11986:6596046384a5
r5584:545d748cc681
r5584:545d748cc681
r18241:a4322e3af754
r18241:a4322e3af754
r18241:a4322e3af754
r5584:545d748cc681
r8838:ab02a7e7aabf
r5584:545d748cc681
r17819:976cd38ca2d1
r19528:aaa5a65470fe
r17819:976cd38ca2d1
r17819:976cd38ca2d1
r17819:976cd38ca2d1
r17819:976cd38ca2d1
r9941:945cc0c6ccbc
r5584:545d748cc681
r12882:f4dfec701fee
r5584:545d748cc681
r5584:545d748cc681
r17184:a6dd7165a9b8
r8838:ab02a7e7aabf
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6950:1a54b1afb12a
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r10647:62911ec68e89
r5584:545d748cc681
r5584:545d748cc681
r9413:fcf267325763
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r15542:f6c6d0f8689e
r5584:545d748cc681
r5584:545d748cc681
r9941:945cc0c6ccbc
r5584:545d748cc681
r5584:545d748cc681
r10207:a1fc2f2a33db
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8836:911846a8cfa6
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8836:911846a8cfa6
r11917:612c11f7ab47
r5584:545d748cc681
r5584:545d748cc681
r14103:410cf09a59ff
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r10544:3093e218ea50
r11986:6596046384a5
r5584:545d748cc681
r10546:a4ec290c1c46
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r10546:a4ec290c1c46
r11014:238a1e6bb3c7
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r12609:70f427be341a
r5584:545d748cc681
r5584:545d748cc681
r10574:861fa688dc29
r19367:da2e40bf245d
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8836:911846a8cfa6
r8840:f5c2213cf909
r8836:911846a8cfa6
r13024:48c81d0b078a
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r10184:9c5fe3a1bdab
r5584:545d748cc681
r10184:9c5fe3a1bdab
r17436:3d32f1647a59
r16897:d3b3d1abd708
r16897:d3b3d1abd708
r16897:d3b3d1abd708
r17683:ed148d83dec5
r16897:d3b3d1abd708
r17683:ed148d83dec5
r16897:d3b3d1abd708
r16897:d3b3d1abd708
r17683:ed148d83dec5
r17436:3d32f1647a59
r16897:d3b3d1abd708
r17436:3d32f1647a59
r17436:3d32f1647a59
r16897:d3b3d1abd708
r16897:d3b3d1abd708
r8836:911846a8cfa6
r10184:9c5fe3a1bdab
r10184:9c5fe3a1bdab
r10184:9c5fe3a1bdab
r10184:9c5fe3a1bdab
r10184:9c5fe3a1bdab
r10020:7f3adc168420
r10020:7f3adc168420
r5584:545d748cc681
r18607:7724313c61c6
r18607:7724313c61c6
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r16723:9f6e29be2bde
r16723:9f6e29be2bde
r5584:545d748cc681
r16723:9f6e29be2bde
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r16723:9f6e29be2bde
r15542:f6c6d0f8689e
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r17296:56a65652cc58
r17296:56a65652cc58
r17683:ed148d83dec5
r17296:56a65652cc58
r17296:56a65652cc58
r17296:56a65652cc58
r5584:545d748cc681
r17296:56a65652cc58
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8469:0e9208c7ef41
r9941:945cc0c6ccbc
r9941:945cc0c6ccbc
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r9941:945cc0c6ccbc
r10546:a4ec290c1c46
r10546:a4ec290c1c46
r5584:545d748cc681
r17296:56a65652cc58
r17296:56a65652cc58
r17683:ed148d83dec5
r17296:56a65652cc58
r17296:56a65652cc58
r17296:56a65652cc58
r17296:56a65652cc58
r5584:545d748cc681
r5584:545d748cc681
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r12027:83216fa52f8f
r8211:7dc9fca2785c
r12027:83216fa52f8f
r8211:7dc9fca2785c
r8211:7dc9fca2785c
r8827:6ee5217ef94b
r8830:3bad3e96d573
r8830:3bad3e96d573
r8830:3bad3e96d573
r8830:3bad3e96d573
r14062:88cf06322315
r8830:3bad3e96d573
r8830:3bad3e96d573
r8830:3bad3e96d573
r8830:3bad3e96d573
r8830:3bad3e96d573
r8830:3bad3e96d573
r14062:88cf06322315
r14062:88cf06322315
r14062:88cf06322315
r14062:88cf06322315
r14062:88cf06322315
r14062:88cf06322315
r14062:88cf06322315
r14062:88cf06322315
r14062:88cf06322315
r14062:88cf06322315
r14062:88cf06322315
r8830:3bad3e96d573
r8830:3bad3e96d573
r8830:3bad3e96d573
r8830:3bad3e96d573
r8830:3bad3e96d573
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r8900:dfe0b94b8d96
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r9807:a5bd28dc9b6b
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r18033:53f0ab8989eb
r18033:53f0ab8989eb
r18033:53f0ab8989eb
r18033:53f0ab8989eb
r18033:53f0ab8989eb
r18033:53f0ab8989eb
r18033:53f0ab8989eb
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r13060:e57594b0ca84
r17794:0cc19d7573b2
r9440:8395d31c88d7
r17794:0cc19d7573b2
r9440:8395d31c88d7
r12367:133f84bce6c0
r12367:133f84bce6c0
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r12367:133f84bce6c0
r9440:8395d31c88d7
r9440:8395d31c88d7
r15559:eda939edd685
r17794:0cc19d7573b2
r15559:eda939edd685
r17184:a6dd7165a9b8
r15559:eda939edd685
r15559:eda939edd685
r15559:eda939edd685
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r17794:0cc19d7573b2
r17794:0cc19d7573b2
r17794:0cc19d7573b2
r9440:8395d31c88d7
r11804:b557a467d2ad
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r11977:bc3933e2c9d0
r12109:90df01928018
r11977:bc3933e2c9d0
r11977:bc3933e2c9d0
r11977:bc3933e2c9d0
r11977:bc3933e2c9d0
r11977:bc3933e2c9d0
r9440:8395d31c88d7
r12367:133f84bce6c0
r12367:133f84bce6c0
r12045:526d2deb317d
r17794:0cc19d7573b2
r17794:0cc19d7573b2
r17794:0cc19d7573b2
r12367:133f84bce6c0
r17184:a6dd7165a9b8
r12367:133f84bce6c0
r12367:133f84bce6c0
r12367:133f84bce6c0
r9440:8395d31c88d7
r12367:133f84bce6c0
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r12493:6da69ce1ff42
r12367:133f84bce6c0
r9440:8395d31c88d7
r9440:8395d31c88d7
r17794:0cc19d7573b2
r9440:8395d31c88d7
r9440:8395d31c88d7
r17683:ed148d83dec5
r17184:a6dd7165a9b8
r9641:a78fbf5c85cc
r17683:ed148d83dec5
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17556:e1b7e68a1cb8
r17683:ed148d83dec5
r17556:e1b7e68a1cb8
r17556:e1b7e68a1cb8
r17556:e1b7e68a1cb8
r17683:ed148d83dec5
r17556:e1b7e68a1cb8
r9440:8395d31c88d7
r9641:a78fbf5c85cc
r17184:a6dd7165a9b8
r9440:8395d31c88d7
r12367:133f84bce6c0
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r12367:133f84bce6c0
r17683:ed148d83dec5
r17184:a6dd7165a9b8
r12367:133f84bce6c0
r12367:133f84bce6c0
r17184:a6dd7165a9b8
r17683:ed148d83dec5
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r16897:d3b3d1abd708
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r16897:d3b3d1abd708
r17184:a6dd7165a9b8
r12367:133f84bce6c0
r17794:0cc19d7573b2
r9440:8395d31c88d7
r9440:8395d31c88d7
r9440:8395d31c88d7
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8836:911846a8cfa6
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8853:c56f6dec859b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8830:3bad3e96d573
r8830:3bad3e96d573
r8827:6ee5217ef94b
r8830:3bad3e96d573
r8830:3bad3e96d573
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8836:911846a8cfa6
r8827:6ee5217ef94b
r15887:0cf937038f56
r12493:6da69ce1ff42
r8827:6ee5217ef94b
r8840:f5c2213cf909
r17683:ed148d83dec5
r15887:0cf937038f56
r15887:0cf937038f56
r15887:0cf937038f56
r15887:0cf937038f56
r15887:0cf937038f56
r8827:6ee5217ef94b
r17683:ed148d83dec5
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r17683:ed148d83dec5
r17184:a6dd7165a9b8
r8827:6ee5217ef94b
r17184:a6dd7165a9b8
r17683:ed148d83dec5
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r17184:a6dd7165a9b8
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r14062:88cf06322315
r8830:3bad3e96d573
r8830:3bad3e96d573
r11976:ae6aa97461b7
r12109:90df01928018
r8830:3bad3e96d573
r8830:3bad3e96d573
r8830:3bad3e96d573
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8911:4dc06321ec50
r11917:612c11f7ab47
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r12882:f4dfec701fee
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8830:3bad3e96d573
r8827:6ee5217ef94b
r13024:48c81d0b078a
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r8827:6ee5217ef94b
r9440:8395d31c88d7
r8827:6ee5217ef94b
r5584:545d748cc681
r8832:6c9ef37d3595
r8832:6c9ef37d3595
r8832:6c9ef37d3595
r8832:6c9ef37d3595
r8832:6c9ef37d3595
r8832:6c9ef37d3595
r8832:6c9ef37d3595
r8832:6c9ef37d3595
r8832:6c9ef37d3595
r8941:810ccf87dc7d
r16537:b136370bd3c2
r16537:b136370bd3c2
r8832:6c9ef37d3595
r8848:6bd9c22eb5ec
r8941:810ccf87dc7d
r8832:6c9ef37d3595
/* $Id$ */

/*
 * 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 order_cmd.cpp Handling of orders. */

#include "stdafx.h"
#include "debug.h"
#include "cmd_helper.h"
#include "command_func.h"
#include "company_func.h"
#include "news_func.h"
#include "strings_func.h"
#include "timetable.h"
#include "vehicle_func.h"
#include "depot_base.h"
#include "core/pool_func.hpp"
#include "aircraft.h"
#include "roadveh.h"
#include "station_base.h"
#include "waypoint_base.h"
#include "company_base.h"
#include "order_backup.h"

#include "table/strings.h"

/* DestinationID must be at least as large as every these below, because it can
 * be any of them
 */
assert_compile(sizeof(DestinationID) >= sizeof(DepotID));
assert_compile(sizeof(DestinationID) >= sizeof(StationID));

OrderPool _order_pool("Order");
INSTANTIATE_POOL_METHODS(Order)
OrderListPool _orderlist_pool("OrderList");
INSTANTIATE_POOL_METHODS(OrderList)

/** Clean everything up. */
Order::~Order()
{
	if (CleaningPool()) return;

	/* We can visit oil rigs and buoys that are not our own. They will be shown in
	 * the list of stations. So, we need to invalidate that window if needed. */
	if (this->IsType(OT_GOTO_STATION) || this->IsType(OT_GOTO_WAYPOINT)) {
		BaseStation *bs = BaseStation::GetIfValid(this->GetDestination());
		if (bs != NULL && bs->owner == OWNER_NONE) InvalidateWindowClassesData(WC_STATION_LIST, 0);
	}
}

/**
 * 'Free' the order
 * @note ONLY use on "current_order" vehicle orders!
 */
void Order::Free()
{
	this->type  = OT_NOTHING;
	this->flags = 0;
	this->dest  = 0;
	this->next  = NULL;
}

/**
 * Makes this order a Go To Station order.
 * @param destination the station to go to.
 */
void Order::MakeGoToStation(StationID destination)
{
	this->type = OT_GOTO_STATION;
	this->flags = 0;
	this->dest = destination;
}

/**
 * Makes this order a Go To Depot order.
 * @param destination   the depot to go to.
 * @param order         is this order a 'default' order, or an overriden vehicle order?
 * @param non_stop_type how to get to the depot?
 * @param action        what to do in the depot?
 * @param cargo         the cargo type to change to.
 * @param subtype       the subtype to change to.
 */
void Order::MakeGoToDepot(DepotID destination, OrderDepotTypeFlags order, OrderNonStopFlags non_stop_type, OrderDepotActionFlags action, CargoID cargo, byte subtype)
{
	this->type = OT_GOTO_DEPOT;
	this->SetDepotOrderType(order);
	this->SetDepotActionType(action);
	this->SetNonStopType(non_stop_type);
	this->dest = destination;
	this->SetRefit(cargo, subtype);
}

/**
 * Makes this order a Go To Waypoint order.
 * @param destination the waypoint to go to.
 */
void Order::MakeGoToWaypoint(StationID destination)
{
	this->type = OT_GOTO_WAYPOINT;
	this->flags = 0;
	this->dest = destination;
}

/**
 * Makes this order a Loading order.
 * @param ordered is this an ordered stop?
 */
void Order::MakeLoading(bool ordered)
{
	this->type = OT_LOADING;
	if (!ordered) this->flags = 0;
}

/**
 * Makes this order a Leave Station order.
 */
void Order::MakeLeaveStation()
{
	this->type = OT_LEAVESTATION;
	this->flags = 0;
}

/**
 * Makes this order a Dummy order.
 */
void Order::MakeDummy()
{
	this->type = OT_DUMMY;
	this->flags = 0;
}

/**
 * Makes this order an conditional order.
 * @param order the order to jump to.
 */
void Order::MakeConditional(VehicleOrderID order)
{
	this->type = OT_CONDITIONAL;
	this->flags = order;
	this->dest = 0;
}

/**
 * Makes this order an implicit order.
 * @param destination the station to go to.
 */
void Order::MakeImplicit(StationID destination)
{
	this->type = OT_IMPLICIT;
	this->dest = destination;
}

/**
 * Make this depot/station order also a refit order.
 * @param cargo   the cargo type to change to.
 * @param subtype the subtype to change to.
 * @pre IsType(OT_GOTO_DEPOT) || IsType(OT_GOTO_STATION).
 */
void Order::SetRefit(CargoID cargo, byte subtype)
{
	this->refit_cargo = cargo;
	this->refit_subtype = subtype;
}

/**
 * Does this order have the same type, flags and destination?
 * @param other the second order to compare to.
 * @return true if the type, flags and destination match.
 */
bool Order::Equals(const Order &other) const
{
	/* In case of go to nearest depot orders we need "only" compare the flags
	 * with the other and not the nearest depot order bit or the actual
	 * destination because those get clear/filled in during the order
	 * evaluation. If we do not do this the order will continuously be seen as
	 * a different order and it will try to find a "nearest depot" every tick. */
	if ((this->IsType(OT_GOTO_DEPOT) && this->type == other.type) &&
			((this->GetDepotActionType() & ODATFB_NEAREST_DEPOT) != 0 ||
			 (other.GetDepotActionType() & ODATFB_NEAREST_DEPOT) != 0)) {
		return this->GetDepotOrderType() == other.GetDepotOrderType() &&
				(this->GetDepotActionType() & ~ODATFB_NEAREST_DEPOT) == (other.GetDepotActionType() & ~ODATFB_NEAREST_DEPOT);
	}

	return this->type == other.type && this->flags == other.flags && this->dest == other.dest;
}

/**
 * Pack this order into a 32 bits integer, or actually only
 * the type, flags and destination.
 * @return the packed representation.
 * @note unpacking is done in the constructor.
 */
uint32 Order::Pack() const
{
	return this->dest << 16 | this->flags << 8 | this->type;
}

/**
 * Pack this order into a 16 bits integer as close to the TTD
 * representation as possible.
 * @return the TTD-like packed representation.
 */
uint16 Order::MapOldOrder() const
{
	uint16 order = this->GetType();
	switch (this->type) {
		case OT_GOTO_STATION:
			if (this->GetUnloadType() & OUFB_UNLOAD) SetBit(order, 5);
			if (this->GetLoadType() & OLFB_FULL_LOAD) SetBit(order, 6);
			if (this->GetNonStopType() & ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS) SetBit(order, 7);
			order |= GB(this->GetDestination(), 0, 8) << 8;
			break;
		case OT_GOTO_DEPOT:
			if (!(this->GetDepotOrderType() & ODTFB_PART_OF_ORDERS)) SetBit(order, 6);
			SetBit(order, 7);
			order |= GB(this->GetDestination(), 0, 8) << 8;
			break;
		case OT_LOADING:
			if (this->GetLoadType() & OLFB_FULL_LOAD) SetBit(order, 6);
			break;
	}
	return order;
}

/**
 * Create an order based on a packed representation of that order.
 * @param packed the packed representation.
 */
Order::Order(uint32 packed)
{
	this->type    = (OrderType)GB(packed,  0,  8);
	this->flags   = GB(packed,  8,  8);
	this->dest    = GB(packed, 16, 16);
	this->next    = NULL;
	this->refit_cargo   = CT_NO_REFIT;
	this->refit_subtype = 0;
	this->wait_time     = 0;
	this->travel_time   = 0;
	this->max_speed     = UINT16_MAX;
}

/**
 *
 * Updates the widgets of a vehicle which contains the order-data
 *
 */
void InvalidateVehicleOrder(const Vehicle *v, int data)
{
	SetWindowDirty(WC_VEHICLE_VIEW, v->index);

	if (data != 0) {
		/* Calls SetDirty() too */
		InvalidateWindowData(WC_VEHICLE_ORDERS,    v->index, data);
		InvalidateWindowData(WC_VEHICLE_TIMETABLE, v->index, data);
		return;
	}

	SetWindowDirty(WC_VEHICLE_ORDERS,    v->index);
	SetWindowDirty(WC_VEHICLE_TIMETABLE, v->index);
}

/**
 *
 * Assign data to an order (from another order)
 *   This function makes sure that the index is maintained correctly
 * @param other the data to copy (except next pointer).
 *
 */
void Order::AssignOrder(const Order &other)
{
	this->type  = other.type;
	this->flags = other.flags;
	this->dest  = other.dest;

	this->refit_cargo   = other.refit_cargo;
	this->refit_subtype = other.refit_subtype;

	this->wait_time   = other.wait_time;
	this->travel_time = other.travel_time;
	this->max_speed   = other.max_speed;
}

/**
 * Recomputes everything.
 * @param chain first order in the chain
 * @param v one of vehicle that is using this orderlist
 */
void OrderList::Initialize(Order *chain, Vehicle *v)
{
	this->first = chain;
	this->first_shared = v;

	this->num_orders = 0;
	this->num_manual_orders = 0;
	this->num_vehicles = 1;
	this->timetable_duration = 0;

	for (Order *o = this->first; o != NULL; o = o->next) {
		++this->num_orders;
		if (!o->IsType(OT_IMPLICIT)) ++this->num_manual_orders;
		this->timetable_duration += o->wait_time + o->travel_time;
	}

	for (Vehicle *u = this->first_shared->PreviousShared(); u != NULL; u = u->PreviousShared()) {
		++this->num_vehicles;
		this->first_shared = u;
	}

	for (const Vehicle *u = v->NextShared(); u != NULL; u = u->NextShared()) ++this->num_vehicles;
}

/**
 * Free a complete order chain.
 * @param keep_orderlist If this is true only delete the orders, otherwise also delete the OrderList.
 * @note do not use on "current_order" vehicle orders!
 */
void OrderList::FreeChain(bool keep_orderlist)
{
	Order *next;
	for (Order *o = this->first; o != NULL; o = next) {
		next = o->next;
		delete o;
	}

	if (keep_orderlist) {
		this->first = NULL;
		this->num_orders = 0;
		this->num_manual_orders = 0;
		this->timetable_duration = 0;
	} else {
		delete this;
	}
}

/**
 * Get a certain order of the order chain.
 * @param index zero-based index of the order within the chain.
 * @return the order at position index.
 */
Order *OrderList::GetOrderAt(int index) const
{
	if (index < 0) return NULL;

	Order *order = this->first;

	while (order != NULL && index-- > 0) {
		order = order->next;
	}
	return order;
}

/**
 * Insert a new order into the order chain.
 * @param new_order is the order to insert into the chain.
 * @param index is the position where the order is supposed to be inserted.
 */
void OrderList::InsertOrderAt(Order *new_order, int index)
{
	if (this->first == NULL) {
		this->first = new_order;
	} else {
		if (index == 0) {
			/* Insert as first or only order */
			new_order->next = this->first;
			this->first = new_order;
		} else if (index >= this->num_orders) {
			/* index is after the last order, add it to the end */
			this->GetLastOrder()->next = new_order;
		} else {
			/* Put the new order in between */
			Order *order = this->GetOrderAt(index - 1);
			new_order->next = order->next;
			order->next = new_order;
		}
	}
	++this->num_orders;
	if (!new_order->IsType(OT_IMPLICIT)) ++this->num_manual_orders;
	this->timetable_duration += new_order->wait_time + new_order->travel_time;

	/* We can visit oil rigs and buoys that are not our own. They will be shown in
	 * the list of stations. So, we need to invalidate that window if needed. */
	if (new_order->IsType(OT_GOTO_STATION) || new_order->IsType(OT_GOTO_WAYPOINT)) {
		BaseStation *bs = BaseStation::Get(new_order->GetDestination());
		if (bs->owner == OWNER_NONE) InvalidateWindowClassesData(WC_STATION_LIST, 0);
	}

}


/**
 * Remove an order from the order list and delete it.
 * @param index is the position of the order which is to be deleted.
 */
void OrderList::DeleteOrderAt(int index)
{
	if (index >= this->num_orders) return;

	Order *to_remove;

	if (index == 0) {
		to_remove = this->first;
		this->first = to_remove->next;
	} else {
		Order *prev = GetOrderAt(index - 1);
		to_remove = prev->next;
		prev->next = to_remove->next;
	}
	--this->num_orders;
	if (!to_remove->IsType(OT_IMPLICIT)) --this->num_manual_orders;
	this->timetable_duration -= (to_remove->wait_time + to_remove->travel_time);
	delete to_remove;
}

/**
 * Move an order to another position within the order list.
 * @param from is the zero-based position of the order to move.
 * @param to is the zero-based position where the order is moved to.
 */
void OrderList::MoveOrder(int from, int to)
{
	if (from >= this->num_orders || to >= this->num_orders || from == to) return;

	Order *moving_one;

	/* Take the moving order out of the pointer-chain */
	if (from == 0) {
		moving_one = this->first;
		this->first = moving_one->next;
	} else {
		Order *one_before = GetOrderAt(from - 1);
		moving_one = one_before->next;
		one_before->next = moving_one->next;
	}

	/* Insert the moving_order again in the pointer-chain */
	if (to == 0) {
		moving_one->next = this->first;
		this->first = moving_one;
	} else {
		Order *one_before = GetOrderAt(to - 1);
		moving_one->next = one_before->next;
		one_before->next = moving_one;
	}
}

/**
 * Removes the vehicle from the shared order list.
 * @note This is supposed to be called when the vehicle is still in the chain
 * @param v vehicle to remove from the list
 */
void OrderList::RemoveVehicle(Vehicle *v)
{
	--this->num_vehicles;
	if (v == this->first_shared) this->first_shared = v->NextShared();
}

/**
 * Checks whether a vehicle is part of the shared vehicle chain.
 * @param v is the vehicle to search in the shared vehicle chain.
 */
bool OrderList::IsVehicleInSharedOrdersList(const Vehicle *v) const
{
	for (const Vehicle *v_shared = this->first_shared; v_shared != NULL; v_shared = v_shared->NextShared()) {
		if (v_shared == v) return true;
	}

	return false;
}

/**
 * Gets the position of the given vehicle within the shared order vehicle list.
 * @param v is the vehicle of which to get the position
 * @return position of v within the shared vehicle chain.
 */
int OrderList::GetPositionInSharedOrderList(const Vehicle *v) const
{
	int count = 0;
	for (const Vehicle *v_shared = v->PreviousShared(); v_shared != NULL; v_shared = v_shared->PreviousShared()) count++;
	return count;
}

/**
 * Checks whether all orders of the list have a filled timetable.
 * @return whether all orders have a filled timetable.
 */
bool OrderList::IsCompleteTimetable() const
{
	for (Order *o = this->first; o != NULL; o = o->next) {
		/* Implicit orders are, by definition, not timetabled. */
		if (o->IsType(OT_IMPLICIT)) continue;
		if (!o->IsCompletelyTimetabled()) return false;
	}
	return true;
}

/**
 * Checks for internal consistency of order list. Triggers assertion if something is wrong.
 */
void OrderList::DebugCheckSanity() const
{
	VehicleOrderID check_num_orders = 0;
	VehicleOrderID check_num_manual_orders = 0;
	uint check_num_vehicles = 0;
	Ticks check_timetable_duration = 0;

	DEBUG(misc, 6, "Checking OrderList %hu for sanity...", this->index);

	for (const Order *o = this->first; o != NULL; o = o->next) {
		++check_num_orders;
		if (!o->IsType(OT_IMPLICIT)) ++check_num_manual_orders;
		check_timetable_duration += o->wait_time + o->travel_time;
	}
	assert(this->num_orders == check_num_orders);
	assert(this->num_manual_orders == check_num_manual_orders);
	assert(this->timetable_duration == check_timetable_duration);

	for (const Vehicle *v = this->first_shared; v != NULL; v = v->NextShared()) {
		++check_num_vehicles;
		assert(v->orders.list == this);
	}
	assert(this->num_vehicles == check_num_vehicles);
	DEBUG(misc, 6, "... detected %u orders (%u manual), %u vehicles, %i ticks",
			(uint)this->num_orders, (uint)this->num_manual_orders,
			this->num_vehicles, this->timetable_duration);
}

/**
 * Checks whether the order goes to a station or not, i.e. whether the
 * destination is a station
 * @param v the vehicle to check for
 * @param o the order to check
 * @return true if the destination is a station
 */
static inline bool OrderGoesToStation(const Vehicle *v, const Order *o)
{
	return o->IsType(OT_GOTO_STATION) ||
			(v->type == VEH_AIRCRAFT && o->IsType(OT_GOTO_DEPOT) && !(o->GetDepotActionType() & ODATFB_NEAREST_DEPOT));
}

/**
 * Delete all news items regarding defective orders about a vehicle
 * This could kill still valid warnings (for example about void order when just
 * another order gets added), but assume the company will notice the problems,
 * when (s)he's changing the orders.
 */
static void DeleteOrderWarnings(const Vehicle *v)
{
	DeleteVehicleNews(v->index, STR_NEWS_VEHICLE_HAS_TOO_FEW_ORDERS);
	DeleteVehicleNews(v->index, STR_NEWS_VEHICLE_HAS_VOID_ORDER);
	DeleteVehicleNews(v->index, STR_NEWS_VEHICLE_HAS_DUPLICATE_ENTRY);
	DeleteVehicleNews(v->index, STR_NEWS_VEHICLE_HAS_INVALID_ENTRY);
}

/**
 * Returns a tile somewhat representing the order destination (not suitable for pathfinding).
 * @param v The vehicle to get the location for.
 * @param airport Get the airport tile and not the station location for aircraft.
 * @return destination of order, or INVALID_TILE if none.
 */
TileIndex Order::GetLocation(const Vehicle *v, bool airport) const
{
	switch (this->GetType()) {
		case OT_GOTO_WAYPOINT:
		case OT_GOTO_STATION:
		case OT_IMPLICIT:
			if (airport && v->type == VEH_AIRCRAFT) return Station::Get(this->GetDestination())->airport.tile;
			return BaseStation::Get(this->GetDestination())->xy;

		case OT_GOTO_DEPOT:
			if ((this->GetDepotActionType() & ODATFB_NEAREST_DEPOT) != 0) return INVALID_TILE;
			return (v->type == VEH_AIRCRAFT) ? Station::Get(this->GetDestination())->xy : Depot::Get(this->GetDestination())->xy;

		default:
			return INVALID_TILE;
	}
}

/**
 * Get the distance between two orders of a vehicle. Conditional orders are resolved
 * and the bigger distance of the two order branches is returned.
 * @param prev Origin order.
 * @param cur Destination order.
 * @param v The vehicle to get the distance for.
 * @param conditional_depth Internal param for resolving conditional orders.
 * @return Maximum distance between the two orders.
 */
uint GetOrderDistance(const Order *prev, const Order *cur, const Vehicle *v, int conditional_depth)
{
	if (cur->IsType(OT_CONDITIONAL)) {
		if (conditional_depth > v->GetNumOrders()) return 0;

		conditional_depth++;

		int dist1 = GetOrderDistance(prev, v->GetOrder(cur->GetConditionSkipToOrder()), v, conditional_depth);
		int dist2 = GetOrderDistance(prev, cur->next == NULL ? v->orders.list->GetFirstOrder() : cur->next, v, conditional_depth);
		return max(dist1, dist2);
	}

	TileIndex prev_tile = prev->GetLocation(v, true);
	TileIndex cur_tile = cur->GetLocation(v, true);
	if (prev_tile == INVALID_TILE || cur_tile == INVALID_TILE) return 0;
	return v->type == VEH_AIRCRAFT ? DistanceSquare(prev_tile, cur_tile) : DistanceManhattan(prev_tile, cur_tile);
}

/**
 * Add an order to the orderlist of a vehicle.
 * @param tile unused
 * @param flags operation to perform
 * @param p1 various bitstuffed elements
 * - p1 = (bit  0 - 19) - ID of the vehicle
 * - p1 = (bit 24 - 31) - the selected order (if any). If the last order is given,
 *                        the order will be inserted before that one
 *                        the maximum vehicle order id is 254.
 * @param p2 packed order to insert
 * @param text unused
 * @return the cost of this operation or an error
 */
CommandCost CmdInsertOrder(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
{
	VehicleID veh          = GB(p1,  0, 20);
	VehicleOrderID sel_ord = GB(p1, 20, 8);
	Order new_order(p2);

	Vehicle *v = Vehicle::GetIfValid(veh);
	if (v == NULL || !v->IsPrimaryVehicle()) return CMD_ERROR;

	CommandCost ret = CheckOwnership(v->owner);
	if (ret.Failed()) return ret;

	/* Check if the inserted order is to the correct destination (owner, type),
	 * and has the correct flags if any */
	switch (new_order.GetType()) {
		case OT_GOTO_STATION: {
			const Station *st = Station::GetIfValid(new_order.GetDestination());
			if (st == NULL) return CMD_ERROR;

			if (st->owner != OWNER_NONE) {
				CommandCost ret = CheckOwnership(st->owner);
				if (ret.Failed()) return ret;
			}

			if (!CanVehicleUseStation(v, st)) return_cmd_error(STR_ERROR_CAN_T_ADD_ORDER);
			for (Vehicle *u = v->FirstShared(); u != NULL; u = u->NextShared()) {
				if (!CanVehicleUseStation(u, st)) return_cmd_error(STR_ERROR_CAN_T_ADD_ORDER_SHARED);
			}

			/* Non stop only allowed for ground vehicles. */
			if (new_order.GetNonStopType() != ONSF_STOP_EVERYWHERE && !v->IsGroundVehicle()) return CMD_ERROR;

			/* Filter invalid load/unload types. */
			switch (new_order.GetLoadType()) {
				case OLF_LOAD_IF_POSSIBLE: case OLFB_FULL_LOAD: case OLF_FULL_LOAD_ANY: case OLFB_NO_LOAD: break;
				default: return CMD_ERROR;
			}
			switch (new_order.GetUnloadType()) {
				case OUF_UNLOAD_IF_POSSIBLE: case OUFB_UNLOAD: case OUFB_TRANSFER: case OUFB_NO_UNLOAD: break;
				default: return CMD_ERROR;
			}

			/* Filter invalid stop locations */
			switch (new_order.GetStopLocation()) {
				case OSL_PLATFORM_NEAR_END:
				case OSL_PLATFORM_MIDDLE:
					if (v->type != VEH_TRAIN) return CMD_ERROR;
					/* FALL THROUGH */
				case OSL_PLATFORM_FAR_END:
					break;

				default:
					return CMD_ERROR;
			}

			break;
		}

		case OT_GOTO_DEPOT: {
			if ((new_order.GetDepotActionType() & ODATFB_NEAREST_DEPOT) == 0) {
				if (v->type == VEH_AIRCRAFT) {
					const Station *st = Station::GetIfValid(new_order.GetDestination());

					if (st == NULL) return CMD_ERROR;

					CommandCost ret = CheckOwnership(st->owner);
					if (ret.Failed()) return ret;

					if (!CanVehicleUseStation(v, st) || !st->airport.HasHangar()) {
						return CMD_ERROR;
					}
				} else {
					const Depot *dp = Depot::GetIfValid(new_order.GetDestination());

					if (dp == NULL) return CMD_ERROR;

					CommandCost ret = CheckOwnership(GetTileOwner(dp->xy));
					if (ret.Failed()) return ret;

					switch (v->type) {
						case VEH_TRAIN:
							if (!IsRailDepotTile(dp->xy)) return CMD_ERROR;
							break;

						case VEH_ROAD:
							if (!IsRoadDepotTile(dp->xy)) return CMD_ERROR;
							break;

						case VEH_SHIP:
							if (!IsShipDepotTile(dp->xy)) return CMD_ERROR;
							break;

						default: return CMD_ERROR;
					}
				}
			}

			if (new_order.GetNonStopType() != ONSF_STOP_EVERYWHERE && !v->IsGroundVehicle()) return CMD_ERROR;
			if (new_order.GetDepotOrderType() & ~(ODTFB_PART_OF_ORDERS | ((new_order.GetDepotOrderType() & ODTFB_PART_OF_ORDERS) != 0 ? ODTFB_SERVICE : 0))) return CMD_ERROR;
			if (new_order.GetDepotActionType() & ~(ODATFB_HALT | ODATFB_NEAREST_DEPOT)) return CMD_ERROR;
			if ((new_order.GetDepotOrderType() & ODTFB_SERVICE) && (new_order.GetDepotActionType() & ODATFB_HALT)) return CMD_ERROR;
			break;
		}

		case OT_GOTO_WAYPOINT: {
			const Waypoint *wp = Waypoint::GetIfValid(new_order.GetDestination());
			if (wp == NULL) return CMD_ERROR;

			switch (v->type) {
				default: return CMD_ERROR;

				case VEH_TRAIN: {
					if (!(wp->facilities & FACIL_TRAIN)) return_cmd_error(STR_ERROR_CAN_T_ADD_ORDER);

					CommandCost ret = CheckOwnership(wp->owner);
					if (ret.Failed()) return ret;
					break;
				}

				case VEH_SHIP:
					if (!(wp->facilities & FACIL_DOCK)) return_cmd_error(STR_ERROR_CAN_T_ADD_ORDER);
					if (wp->owner != OWNER_NONE) {
						CommandCost ret = CheckOwnership(wp->owner);
						if (ret.Failed()) return ret;
					}
					break;
			}

			/* Order flags can be any of the following for waypoints:
			 * [non-stop]
			 * non-stop orders (if any) are only valid for trains */
			if (new_order.GetNonStopType() != ONSF_STOP_EVERYWHERE && v->type != VEH_TRAIN) return CMD_ERROR;
			break;
		}

		case OT_CONDITIONAL: {
			VehicleOrderID skip_to = new_order.GetConditionSkipToOrder();
			if (skip_to != 0 && skip_to >= v->GetNumOrders()) return CMD_ERROR; // Always allow jumping to the first (even when there is no order).
			if (new_order.GetConditionVariable() >= OCV_END) return CMD_ERROR;

			OrderConditionComparator occ = new_order.GetConditionComparator();
			if (occ >= OCC_END) return CMD_ERROR;
			switch (new_order.GetConditionVariable()) {
				case OCV_REQUIRES_SERVICE:
					if (occ != OCC_IS_TRUE && occ != OCC_IS_FALSE) return CMD_ERROR;
					break;

				case OCV_UNCONDITIONALLY:
					if (occ != OCC_EQUALS) return CMD_ERROR;
					if (new_order.GetConditionValue() != 0) return CMD_ERROR;
					break;

				case OCV_LOAD_PERCENTAGE:
				case OCV_RELIABILITY:
					if (new_order.GetConditionValue() > 100) return CMD_ERROR;
					/* FALL THROUGH */
				default:
					if (occ == OCC_IS_TRUE || occ == OCC_IS_FALSE) return CMD_ERROR;
					break;
			}
			break;
		}

		default: return CMD_ERROR;
	}

	if (sel_ord > v->GetNumOrders()) return CMD_ERROR;

	if (v->GetNumOrders() >= MAX_VEH_ORDER_ID) return_cmd_error(STR_ERROR_TOO_MANY_ORDERS);
	if (!Order::CanAllocateItem()) return_cmd_error(STR_ERROR_NO_MORE_SPACE_FOR_ORDERS);
	if (v->orders.list == NULL && !OrderList::CanAllocateItem()) return_cmd_error(STR_ERROR_NO_MORE_SPACE_FOR_ORDERS);

	if (v->type == VEH_SHIP && _settings_game.pf.pathfinder_for_ships != VPF_NPF) {
		/* Make sure the new destination is not too far away from the previous */
		const Order *prev = NULL;
		uint n = 0;

		/* Find the last goto station or depot order before the insert location.
		 * If the order is to be inserted at the beginning of the order list this
		 * finds the last order in the list. */
		const Order *o;
		FOR_VEHICLE_ORDERS(v, o) {
			switch (o->GetType()) {
				case OT_GOTO_STATION:
				case OT_GOTO_DEPOT:
				case OT_GOTO_WAYPOINT:
					prev = o;
					break;

				default: break;
			}
			if (++n == sel_ord && prev != NULL) break;
		}
		if (prev != NULL) {
			uint dist;
			if (new_order.IsType(OT_CONDITIONAL)) {
				/* The order is not yet inserted, so we have to do the first iteration here. */
				dist = GetOrderDistance(prev, v->GetOrder(new_order.GetConditionSkipToOrder()), v);
			} else {
				dist = GetOrderDistance(prev, &new_order, v);
			}

			if (dist >= 130) {
				return_cmd_error(STR_ERROR_TOO_FAR_FROM_PREVIOUS_DESTINATION);
			}
		}
	}

	if (flags & DC_EXEC) {
		Order *new_o = new Order();
		new_o->AssignOrder(new_order);
		InsertOrder(v, new_o, sel_ord);
	}

	return CommandCost();
}

/**
 * Insert a new order but skip the validation.
 * @param v       The vehicle to insert the order to.
 * @param new_o   The new order.
 * @param sel_ord The position the order should be inserted at.
 */
void InsertOrder(Vehicle *v, Order *new_o, VehicleOrderID sel_ord)
{
	/* Create new order and link in list */
	if (v->orders.list == NULL) {
		v->orders.list = new OrderList(new_o, v);
	} else {
		v->orders.list->InsertOrderAt(new_o, sel_ord);
	}

	Vehicle *u = v->FirstShared();
	DeleteOrderWarnings(u);
	for (; u != NULL; u = u->NextShared()) {
		assert(v->orders.list == u->orders.list);

		/* If there is added an order before the current one, we need
		 * to update the selected order. We do not change implicit/real order indices though.
		 * If the new order is between the current implicit order and real order, the implicit order will
		 * later skip the inserted order. */
		if (sel_ord <= u->cur_real_order_index) {
			uint cur = u->cur_real_order_index + 1;
			/* Check if we don't go out of bound */
			if (cur < u->GetNumOrders()) {
				u->cur_real_order_index = cur;
			}
		}
		if (sel_ord == u->cur_implicit_order_index && u->IsGroundVehicle()) {
			/* We are inserting an order just before the current implicit order.
			 * We do not know whether we will reach current implicit or the newly inserted order first.
			 * So, disable creation of implicit orders until we are on track again. */
			uint16 &gv_flags = u->GetGroundVehicleFlags();
			SetBit(gv_flags, GVF_SUPPRESS_IMPLICIT_ORDERS);
		}
		if (sel_ord <= u->cur_implicit_order_index) {
			uint cur = u->cur_implicit_order_index + 1;
			/* Check if we don't go out of bound */
			if (cur < u->GetNumOrders()) {
				u->cur_implicit_order_index = cur;
			}
		}
		/* Update any possible open window of the vehicle */
		InvalidateVehicleOrder(u, INVALID_VEH_ORDER_ID | (sel_ord << 8));
	}

	/* As we insert an order, the order to skip to will be 'wrong'. */
	VehicleOrderID cur_order_id = 0;
	Order *order;
	FOR_VEHICLE_ORDERS(v, order) {
		if (order->IsType(OT_CONDITIONAL)) {
			VehicleOrderID order_id = order->GetConditionSkipToOrder();
			if (order_id >= sel_ord) {
				order->SetConditionSkipToOrder(order_id + 1);
			}
			if (order_id == cur_order_id) {
				order->SetConditionSkipToOrder((order_id + 1) % v->GetNumOrders());
			}
		}
		cur_order_id++;
	}

	/* Make sure to rebuild the whole list */
	InvalidateWindowClassesData(GetWindowClassForVehicleType(v->type), 0);
}

/**
 * Declone an order-list
 * @param *dst delete the orders of this vehicle
 * @param flags execution flags
 */
static CommandCost DecloneOrder(Vehicle *dst, DoCommandFlag flags)
{
	if (flags & DC_EXEC) {
		DeleteVehicleOrders(dst);
		InvalidateVehicleOrder(dst, -1);
		InvalidateWindowClassesData(GetWindowClassForVehicleType(dst->type), 0);
	}
	return CommandCost();
}

/**
 * Delete an order from the orderlist of a vehicle.
 * @param tile unused
 * @param flags operation to perform
 * @param p1 the ID of the vehicle
 * @param p2 the order to delete (max 255)
 * @param text unused
 * @return the cost of this operation or an error
 */
CommandCost CmdDeleteOrder(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
{
	VehicleID veh_id = GB(p1, 0, 20);
	VehicleOrderID sel_ord = GB(p2, 0, 8);

	Vehicle *v = Vehicle::GetIfValid(veh_id);

	if (v == NULL || !v->IsPrimaryVehicle()) return CMD_ERROR;

	CommandCost ret = CheckOwnership(v->owner);
	if (ret.Failed()) return ret;

	/* If we did not select an order, we maybe want to de-clone the orders */
	if (sel_ord >= v->GetNumOrders()) return DecloneOrder(v, flags);

	if (v->GetOrder(sel_ord) == NULL) return CMD_ERROR;

	if (flags & DC_EXEC) DeleteOrder(v, sel_ord);
	return CommandCost();
}

/**
 * Cancel the current loading order of the vehicle as the order was deleted.
 * @param v the vehicle
 */
static void CancelLoadingDueToDeletedOrder(Vehicle *v)
{
	assert(v->current_order.IsType(OT_LOADING));
	/* NON-stop flag is misused to see if a train is in a station that is
	 * on his order list or not */
	v->current_order.SetNonStopType(ONSF_STOP_EVERYWHERE);
	/* When full loading, "cancel" that order so the vehicle doesn't
	 * stay indefinitely at this station anymore. */
	if (v->current_order.GetLoadType() & OLFB_FULL_LOAD) v->current_order.SetLoadType(OLF_LOAD_IF_POSSIBLE);
}

/**
 * Delete an order but skip the parameter validation.
 * @param v       The vehicle to delete the order from.
 * @param sel_ord The id of the order to be deleted.
 */
void DeleteOrder(Vehicle *v, VehicleOrderID sel_ord)
{
	v->orders.list->DeleteOrderAt(sel_ord);

	Vehicle *u = v->FirstShared();
	DeleteOrderWarnings(u);
	for (; u != NULL; u = u->NextShared()) {
		assert(v->orders.list == u->orders.list);

		if (sel_ord == u->cur_real_order_index && u->current_order.IsType(OT_LOADING)) {
			CancelLoadingDueToDeletedOrder(u);
		}

		if (sel_ord < u->cur_real_order_index) {
			u->cur_real_order_index--;
		} else if (sel_ord == u->cur_real_order_index) {
			u->UpdateRealOrderIndex();
		}

		if (sel_ord < u->cur_implicit_order_index) {
			u->cur_implicit_order_index--;
		} else if (sel_ord == u->cur_implicit_order_index) {
			/* Make sure the index is valid */
			if (u->cur_implicit_order_index >= u->GetNumOrders()) u->cur_implicit_order_index = 0;

			/* Skip non-implicit orders for the implicit-order-index (e.g. if the current implicit order was deleted */
			while (u->cur_implicit_order_index != u->cur_real_order_index && !u->GetOrder(u->cur_implicit_order_index)->IsType(OT_IMPLICIT)) {
				u->cur_implicit_order_index++;
				if (u->cur_implicit_order_index >= u->GetNumOrders()) u->cur_implicit_order_index = 0;
			}
		}

		/* Update any possible open window of the vehicle */
		InvalidateVehicleOrder(u, sel_ord | (INVALID_VEH_ORDER_ID << 8));
	}

	/* As we delete an order, the order to skip to will be 'wrong'. */
	VehicleOrderID cur_order_id = 0;
	Order *order = NULL;
	FOR_VEHICLE_ORDERS(v, order) {
		if (order->IsType(OT_CONDITIONAL)) {
			VehicleOrderID order_id = order->GetConditionSkipToOrder();
			if (order_id >= sel_ord) {
				order_id = max(order_id - 1, 0);
			}
			if (order_id == cur_order_id) {
				order_id = (order_id + 1) % v->GetNumOrders();
			}
			order->SetConditionSkipToOrder(order_id);
		}
		cur_order_id++;
	}

	InvalidateWindowClassesData(GetWindowClassForVehicleType(v->type), 0);
}

/**
 * Goto order of order-list.
 * @param tile unused
 * @param flags operation to perform
 * @param p1 The ID of the vehicle which order is skipped
 * @param p2 the selected order to which we want to skip
 * @param text unused
 * @return the cost of this operation or an error
 */
CommandCost CmdSkipToOrder(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
{
	VehicleID veh_id = GB(p1, 0, 20);
	VehicleOrderID sel_ord = GB(p2, 0, 8);

	Vehicle *v = Vehicle::GetIfValid(veh_id);

	if (v == NULL || !v->IsPrimaryVehicle() || sel_ord == v->cur_implicit_order_index || sel_ord >= v->GetNumOrders() || v->GetNumOrders() < 2) return CMD_ERROR;

	CommandCost ret = CheckOwnership(v->owner);
	if (ret.Failed()) return ret;

	if (flags & DC_EXEC) {
		v->cur_implicit_order_index = v->cur_real_order_index = sel_ord;
		v->UpdateRealOrderIndex();

		if (v->current_order.IsType(OT_LOADING)) v->LeaveStation();

		InvalidateVehicleOrder(v, -2);
	}

	/* We have an aircraft/ship, they have a mini-schedule, so update them all */
	if (v->type == VEH_AIRCRAFT) SetWindowClassesDirty(WC_AIRCRAFT_LIST);
	if (v->type == VEH_SHIP) SetWindowClassesDirty(WC_SHIPS_LIST);

	return CommandCost();
}

/**
 * Move an order inside the orderlist
 * @param tile unused
 * @param flags operation to perform
 * @param p1 the ID of the vehicle
 * @param p2 order to move and target
 *           bit 0-15  : the order to move
 *           bit 16-31 : the target order
 * @param text unused
 * @return the cost of this operation or an error
 * @note The target order will move one place down in the orderlist
 *  if you move the order upwards else it'll move it one place down
 */
CommandCost CmdMoveOrder(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
{
	VehicleID veh = GB(p1, 0, 20);
	VehicleOrderID moving_order = GB(p2,  0, 16);
	VehicleOrderID target_order = GB(p2, 16, 16);

	Vehicle *v = Vehicle::GetIfValid(veh);
	if (v == NULL || !v->IsPrimaryVehicle()) return CMD_ERROR;

	CommandCost ret = CheckOwnership(v->owner);
	if (ret.Failed()) return ret;

	/* Don't make senseless movements */
	if (moving_order >= v->GetNumOrders() || target_order >= v->GetNumOrders() ||
			moving_order == target_order || v->GetNumOrders() <= 1) return CMD_ERROR;

	Order *moving_one = v->GetOrder(moving_order);
	/* Don't move an empty order */
	if (moving_one == NULL) return CMD_ERROR;

	if (flags & DC_EXEC) {
		v->orders.list->MoveOrder(moving_order, target_order);

		/* Update shared list */
		Vehicle *u = v->FirstShared();

		DeleteOrderWarnings(u);

		for (; u != NULL; u = u->NextShared()) {
			/* Update the current order.
			 * There are multiple ways to move orders, which result in cur_implicit_order_index
			 * and cur_real_order_index to not longer make any sense. E.g. moving another
			 * real order between them.
			 *
			 * Basically one could choose to preserve either of them, but not both.
			 * While both ways are suitable in this or that case from a human point of view, neither
			 * of them makes really sense.
			 * However, from an AI point of view, preserving cur_real_order_index is the most
			 * predictable and transparent behaviour.
			 *
			 * With that decision it basically does not matter what we do to cur_implicit_order_index.
			 * If we change orders between the implict- and real-index, the implicit orders are mostly likely
			 * completely out-dated anyway. So, keep it simple and just keep cur_implicit_order_index as well.
			 * The worst which can happen is that a lot of implicit orders are removed when reaching current_order.
			 */
			if (u->cur_real_order_index == moving_order) {
				u->cur_real_order_index = target_order;
			} else if (u->cur_real_order_index > moving_order && u->cur_real_order_index <= target_order) {
				u->cur_real_order_index--;
			} else if (u->cur_real_order_index < moving_order && u->cur_real_order_index >= target_order) {
				u->cur_real_order_index++;
			}

			if (u->cur_implicit_order_index == moving_order) {
				u->cur_implicit_order_index = target_order;
			} else if (u->cur_implicit_order_index > moving_order && u->cur_implicit_order_index <= target_order) {
				u->cur_implicit_order_index--;
			} else if (u->cur_implicit_order_index < moving_order && u->cur_implicit_order_index >= target_order) {
				u->cur_implicit_order_index++;
			}

			assert(v->orders.list == u->orders.list);
			/* Update any possible open window of the vehicle */
			InvalidateVehicleOrder(u, moving_order | (target_order << 8));
		}

		/* As we move an order, the order to skip to will be 'wrong'. */
		Order *order;
		FOR_VEHICLE_ORDERS(v, order) {
			if (order->IsType(OT_CONDITIONAL)) {
				VehicleOrderID order_id = order->GetConditionSkipToOrder();
				if (order_id == moving_order) {
					order_id = target_order;
				} else if (order_id > moving_order && order_id <= target_order) {
					order_id--;
				} else if (order_id < moving_order && order_id >= target_order) {
					order_id++;
				}
				order->SetConditionSkipToOrder(order_id);
			}
		}

		/* Make sure to rebuild the whole list */
		InvalidateWindowClassesData(GetWindowClassForVehicleType(v->type), 0);
	}

	return CommandCost();
}

/**
 * Modify an order in the orderlist of a vehicle.
 * @param tile unused
 * @param flags operation to perform
 * @param p1 various bitstuffed elements
 * - p1 = (bit  0 - 19) - ID of the vehicle
 * - p1 = (bit 24 - 31) - the selected order (if any). If the last order is given,
 *                        the order will be inserted before that one
 *                        the maximum vehicle order id is 254.
 * @param p2 various bitstuffed elements
 *  - p2 = (bit 0 -  3) - what data to modify (@see ModifyOrderFlags)
 *  - p2 = (bit 4 - 15) - the data to modify
 * @param text unused
 * @return the cost of this operation or an error
 */
CommandCost CmdModifyOrder(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
{
	VehicleOrderID sel_ord = GB(p1, 20,  8);
	VehicleID veh          = GB(p1,  0, 20);
	ModifyOrderFlags mof   = Extract<ModifyOrderFlags, 0, 4>(p2);
	uint16 data            = GB(p2,  4, 11);

	if (mof >= MOF_END) return CMD_ERROR;

	Vehicle *v = Vehicle::GetIfValid(veh);
	if (v == NULL || !v->IsPrimaryVehicle()) return CMD_ERROR;

	CommandCost ret = CheckOwnership(v->owner);
	if (ret.Failed()) return ret;

	/* Is it a valid order? */
	if (sel_ord >= v->GetNumOrders()) return CMD_ERROR;

	Order *order = v->GetOrder(sel_ord);
	switch (order->GetType()) {
		case OT_GOTO_STATION:
			if (mof == MOF_COND_VARIABLE || mof == MOF_COND_COMPARATOR || mof == MOF_DEPOT_ACTION || mof == MOF_COND_VALUE) return CMD_ERROR;
			break;

		case OT_GOTO_DEPOT:
			if (mof != MOF_NON_STOP && mof != MOF_DEPOT_ACTION) return CMD_ERROR;
			break;

		case OT_GOTO_WAYPOINT:
			if (mof != MOF_NON_STOP) return CMD_ERROR;
			break;

		case OT_CONDITIONAL:
			if (mof != MOF_COND_VARIABLE && mof != MOF_COND_COMPARATOR && mof != MOF_COND_VALUE && mof != MOF_COND_DESTINATION) return CMD_ERROR;
			break;

		default:
			return CMD_ERROR;
	}

	switch (mof) {
		default: NOT_REACHED();

		case MOF_NON_STOP:
			if (!v->IsGroundVehicle()) return CMD_ERROR;
			if (data >= ONSF_END) return CMD_ERROR;
			if (data == order->GetNonStopType()) return CMD_ERROR;
			break;

		case MOF_STOP_LOCATION:
			if (v->type != VEH_TRAIN) return CMD_ERROR;
			if (data >= OSL_END) return CMD_ERROR;
			break;

		case MOF_UNLOAD:
			if ((data & ~(OUFB_UNLOAD | OUFB_TRANSFER | OUFB_NO_UNLOAD)) != 0) return CMD_ERROR;
			/* Unload and no-unload are mutual exclusive and so are transfer and no unload. */
			if (data != 0 && ((data & (OUFB_UNLOAD | OUFB_TRANSFER)) != 0) == ((data & OUFB_NO_UNLOAD) != 0)) return CMD_ERROR;
			if (data == order->GetUnloadType()) return CMD_ERROR;
			break;

		case MOF_LOAD:
			if (data > OLFB_NO_LOAD || data == 1) return CMD_ERROR;
			if (data == order->GetLoadType()) return CMD_ERROR;
			break;

		case MOF_DEPOT_ACTION:
			if (data >= DA_END) return CMD_ERROR;
			break;

		case MOF_COND_VARIABLE:
			if (data >= OCV_END) return CMD_ERROR;
			break;

		case MOF_COND_COMPARATOR:
			if (data >= OCC_END) return CMD_ERROR;
			switch (order->GetConditionVariable()) {
				case OCV_UNCONDITIONALLY: return CMD_ERROR;

				case OCV_REQUIRES_SERVICE:
					if (data != OCC_IS_TRUE && data != OCC_IS_FALSE) return CMD_ERROR;
					break;

				default:
					if (data == OCC_IS_TRUE || data == OCC_IS_FALSE) return CMD_ERROR;
					break;
			}
			break;

		case MOF_COND_VALUE:
			switch (order->GetConditionVariable()) {
				case OCV_UNCONDITIONALLY: return CMD_ERROR;

				case OCV_LOAD_PERCENTAGE:
				case OCV_RELIABILITY:
					if (data > 100) return CMD_ERROR;
					break;

				default:
					if (data > 2047) return CMD_ERROR;
					break;
			}
			break;

		case MOF_COND_DESTINATION:
			if (data >= v->GetNumOrders()) return CMD_ERROR;
			break;
	}

	if (flags & DC_EXEC) {
		switch (mof) {
			case MOF_NON_STOP:
				order->SetNonStopType((OrderNonStopFlags)data);
				if (data & ONSF_NO_STOP_AT_DESTINATION_STATION) order->SetRefit(CT_NO_REFIT);
				break;

			case MOF_STOP_LOCATION:
				order->SetStopLocation((OrderStopLocation)data);
				break;

			case MOF_UNLOAD:
				order->SetUnloadType((OrderUnloadFlags)data);
				break;

			case MOF_LOAD:
				order->SetLoadType((OrderLoadFlags)data);
				if (data & OLFB_NO_LOAD) order->SetRefit(CT_NO_REFIT);
				break;

			case MOF_DEPOT_ACTION: {
				switch (data) {
					case DA_ALWAYS_GO:
						order->SetDepotOrderType((OrderDepotTypeFlags)(order->GetDepotOrderType() & ~ODTFB_SERVICE));
						order->SetDepotActionType((OrderDepotActionFlags)(order->GetDepotActionType() & ~ODATFB_HALT));
						break;

					case DA_SERVICE:
						order->SetDepotOrderType((OrderDepotTypeFlags)(order->GetDepotOrderType() | ODTFB_SERVICE));
						order->SetDepotActionType((OrderDepotActionFlags)(order->GetDepotActionType() & ~ODATFB_HALT));
						order->SetRefit(CT_NO_REFIT);
						break;

					case DA_STOP:
						order->SetDepotOrderType((OrderDepotTypeFlags)(order->GetDepotOrderType() & ~ODTFB_SERVICE));
						order->SetDepotActionType((OrderDepotActionFlags)(order->GetDepotActionType() | ODATFB_HALT));
						order->SetRefit(CT_NO_REFIT);
						break;

					default:
						NOT_REACHED();
				}
				break;
			}

			case MOF_COND_VARIABLE: {
				order->SetConditionVariable((OrderConditionVariable)data);

				OrderConditionComparator occ = order->GetConditionComparator();
				switch (order->GetConditionVariable()) {
					case OCV_UNCONDITIONALLY:
						order->SetConditionComparator(OCC_EQUALS);
						order->SetConditionValue(0);
						break;

					case OCV_REQUIRES_SERVICE:
						if (occ != OCC_IS_TRUE && occ != OCC_IS_FALSE) order->SetConditionComparator(OCC_IS_TRUE);
						break;

					case OCV_LOAD_PERCENTAGE:
					case OCV_RELIABILITY:
						if (order->GetConditionValue() > 100) order->SetConditionValue(100);
						/* FALL THROUGH */
					default:
						if (occ == OCC_IS_TRUE || occ == OCC_IS_FALSE) order->SetConditionComparator(OCC_EQUALS);
						break;
				}
				break;
			}

			case MOF_COND_COMPARATOR:
				order->SetConditionComparator((OrderConditionComparator)data);
				break;

			case MOF_COND_VALUE:
				order->SetConditionValue(data);
				break;

			case MOF_COND_DESTINATION:
				order->SetConditionSkipToOrder(data);
				break;

			default: NOT_REACHED();
		}

		/* Update the windows and full load flags, also for vehicles that share the same order list */
		Vehicle *u = v->FirstShared();
		DeleteOrderWarnings(u);
		for (; u != NULL; u = u->NextShared()) {
			/* Toggle u->current_order "Full load" flag if it changed.
			 * However, as the same flag is used for depot orders, check
			 * whether we are not going to a depot as there are three
			 * cases where the full load flag can be active and only
			 * one case where the flag is used for depot orders. In the
			 * other cases for the OrderTypeByte the flags are not used,
			 * so do not care and those orders should not be active
			 * when this function is called.
			 */
			if (sel_ord == u->cur_real_order_index &&
					(u->current_order.IsType(OT_GOTO_STATION) || u->current_order.IsType(OT_LOADING)) &&
					u->current_order.GetLoadType() != order->GetLoadType()) {
				u->current_order.SetLoadType(order->GetLoadType());
			}
			InvalidateVehicleOrder(u, -2);
		}
	}

	return CommandCost();
}

/**
 * Check if an aircraft has enough range for an order list.
 * @param v_new Aircraft to check.
 * @param v_order Vehicle currently holding the order list.
 * @param first First order in the source order list.
 * @return True if the aircraft has enough range for the orders, false otherwise.
 */
static bool CheckAircraftOrderDistance(const Aircraft *v_new, const Vehicle *v_order, const Order *first)
{
	if (first == NULL || v_new->acache.cached_max_range == 0) return true;

	/* Iterate over all orders to check the distance between all
	 * 'goto' orders and their respective next order (of any type). */
	for (const Order *o = first; o != NULL; o = o->next) {
		switch (o->GetType()) {
			case OT_GOTO_STATION:
			case OT_GOTO_DEPOT:
			case OT_GOTO_WAYPOINT:
				/* If we don't have a next order, we've reached the end and must check the first order instead. */
				if (GetOrderDistance(o, o->next != NULL ? o->next : first, v_order) > v_new->acache.cached_max_range_sqr) return false;
				break;

			default: break;
		}
	}

	return true;
}

/**
 * Clone/share/copy an order-list of another vehicle.
 * @param tile unused
 * @param flags operation to perform
 * @param p1 various bitstuffed elements
 * - p1 = (bit  0-19) - destination vehicle to clone orders to
 * - p1 = (bit 30-31) - action to perform
 * @param p2 source vehicle to clone orders from, if any (none for CO_UNSHARE)
 * @param text unused
 * @return the cost of this operation or an error
 */
CommandCost CmdCloneOrder(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
{
	VehicleID veh_src = GB(p2, 0, 20);
	VehicleID veh_dst = GB(p1, 0, 20);

	Vehicle *dst = Vehicle::GetIfValid(veh_dst);
	if (dst == NULL || !dst->IsPrimaryVehicle()) return CMD_ERROR;

	CommandCost ret = CheckOwnership(dst->owner);
	if (ret.Failed()) return ret;

	switch (GB(p1, 30, 2)) {
		case CO_SHARE: {
			Vehicle *src = Vehicle::GetIfValid(veh_src);

			/* Sanity checks */
			if (src == NULL || !src->IsPrimaryVehicle() || dst->type != src->type || dst == src) return CMD_ERROR;

			CommandCost ret = CheckOwnership(src->owner);
			if (ret.Failed()) return ret;

			/* Trucks can't share orders with busses (and visa versa) */
			if (src->type == VEH_ROAD && RoadVehicle::From(src)->IsBus() != RoadVehicle::From(dst)->IsBus()) {
				return CMD_ERROR;
			}

			/* Is the vehicle already in the shared list? */
			if (src->FirstShared() == dst->FirstShared()) return CMD_ERROR;

			const Order *order;

			FOR_VEHICLE_ORDERS(src, order) {
				if (!OrderGoesToStation(dst, order)) continue;

				/* Allow copying unreachable destinations if they were already unreachable for the source.
				 * This is basically to allow cloning / autorenewing / autoreplacing vehicles, while the stations
				 * are temporarily invalid due to reconstruction. */
				const Station *st = Station::Get(order->GetDestination());
				if (CanVehicleUseStation(src, st) && !CanVehicleUseStation(dst, st)) {
					return_cmd_error(STR_ERROR_CAN_T_COPY_SHARE_ORDER);
				}
			}

			/* Check for aircraft range limits. */
			if (dst->type == VEH_AIRCRAFT && !CheckAircraftOrderDistance(Aircraft::From(dst), src, src->GetFirstOrder())) {
				return_cmd_error(STR_ERROR_AIRCRAFT_NOT_ENOUGH_RANGE);
			}

			if (src->orders.list == NULL && !OrderList::CanAllocateItem()) {
				return_cmd_error(STR_ERROR_NO_MORE_SPACE_FOR_ORDERS);
			}

			if (flags & DC_EXEC) {
				/* If the destination vehicle had a OrderList, destroy it.
				 * We only reset the order indices, if the new orders are obviously different.
				 * (We mainly do this to keep the order indices valid and in range.) */
				DeleteVehicleOrders(dst, false, dst->GetNumOrders() != src->GetNumOrders());

				dst->orders.list = src->orders.list;

				/* Link this vehicle in the shared-list */
				dst->AddToShared(src);

				InvalidateVehicleOrder(dst, -1);
				InvalidateVehicleOrder(src, -2);

				InvalidateWindowClassesData(GetWindowClassForVehicleType(dst->type), 0);
			}
			break;
		}

		case CO_COPY: {
			Vehicle *src = Vehicle::GetIfValid(veh_src);

			/* Sanity checks */
			if (src == NULL || !src->IsPrimaryVehicle() || dst->type != src->type || dst == src) return CMD_ERROR;

			CommandCost ret = CheckOwnership(src->owner);
			if (ret.Failed()) return ret;

			/* Trucks can't copy all the orders from busses (and visa versa),
			 * and neither can helicopters and aircarft. */
			const Order *order;
			FOR_VEHICLE_ORDERS(src, order) {
				if (OrderGoesToStation(dst, order) &&
						!CanVehicleUseStation(dst, Station::Get(order->GetDestination()))) {
					return_cmd_error(STR_ERROR_CAN_T_COPY_SHARE_ORDER);
				}
			}

			/* Check for aircraft range limits. */
			if (dst->type == VEH_AIRCRAFT && !CheckAircraftOrderDistance(Aircraft::From(dst), src, src->GetFirstOrder())) {
				return_cmd_error(STR_ERROR_AIRCRAFT_NOT_ENOUGH_RANGE);
			}

			/* make sure there are orders available */
			if (!Order::CanAllocateItem(src->GetNumOrders()) || !OrderList::CanAllocateItem()) {
				return_cmd_error(STR_ERROR_NO_MORE_SPACE_FOR_ORDERS);
			}

			if (flags & DC_EXEC) {
				const Order *order;
				Order *first = NULL;
				Order **order_dst;

				/* If the destination vehicle had an order list, destroy the chain but keep the OrderList.
				 * We only reset the order indices, if the new orders are obviously different.
				 * (We mainly do this to keep the order indices valid and in range.) */
				DeleteVehicleOrders(dst, true, dst->GetNumOrders() != src->GetNumOrders());

				order_dst = &first;
				FOR_VEHICLE_ORDERS(src, order) {
					*order_dst = new Order();
					(*order_dst)->AssignOrder(*order);
					order_dst = &(*order_dst)->next;
				}
				if (dst->orders.list == NULL) {
					dst->orders.list = new OrderList(first, dst);
				} else {
					assert(dst->orders.list->GetFirstOrder() == NULL);
					assert(!dst->orders.list->IsShared());
					delete dst->orders.list;
					assert(OrderList::CanAllocateItem());
					dst->orders.list = new OrderList(first, dst);
				}

				InvalidateVehicleOrder(dst, -1);

				InvalidateWindowClassesData(GetWindowClassForVehicleType(dst->type), 0);
			}
			break;
		}

		case CO_UNSHARE: return DecloneOrder(dst, flags);
		default: return CMD_ERROR;
	}

	return CommandCost();
}

/**
 * Add/remove refit orders from an order
 * @param tile Not used
 * @param flags operation to perform
 * @param p1 VehicleIndex of the vehicle having the order
 * @param p2 bitmask
 *   - bit 0-7 CargoID
 *   - bit 8-15 Cargo subtype
 *   - bit 16-23 number of order to modify
 * @param text unused
 * @return the cost of this operation or an error
 */
CommandCost CmdOrderRefit(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
{
	VehicleID veh = GB(p1, 0, 20);
	VehicleOrderID order_number  = GB(p2, 16, 8);
	CargoID cargo = GB(p2, 0, 8);
	byte subtype  = GB(p2, 8, 8);

	if (cargo >= NUM_CARGO && cargo != CT_NO_REFIT && cargo != CT_AUTO_REFIT) return CMD_ERROR;

	const Vehicle *v = Vehicle::GetIfValid(veh);
	if (v == NULL || !v->IsPrimaryVehicle()) return CMD_ERROR;

	CommandCost ret = CheckOwnership(v->owner);
	if (ret.Failed()) return ret;

	Order *order = v->GetOrder(order_number);
	if (order == NULL) return CMD_ERROR;

	/* Automatic refit cargo is only supported for goto station orders. */
	if (cargo == CT_AUTO_REFIT && !order->IsType(OT_GOTO_STATION)) return CMD_ERROR;

	if (flags & DC_EXEC) {
		order->SetRefit(cargo, subtype);

		/* Make the depot order an 'always go' order. */
		if (cargo != CT_NO_REFIT && order->IsType(OT_GOTO_DEPOT)) {
			order->SetDepotOrderType((OrderDepotTypeFlags)(order->GetDepotOrderType() & ~ODTFB_SERVICE));
			order->SetDepotActionType((OrderDepotActionFlags)(order->GetDepotActionType() & ~ODATFB_HALT));
		}

		for (Vehicle *u = v->FirstShared(); u != NULL; u = u->NextShared()) {
			/* Update any possible open window of the vehicle */
			InvalidateVehicleOrder(u, -2);

			/* If the vehicle already got the current depot set as current order, then update current order as well */
			if (u->cur_real_order_index == order_number && (u->current_order.GetDepotOrderType() & ODTFB_PART_OF_ORDERS)) {
				u->current_order.SetRefit(cargo, subtype);
			}
		}
	}

	return CommandCost();
}


/**
 *
 * Check the orders of a vehicle, to see if there are invalid orders and stuff
 *
 */
void CheckOrders(const Vehicle *v)
{
	/* Does the user wants us to check things? */
	if (_settings_client.gui.order_review_system == 0) return;

	/* Do nothing for crashed vehicles */
	if (v->vehstatus & VS_CRASHED) return;

	/* Do nothing for stopped vehicles if setting is '1' */
	if (_settings_client.gui.order_review_system == 1 && (v->vehstatus & VS_STOPPED)) return;

	/* do nothing we we're not the first vehicle in a share-chain */
	if (v->FirstShared() != v) return;

	/* Only check every 20 days, so that we don't flood the message log */
	if (v->owner == _local_company && v->day_counter % 20 == 0) {
		int n_st, problem_type = -1;
		const Order *order;
		int message = 0;

		/* Check the order list */
		n_st = 0;

		FOR_VEHICLE_ORDERS(v, order) {
			/* Dummy order? */
			if (order->IsType(OT_DUMMY)) {
				problem_type = 1;
				break;
			}
			/* Does station have a load-bay for this vehicle? */
			if (order->IsType(OT_GOTO_STATION)) {
				const Station *st = Station::Get(order->GetDestination());

				n_st++;
				if (!CanVehicleUseStation(v, st)) problem_type = 3;
			}
		}

		/* Check if the last and the first order are the same */
		if (v->GetNumOrders() > 1) {
			const Order *last = v->GetLastOrder();

			if (v->orders.list->GetFirstOrder()->Equals(*last)) {
				problem_type = 2;
			}
		}

		/* Do we only have 1 station in our order list? */
		if (n_st < 2 && problem_type == -1) problem_type = 0;

#ifndef NDEBUG
		if (v->orders.list != NULL) v->orders.list->DebugCheckSanity();
#endif

		/* We don't have a problem */
		if (problem_type < 0) return;

		message = STR_NEWS_VEHICLE_HAS_TOO_FEW_ORDERS + problem_type;
		//DEBUG(misc, 3, "Triggered News Item for vehicle %d", v->index);

		SetDParam(0, v->index);
		AddVehicleAdviceNewsItem(message, v->index);
	}
}

/**
 * Removes an order from all vehicles. Triggers when, say, a station is removed.
 * @param type The type of the order (OT_GOTO_[STATION|DEPOT|WAYPOINT]).
 * @param destination The destination. Can be a StationID, DepotID or WaypointID.
 */
void RemoveOrderFromAllVehicles(OrderType type, DestinationID destination)
{
	Vehicle *v;

	/* Aircraft have StationIDs for depot orders and never use DepotIDs
	 * This fact is handled specially below
	 */

	/* Go through all vehicles */
	FOR_ALL_VEHICLES(v) {
		Order *order;

		order = &v->current_order;
		if ((v->type == VEH_AIRCRAFT && order->IsType(OT_GOTO_DEPOT) ? OT_GOTO_STATION : order->GetType()) == type &&
				v->current_order.GetDestination() == destination) {
			order->MakeDummy();
			SetWindowDirty(WC_VEHICLE_VIEW, v->index);
		}

		/* Clear the order from the order-list */
		int id = -1;
		FOR_VEHICLE_ORDERS(v, order) {
			id++;
restart:

			OrderType ot = order->GetType();
			if (ot == OT_GOTO_DEPOT && (order->GetDepotActionType() & ODATFB_NEAREST_DEPOT) != 0) continue;
			if (ot == OT_IMPLICIT || (v->type == VEH_AIRCRAFT && ot == OT_GOTO_DEPOT)) ot = OT_GOTO_STATION;
			if (ot == type && order->GetDestination() == destination) {
				/* We want to clear implicit orders, but we don't want to make them
				 * dummy orders. They should just vanish. Also check the actual order
				 * type as ot is currently OT_GOTO_STATION. */
				if (order->IsType(OT_IMPLICIT)) {
					order = order->next; // DeleteOrder() invalidates current order
					DeleteOrder(v, id);
					if (order != NULL) goto restart;
					break;
				}

				order->MakeDummy();
				for (const Vehicle *w = v->FirstShared(); w != NULL; w = w->NextShared()) {
					/* In GUI, simulate by removing the order and adding it back */
					InvalidateVehicleOrder(w, id | (INVALID_VEH_ORDER_ID << 8));
					InvalidateVehicleOrder(w, (INVALID_VEH_ORDER_ID << 8) | id);
				}
			}
		}
	}

	OrderBackup::RemoveOrder(type, destination);
}

/**
 * Checks if a vehicle has a depot in its order list.
 * @return True iff at least one order is a depot order.
 */
bool Vehicle::HasDepotOrder() const
{
	const Order *order;

	FOR_VEHICLE_ORDERS(this, order) {
		if (order->IsType(OT_GOTO_DEPOT)) return true;
	}

	return false;
}

/**
 * Delete all orders from a vehicle
 * @param v                   Vehicle whose orders to reset
 * @param keep_orderlist      If true, do not free the order list, only empty it.
 * @param reset_order_indices If true, reset cur_implicit_order_index and cur_real_order_index
 *                            and cancel the current full load order (if the vehicle is loading).
 *                            If false, _you_ have to make sure the order indices are valid after
 *                            your messing with them!
 */
void DeleteVehicleOrders(Vehicle *v, bool keep_orderlist, bool reset_order_indices)
{
	DeleteOrderWarnings(v);

	if (v->IsOrderListShared()) {
		/* Remove ourself from the shared order list. */
		v->RemoveFromShared();
		v->orders.list = NULL;
	} else if (v->orders.list != NULL) {
		/* Remove the orders */
		v->orders.list->FreeChain(keep_orderlist);
		if (!keep_orderlist) v->orders.list = NULL;
	}

	if (reset_order_indices) {
		v->cur_implicit_order_index = v->cur_real_order_index = 0;
		if (v->current_order.IsType(OT_LOADING)) {
			CancelLoadingDueToDeletedOrder(v);
		}
	}
}

/**
 * Clamp the service interval to the correct min/max. The actual min/max values
 * depend on whether it's in percent or days.
 * @param interval proposed service interval
 * @param company_id the owner of the vehicle
 * @return Clamped service interval
 */
uint16 GetServiceIntervalClamped(uint interval, CompanyID company_id)
{
	return (Company::Get(company_id)->settings.vehicle.servint_ispercent) ? Clamp(interval, MIN_SERVINT_PERCENT, MAX_SERVINT_PERCENT) : Clamp(interval, MIN_SERVINT_DAYS, MAX_SERVINT_DAYS);
}

/**
 *
 * Check if a vehicle has any valid orders
 *
 * @return false if there are no valid orders
 * @note Conditional orders are not considered valid destination orders
 *
 */
static bool CheckForValidOrders(const Vehicle *v)
{
	const Order *order;

	FOR_VEHICLE_ORDERS(v, order) {
		switch (order->GetType()) {
			case OT_GOTO_STATION:
			case OT_GOTO_DEPOT:
			case OT_GOTO_WAYPOINT:
				return true;

			default:
				break;
		}
	}

	return false;
}

/**
 * Compare the variable and value based on the given comparator.
 */
static bool OrderConditionCompare(OrderConditionComparator occ, int variable, int value)
{
	switch (occ) {
		case OCC_EQUALS:      return variable == value;
		case OCC_NOT_EQUALS:  return variable != value;
		case OCC_LESS_THAN:   return variable <  value;
		case OCC_LESS_EQUALS: return variable <= value;
		case OCC_MORE_THAN:   return variable >  value;
		case OCC_MORE_EQUALS: return variable >= value;
		case OCC_IS_TRUE:     return variable != 0;
		case OCC_IS_FALSE:    return variable == 0;
		default: NOT_REACHED();
	}
}

/**
 * Process a conditional order and determine the next order.
 * @param order the order the vehicle currently has
 * @param v the vehicle to update
 * @return index of next order to jump to, or INVALID_VEH_ORDER_ID to use the next order
 */
VehicleOrderID ProcessConditionalOrder(const Order *order, const Vehicle *v)
{
	if (order->GetType() != OT_CONDITIONAL) return INVALID_VEH_ORDER_ID;

	bool skip_order = false;
	OrderConditionComparator occ = order->GetConditionComparator();
	uint16 value = order->GetConditionValue();

	switch (order->GetConditionVariable()) {
		case OCV_LOAD_PERCENTAGE:    skip_order = OrderConditionCompare(occ, CalcPercentVehicleFilled(v, NULL), value); break;
		case OCV_RELIABILITY:        skip_order = OrderConditionCompare(occ, ToPercent16(v->reliability),       value); break;
		case OCV_MAX_SPEED:          skip_order = OrderConditionCompare(occ, v->GetDisplayMaxSpeed() * 10 / 16, value); break;
		case OCV_AGE:                skip_order = OrderConditionCompare(occ, v->age / DAYS_IN_LEAP_YEAR,        value); break;
		case OCV_REQUIRES_SERVICE:   skip_order = OrderConditionCompare(occ, v->NeedsServicing(),               value); break;
		case OCV_UNCONDITIONALLY:    skip_order = true; break;
		case OCV_REMAINING_LIFETIME: skip_order = OrderConditionCompare(occ, max(v->max_age - v->age + DAYS_IN_LEAP_YEAR - 1, 0) / DAYS_IN_LEAP_YEAR, value); break;
		default: NOT_REACHED();
	}

	return skip_order ? order->GetConditionSkipToOrder() : (VehicleOrderID)INVALID_VEH_ORDER_ID;
}

/**
 * Update the vehicle's destination tile from an order.
 * @param order the order the vehicle currently has
 * @param v the vehicle to update
 * @param conditional_depth the depth (amount of steps) to go with conditional orders. This to prevent infinite loops.
 * @param pbs_look_ahead Whether we are forecasting orders for pbs reservations in advance. If true, the order indices must not be modified.
 */
bool UpdateOrderDest(Vehicle *v, const Order *order, int conditional_depth, bool pbs_look_ahead)
{
	if (conditional_depth > v->GetNumOrders()) return false;

	switch (order->GetType()) {
		case OT_GOTO_STATION:
			v->dest_tile = v->GetOrderStationLocation(order->GetDestination());
			return true;

		case OT_GOTO_DEPOT:
			if ((order->GetDepotOrderType() & ODTFB_SERVICE) && !v->NeedsServicing()) {
				assert(!pbs_look_ahead);
				UpdateVehicleTimetable(v, true);
				v->IncrementRealOrderIndex();
				break;
			}

			if (v->current_order.GetDepotActionType() & ODATFB_NEAREST_DEPOT) {
				/* We need to search for the nearest depot (hangar). */
				TileIndex location;
				DestinationID destination;
				bool reverse;

				if (v->FindClosestDepot(&location, &destination, &reverse)) {
					/* PBS reservations cannot reverse */
					if (pbs_look_ahead && reverse) return false;

					v->dest_tile = location;
					v->current_order.MakeGoToDepot(destination, v->current_order.GetDepotOrderType(), v->current_order.GetNonStopType(), (OrderDepotActionFlags)(v->current_order.GetDepotActionType() & ~ODATFB_NEAREST_DEPOT), v->current_order.GetRefitCargo(), v->current_order.GetRefitSubtype());

					/* If there is no depot in front, reverse automatically (trains only) */
					if (v->type == VEH_TRAIN && reverse) DoCommand(v->tile, v->index, 0, DC_EXEC, CMD_REVERSE_TRAIN_DIRECTION);

					if (v->type == VEH_AIRCRAFT) {
						Aircraft *a = Aircraft::From(v);
						if (a->state == FLYING && a->targetairport != destination) {
							/* The aircraft is now heading for a different hangar than the next in the orders */
							extern void AircraftNextAirportPos_and_Order(Aircraft *a);
							AircraftNextAirportPos_and_Order(a);
						}
					}
					return true;
				}

				/* If there is no depot, we cannot help PBS either. */
				if (pbs_look_ahead) return false;

				UpdateVehicleTimetable(v, true);
				v->IncrementRealOrderIndex();
			} else {
				if (v->type != VEH_AIRCRAFT) {
					v->dest_tile = Depot::Get(order->GetDestination())->xy;
				}
				return true;
			}
			break;

		case OT_GOTO_WAYPOINT:
			v->dest_tile = Waypoint::Get(order->GetDestination())->xy;
			return true;

		case OT_CONDITIONAL: {
			assert(!pbs_look_ahead);
			VehicleOrderID next_order = ProcessConditionalOrder(order, v);
			if (next_order != INVALID_VEH_ORDER_ID) {
				/* Jump to next_order. cur_implicit_order_index becomes exactly that order,
				 * cur_real_order_index might come after next_order. */
				UpdateVehicleTimetable(v, false);
				v->cur_implicit_order_index = v->cur_real_order_index = next_order;
				v->UpdateRealOrderIndex();
				v->current_order_time += v->GetOrder(v->cur_real_order_index)->travel_time;

				/* Disable creation of implicit orders.
				 * When inserting them we do not know that we would have to make the conditional orders point to them. */
				if (v->IsGroundVehicle()) {
					uint16 &gv_flags = v->GetGroundVehicleFlags();
					SetBit(gv_flags, GVF_SUPPRESS_IMPLICIT_ORDERS);
				}
			} else {
				UpdateVehicleTimetable(v, true);
				v->IncrementRealOrderIndex();
			}
			break;
		}

		default:
			v->dest_tile = 0;
			return false;
	}

	assert(v->cur_implicit_order_index < v->GetNumOrders());
	assert(v->cur_real_order_index < v->GetNumOrders());

	/* Get the current order */
	order = v->GetOrder(v->cur_real_order_index);
	if (order != NULL && order->IsType(OT_IMPLICIT)) {
		assert(v->GetNumManualOrders() == 0);
		order = NULL;
	}

	if (order == NULL) {
		v->current_order.Free();
		v->dest_tile = 0;
		return false;
	}

	v->current_order = *order;
	return UpdateOrderDest(v, order, conditional_depth + 1, pbs_look_ahead);
}

/**
 * Handle the orders of a vehicle and determine the next place
 * to go to if needed.
 * @param v the vehicle to do this for.
 * @return true *if* the vehicle is eligible for reversing
 *              (basically only when leaving a station).
 */
bool ProcessOrders(Vehicle *v)
{
	switch (v->current_order.GetType()) {
		case OT_GOTO_DEPOT:
			/* Let a depot order in the orderlist interrupt. */
			if (!(v->current_order.GetDepotOrderType() & ODTFB_PART_OF_ORDERS)) return false;
			break;

		case OT_LOADING:
			return false;

		case OT_LEAVESTATION:
			if (v->type != VEH_AIRCRAFT) return false;
			break;

		default: break;
	}

	/**
	 * Reversing because of order change is allowed only just after leaving a
	 * station (and the difficulty setting to allowed, of course)
	 * this can be detected because only after OT_LEAVESTATION, current_order
	 * will be reset to nothing. (That also happens if no order, but in that case
	 * it won't hit the point in code where may_reverse is checked)
	 */
	bool may_reverse = v->current_order.IsType(OT_NOTHING);

	/* Check if we've reached a 'via' destination. */
	if (((v->current_order.IsType(OT_GOTO_STATION) && (v->current_order.GetNonStopType() & ONSF_NO_STOP_AT_DESTINATION_STATION)) || v->current_order.IsType(OT_GOTO_WAYPOINT)) &&
			IsTileType(v->tile, MP_STATION) &&
			v->current_order.GetDestination() == GetStationIndex(v->tile)) {
		v->DeleteUnreachedImplicitOrders();
		/* We set the last visited station here because we do not want
		 * the train to stop at this 'via' station if the next order
		 * is a no-non-stop order; in that case not setting the last
		 * visited station will cause the vehicle to still stop. */
		v->last_station_visited = v->current_order.GetDestination();
		UpdateVehicleTimetable(v, true);
		v->IncrementImplicitOrderIndex();
	}

	/* Get the current order */
	assert(v->cur_implicit_order_index == 0 || v->cur_implicit_order_index < v->GetNumOrders());
	v->UpdateRealOrderIndex();

	const Order *order = v->GetOrder(v->cur_real_order_index);
	if (order != NULL && order->IsType(OT_IMPLICIT)) {
		assert(v->GetNumManualOrders() == 0);
		order = NULL;
	}

	/* If no order, do nothing. */
	if (order == NULL || (v->type == VEH_AIRCRAFT && !CheckForValidOrders(v))) {
		if (v->type == VEH_AIRCRAFT) {
			/* Aircraft do something vastly different here, so handle separately */
			extern void HandleMissingAircraftOrders(Aircraft *v);
			HandleMissingAircraftOrders(Aircraft::From(v));
			return false;
		}

		v->current_order.Free();
		v->dest_tile = 0;
		return false;
	}

	/* If it is unchanged, keep it. */
	if (order->Equals(v->current_order) && (v->type == VEH_AIRCRAFT || v->dest_tile != 0) &&
			(v->type != VEH_SHIP || !order->IsType(OT_GOTO_STATION) || Station::Get(order->GetDestination())->dock_tile != INVALID_TILE)) {
		return false;
	}

	/* Otherwise set it, and determine the destination tile. */
	v->current_order = *order;

	InvalidateVehicleOrder(v, -2);
	switch (v->type) {
		default:
			NOT_REACHED();

		case VEH_ROAD:
		case VEH_TRAIN:
			break;

		case VEH_AIRCRAFT:
		case VEH_SHIP:
			SetWindowClassesDirty(GetWindowClassForVehicleType(v->type));
			break;
	}

	return UpdateOrderDest(v, order) && may_reverse;
}

/**
 * Check whether the given vehicle should stop at the given station
 * based on this order and the non-stop settings.
 * @param v       the vehicle that might be stopping.
 * @param station the station to stop at.
 * @return true if the vehicle should stop.
 */
bool Order::ShouldStopAtStation(const Vehicle *v, StationID station) const
{
	bool is_dest_station = this->IsType(OT_GOTO_STATION) && this->dest == station;

	return (!this->IsType(OT_GOTO_DEPOT) || (this->GetDepotOrderType() & ODTFB_PART_OF_ORDERS) != 0) &&
			v->last_station_visited != station && // Do stop only when we've not just been there
			/* Finally do stop when there is no non-stop flag set for this type of station. */
			!(this->GetNonStopType() & (is_dest_station ? ONSF_NO_STOP_AT_DESTINATION_STATION : ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS));
}