(C) Zeriph Enterprises
omni/xx/date_data.hxx
0001:
0002:
0003:
0004:
0005:
0006:
0007:
0008:
0009:
0010:
0011:
0012:
0013:
0014:
0015:
0016:
0017:
0018:
0019:
0020:
0021:
0022:
0023:
0024:
0025:
0026:
0027:
0028:
0029:
0030:
0031:
0032:
0033:
0034:
0035:
0036:
0037:
0038:
0039:
0040:
0041:
0042:
0043:
0044:
0045:
0046:
0047:
0048:
0049:
0050:
0051:
0052:
0053:
0054:
0055:
0056:
0057:
0058:
0059:
0060:
0061:
0062:
0063:
0064:
0065:
0066:
0067:
0068:
0069:
0070:
0071:
0072:
0073:
0074:
0075:
0076:
0077:
0078:
0079:
0080:
0081:
0082:
0083:
0084:
0085:
0086:
0087:
0088:
0089:
0090:
0091:
0092:
0093:
0094:
0095:
0096:
0097:
0098:
0099:
0100:
0101:
0102:
0103:
0104:
0105:
0106:
0107:
0108:
0109:
0110:
0111:
0112:
0113:
0114:
0115:
0116:
0117:
0118:
0119:
0120:
0121:
0122:
0123:
0124:
0125:
0126:
0127:
0128:
0129:
0130:
0131:
0132:
0133:
0134:
0135:
0136:
0137:
0138:
0139:
0140:
0141:
0142:
0143:
0144:
0145:
0146:
0147:
0148:
0149:
0150:
0151:
0152:
0153:
0154:
0155:
0156:
0157:
0158:
0159:
0160:
0161:
0162:
0163:
0164:
0165:
0166:
0167:
0168:
0169:
0170:
0171:
0172:
0173:
0174:
0175:
0176:
0177:
0178:
0179:
0180:
0181:
0182:
0183:
0184:
0185:
0186:
0187:
0188:
0189:
0190:
0191:
0192:
0193:
0194:
0195:
0196:
0197:
0198:
0199:
0200:
0201:
0202:
0203:
0204:
0205:
0206:
0207:
0208:
0209:
0210:
0211:
0212:
0213:
0214:
0215:
0216:
0217:
0218:
0219:
0220:
0221:
0222:
0223:
0224:
0225:
0226:
0227:
0228:
0229:
0230:
0231:
0232:
0233:
0234:
0235:
0236:
0237:
0238:
0239:
0240:
0241:
0242:
0243:
0244:
0245:
0246:
0247:
0248:
0249:
0250:
0251:
0252:
0253:
0254:
0255:
0256:
0257:
0258:
0259:
0260:
0261:
0262:
0263:
0264:
0265:
0266:
0267:
0268:
0269:
0270:
0271:
0272:
0273:
0274:
0275:
0276:
0277:
0278:
0279:
0280:
0281:
0282:
0283:
0284:
0285:
0286:
0287:
0288:
0289:
0290:
0291:
0292:
0293:
0294:
0295:
0296:
0297:
0298:
0299:
0300:
0301:
0302:
0303:
0304:
0305:
0306:
0307:
0308:
0309:
0310:
0311:
0312:
0313:
0314:
0315:
0316:
0317:
0318:
0319:
0320:
0321:
0322:
0323:
0324:
0325:
0326:
0327:
0328:
0329:
0330:
0331:
0332:
0333:
0334:
0335:
0336:
0337:
0338:
0339:
0340:
0341:
0342:
0343:
0344:
0345:
0346:
0347:
0348:
0349:
0350:
0351:
0352:
0353:
0354:
0355:
0356:
0357:
0358:
0359:
0360:
0361:
0362:
0363:
0364:
0365:
0366:
0367:
0368:
0369:
0370:
0371:
0372:
0373:
0374:
0375:
0376:
0377:
0378:
0379:
0380:
0381:
0382:
0383:
0384:
0385:
0386:
0387:
0388:
0389:
0390:
0391:
0392:
0393:
0394:
0395:
0396:
0397:
0398:
0399:
0400:
0401:
0402:
0403:
0404:
0405:
0406:
0407:
0408:
0409:
0410:
0411:
0412:
0413:
0414:
0415:
0416:
0417:
0418:
0419:
0420:
0421:
0422:
0423:
0424:
0425:
0426:
0427:
0428:
0429:
0430:
0431:
0432:
0433:
0434:
0435:
0436:
0437:
0438:
0439:
0440:
0441:
0442:
0443:
0444:
0445:
0446:
0447:
0448:
0449:
0450:
0451:
0452:
0453:
0454:
0455:
0456:
0457:
0458:
0459:
0460:
0461:
0462:
0463:
0464:
0465:
0466:
0467:
0468:
0469:
0470:
0471:
0472:
0473:
0474:
0475:
0476:
0477:
0478:
0479:
0480:
0481:
0482:
0483:
0484:
0485:
0486:
0487:
0488:
0489:
0490:
0491:
0492:
0493:
0494:
0495:
0496:
0497:
0498:
0499:
0500:
0501:
0502:
0503:
0504:
0505:
0506:
0507:
0508:
0509:
0510:
0511:
0512:
0513:
0514:
0515:
0516:
0517:
0518:
0519:
0520:
0521:
0522:
0523:
0524:
0525:
0526:
0527:
0528:
0529:
0530:
0531:
0532:
0533:
0534:
0535:
0536:
0537:
0538:
0539:
0540:
0541:
0542:
0543:
0544:
0545:
0546:
0547:
0548:
0549:
0550:
0551:
0552:
0553:
0554:
0555:
0556:
0557:
0558:
0559:
0560:
0561:
0562:
0563:
0564:
0565:
0566:
0567:
0568:
0569:
0570:
0571:
0572:
0573:
0574:
0575:
0576:
0577:
0578:
0579:
0580:
0581:
0582:
0583:
0584:
0585:
0586:
0587:
0588:
0589:
0590:
0591:
0592:
0593:
0594:
0595:
0596:
0597:
0598:
0599:
0600:
0601:
0602:
0603:
0604:
0605:
0606:
0607:
0608:
0609:
0610:
0611:
0612:
0613:
0614:
0615:
0616:
0617:
0618:
0619:
0620:
0621:
0622:
0623:
0624:
0625:
0626:
0627:
0628:
0629:
0630:
0631:
0632:
0633:
0634:
0635:
0636:
0637:
0638:
0639:
0640:
0641:
0642:
0643:
0644:
0645:
0646:
0647:
0648:
0649:
0650:
0651:
0652:
0653:
0654:
0655:
0656:
0657:
0658:
0659:
0660:
0661:
0662:
0663:
0664:
0665:
0666:
0667:
0668:
0669:
0670:
0671:
0672:
0673:
0674:
0675:
0676:
0677:
0678:
0679:
0680:
0681:
0682:
0683:
0684:
0685:
0686:
0687:
0688:
0689:
0690:
0691:
0692:
0693:
0694:
0695:
0696:
0697:
0698:
0699:
0700:
0701:
0702:
0703:
0704:
0705:
0706:
0707:
0708:
0709:
0710:
0711:
0712:
0713:
0714:
0715:
0716:
0717:
0718:
0719:
0720:
0721:
0722:
0723:
0724:
0725:
0726:
0727:
0728:
0729:
0730:
0731:
0732:
0733:
0734:
0735:
0736:
0737:
0738:
0739:
0740:
0741:
0742:
0743:
0744:
0745:
0746:
0747:
0748:
0749:
0750:
0751:
0752:
0753:
0754:
0755:
0756:
0757:
0758:
0759:
0760:
0761:
0762:
0763:
0764:
0765:
0766:
0767:
0768:
0769:
0770:
0771:
0772:
0773:
0774:
0775:
0776:
0777:
0778:
0779:
0780:
0781:
0782:
0783:
0784:
0785:
0786:
0787:
0788:
0789:
0790:
0791:
0792:
0793:
0794:
0795:
0796:
0797:
0798:
0799:
0800:
0801:
0802:
0803:
0804:
0805:
0806:
0807:
0808:
0809:
0810:
0811:
0812:
0813:
0814:
0815:
0816:
0817:
0818:
0819:
0820:
0821:
0822:
0823:
0824:
0825:
0826:
0827:
0828:
0829:
0830:
0831:
0832:
0833:
0834:
0835:
0836:
0837:
0838:
0839:
0840:
0841:
0842:
0843:
0844:
0845:
0846:
0847:
0848:
0849:
0850:
0851:
0852:
0853:
0854:
0855:
0856:
0857:
0858:
0859:
0860:
0861:
0862:
0863:
0864:
0865:
0866:
0867:
0868:
0869:
0870:
0871:
0872:
0873:
0874:
0875:
0876:
0877:
0878:
0879:
0880:
0881:
0882:
0883:
0884:
0885:
0886:
0887:
0888:
0889:
0890:
0891:
0892:
0893:
0894:
0895:
0896:
0897:
0898:
0899:
0900:
0901:
0902:
0903:
0904:
0905:
0906:
0907:
0908:
0909:
0910:
0911:
0912:
0913:
0914:
0915:
0916:
0917:
0918:
0919:
0920:
0921:
0922:
0923:
0924:
0925:
0926:
0927:
0928:
0929:
0930:
0931:
0932:
0933:
0934:
0935:
0936:
0937:
0938:
0939:
0940:
0941:
0942:
0943:
0944:
0945:
0946:
0947:
0948:
0949:
0950:
0951:
0952:
0953:
0954:
0955:
0956:
0957:
0958:
0959:
0960:
0961:
0962:
0963:
0964:
0965:
0966:
0967:
0968:
0969:
0970:
0971:
0972:
0973:
0974:
0975:
0976:
0977:
0978:
0979:
0980:
0981:
0982:
0983:
0984:
0985:
0986:
0987:
0988:
0989:
0990:
0991:
0992:
0993:
0994:
0995:
0996:
0997:
0998:
0999:
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:
2130:
2131:
2132:
2133:
2134:
2135:
2136:
2137:
2138:
2139:
2140:
2141:
2142:
2143:
2144:
2145:
2146:
2147:
2148:
2149:
2150:
2151:
2152:
2153:
2154:
2155:
2156:
2157:
2158:
2159:
2160:
2161:
2162:
2163:
2164:
2165:
2166:
2167:
2168:
2169:
2170:
2171:
2172:
2173:
2174:
2175:
2176:
2177:
2178:
2179:
2180:
2181:
2182:
2183:
2184:
2185:
2186:
2187:
2188:
2189:
2190:
2191:
2192:
2193:
2194:
2195:
2196:
2197:
2198:
2199:
2200:
2201:
2202:
2203:
2204:
2205:
2206:
2207:
2208:
2209:
2210:
2211:
2212:
2213:
2214:
2215:
2216:
2217:
2218:
2219:
2220:
2221:
2222:
2223:
2224:
2225:
2226:
2227:
2228:
2229:
2230:
2231:
2232:
2233:
2234:
2235:
2236:
2237:
2238:
2239:
2240:
2241:
2242:
2243:
2244:
2245:
2246:
2247:
2248:
2249:
2250:
2251:
2252:
2253:
2254:
2255:
2256:
2257:
2258:
2259:
2260:
2261:
2262:
2263:
2264:
2265:
2266:
2267:
2268:
2269:
2270:
2271:
2272:
2273:
2274:
2275:
2276:
2277:
2278:
2279:
2280:
2281:
2282:
2283:
2284:
2285:
2286:
2287:
2288:
2289:
2290:
2291:
2292:
2293:
2294:
2295:
2296:
2297:
2298:
2299:
2300:
2301:
2302:
2303:
2304:
2305:
2306:
2307:
2308:
2309:
2310:
2311:
2312:
2313:
2314:
2315:
2316:
2317:
2318:
2319:
2320:
2321:
2322:
2323:
2324:
2325:
2326:
2327:
2328:
2329:
2330:
2331:
2332:
2333:
2334:
2335:
2336:
2337:
2338:
2339:
2340:
2341:
2342:
2343:
2344:
2345:
2346:
2347:
2348:
2349:
2350:
2351:
2352:
2353:
2354:
2355:
2356:
2357:
2358:
2359:
2360:
2361:
2362:
2363:
2364:
2365:
2366:
2367:
2368:
2369:
2370:
2371:
2372:
2373:
2374:
2375:
2376:
2377:
2378:
2379:
2380:
2381:
2382:
2383:
2384:
2385:
2386:
2387:
2388:
2389:
2390:
2391:
2392:
2393:
2394:
2395:
2396:
2397:
2398:
2399:
2400:
2401:
2402:
2403:
2404:
2405:
2406:
2407:
2408:
2409:
2410:
2411:
2412:
2413:
2414:
2415:
2416:
2417:
2418:
2419:
2420:
2421:
2422:
2423:
2424:
2425:
2426:
2427:
2428:
2429:
2430:
2431:
2432:
2433:
2434:
2435:
2436:
2437:
2438:
2439:
2440:
2441:
2442:
2443:
2444:
2445:
2446:
2447:
2448:
2449:
2450:
2451:
2452:
2453:
2454:
2455:
2456:
2457:
2458:
2459:
2460:
2461:
2462:
2463:
2464:
2465:
2466:
2467:
2468:
2469:
2470:
2471:
2472:
2473:
2474:
2475:
2476:
2477:
2478:
2479:
2480:
2481:
2482:
2483:
2484:
2485:
2486:
2487:
2488:
2489:
2490:
2491:
2492:
2493:
2494:
2495:
2496:
2497:
2498:
2499:
2500:
2501:
2502:
2503:
2504:
2505:
2506:
2507:
2508:
2509:
2510:
2511:
2512:
2513:
2514:
2515:
2516:
2517:
2518:
2519:
2520:
2521:
2522:
2523:
2524:
2525:
2526:
2527:
2528:
2529:
2530:
2531:
2532:
2533:
2534:
2535:
2536:
2537:
2538:
2539:
2540:
2541:
2542:
2543:
2544:
2545:
2546:
2547:
2548:
2549:
2550:
2551:
2552:
2553:
2554:
2555:
2556:
2557:
2558:
2559:
2560:
2561:
2562:
2563:
2564:
2565:
2566:
2567:
2568:
2569:
2570:
2571:
2572:
2573:
2574:
2575:
2576:
2577:
2578:
2579:
2580:
2581:
2582:
2583:
2584:
2585:
2586:
2587:
2588:
2589:
2590:
2591:
2592:
2593:
2594:
2595:
2596:
2597:
2598:
2599:
2600:
2601:
2602:
2603:
2604:
2605:
2606:
2607:
2608:
2609:
2610:
2611:
2612:
2613:
2614:
2615:
2616:
2617:
2618:
2619:
2620:
2621:
2622:
2623:
2624:
2625:
2626:
2627:
2628:
2629:
2630:
2631:
2632:
2633:
2634:
2635:
2636:
2637:
2638:
2639:
2640:
2641:
2642:
2643:
2644:
2645:
2646:
2647:
2648:
2649:
2650:
2651:
2652:
2653:
2654:
2655:
2656:
2657:
2658:
2659:
2660:
2661:
2662:
2663:
2664:
2665:
2666:
2667:
2668:
2669:
2670:
2671:
2672:
2673:
2674:
2675:
2676:
2677:
2678:
2679:
2680:
2681:
2682:
2683:
2684:
2685:
2686:
2687:
2688:
2689:
2690:
2691:
2692:
2693:
2694:
2695:
2696:
2697:
2698:
2699:
2700:
2701:
2702:
2703:
2704:
2705:
2706:
2707:
2708:
2709:
2710:
2711:
2712:
2713:
2714:
2715:
2716:
2717:
2718:
2719:
2720:
2721:
2722:
2723:
2724:
2725:
2726:
2727:
2728:
2729:
2730:
2731:
2732:
2733:
2734:
2735:
2736:
2737:
2738:
2739:
2740:
2741:
2742:
2743:
2744:
2745:
2746:
2747:
2748:
2749:
2750:
2751:
2752:
2753:
2754:
2755:
2756:
2757:
2758:
2759:
2760:
2761:
2762:
2763:
2764:
2765:
2766:
2767:
2768:
2769:
2770:
2771:
2772:
2773:
2774:
2775:
2776:
2777:
2778:
2779:
2780:
2781:
2782:
2783:
2784:
2785:
2786:
2787:
2788:
2789:
2790:
2791:
2792:
2793:
2794:
2795:
2796:
2797:
2798:
2799:
2800:
2801:
2802:
2803:
2804:
2805:
2806:
2807:
2808:
2809:
2810:
2811:
2812:
2813:
2814:
2815:
2816:
2817:
2818:
2819:
2820:
2821:
2822:
2823:
2824:
2825:
2826:
2827:
2828:
2829:
2830:
2831:
2832:
2833:
2834:
2835:
2836:
2837:
2838:
2839:
2840:
2841:
2842:
2843:
2844:
2845:
2846:
2847:
2848:
2849:
2850:
2851:
2852:
2853:
2854:
2855:
2856:
2857:
2858:
2859:
2860:
2861:
2862:
2863:
2864:
2865:
2866:
2867:
2868:
2869:
2870:
2871:
2872:
2873:
2874:
2875:
2876:
2877:
2878:
2879:
2880:
2881:
2882:
2883:
2884:
2885:
2886:
2887:
2888:
2889:
2890:
2891:
2892:
2893:
2894:
2895:
2896:
2897:
2898:
2899:
2900:
2901:
2902:
2903:
2904:
2905:
2906:
2907:
2908:
2909:
2910:
2911:
2912:
2913:
2914:
2915:
2916:
2917:
2918:
2919:
2920:
2921:
2922:
2923:
2924:
2925:
2926:
2927:
2928:
2929:
2930:
2931:
2932:
2933:
2934:
2935:
2936:
2937:
2938:
2939:
2940:
2941:
2942:
2943:
2944:
2945:
2946:
2947:
2948:
2949:
2950:
2951:
2952:
2953:
2954:
2955:
2956:
2957:
2958:
2959:
2960:
2961:
2962:
2963:
2964:
2965:
2966:
2967:
2968:
2969:
2970:
2971:
2972:
2973:
2974:
2975:
2976:
2977:
2978:
2979:
2980:
2981:
2982:
2983:
2984:
2985:
2986:
2987:
2988:
2989:
2990:
2991:
2992:
2993:
2994:
2995:
2996:
2997:
2998:
2999:
3000:
3001:
3002:
3003:
3004:
3005:
3006:
3007:
3008:
3009:
3010:
3011:
3012:
3013:
3014:
3015:
3016:
3017:
3018:
3019:
3020:
3021:
3022:
3023:
3024:
3025:
3026:
3027:
3028:
3029:
3030:
3031:
3032:
3033:
3034:
3035:
3036:
3037:
3038:
3039:
3040:
3041:
3042:
3043:
3044:
3045:
3046:
3047:
3048:
3049:
3050:
3051:
3052:
3053:
3054:
3055:
3056:
3057:
3058:
3059:
3060:
3061:
3062:
3063:
3064:
3065:
3066:
3067:
3068:
3069:
3070:
3071:
3072:
3073:
3074:
3075:
3076:
3077:
3078:
3079:
3080:
3081:
3082:
3083:
3084:
3085:
3086:
3087:
3088:
3089:
3090:
3091:
3092:
3093:
3094:
3095:
3096:
3097:
3098:
3099:
3100:
3101:
3102:
3103:
3104:
3105:
3106:
3107:
3108:
3109:
3110:
3111:
3112:
3113:
3114:
3115:
3116:
3117:
3118:
3119:
3120:
3121:
3122:
3123:
3124:
3125:
3126:
3127:
3128:
3129:
3130:
3131:
3132:
3133:
3134:
3135:
3136:
3137:
3138:
3139:
3140:
3141:
3142:
3143:
3144:
3145:
3146:
3147:
3148:
3149:
3150:
3151:
3152:
3153:
3154:
3155:
3156:
3157:
3158:
3159:
3160:
3161:
3162:
3163:
3164:
3165:
3166:
3167:
3168:
3169:
3170:
3171:
3172:
3173:
3174:
3175:
3176:
3177:
3178:
3179:
3180:
3181:
3182:
3183:
3184:
3185:
3186:
3187:
3188:
3189:
3190:
3191:
3192:
3193:
3194:
3195:
3196:
3197:
3198:
3199:
3200:
3201:
3202:
3203:
3204:
3205:
3206:
3207:
3208:
3209:
3210:
3211:
3212:
3213:
3214:
3215:
3216:
3217:
3218:
3219:
3220:
3221:
3222:
3223:
3224:
3225:
3226:
3227:
3228:
3229:
3230:
3231:
3232:
3233:
3234:
3235:
3236:
3237:
3238:
3239:
3240:
3241:
3242:
3243:
3244:
3245:
3246:
3247:
3248:
3249:
3250:
3251:
3252:
3253:
3254:
3255:
3256:
3257:
3258:
3259:
3260:
3261:
3262:
3263:
3264:
3265:
3266:
3267:
3268:
3269:
3270:
3271:
3272:
3273:
3274:
3275:
3276:
3277:
3278:
3279:
3280:
3281:
3282:
3283:
3284:
3285:
3286:
3287:
3288:
3289:
3290:
3291:
3292:
3293:
3294:
3295:
3296:
3297:
3298:
3299:
3300:
3301:
3302:
3303:
3304:
3305:
3306:
3307:
3308:
3309:
3310:
3311:
3312:
3313:
3314:
3315:
3316:
3317:
3318:
3319:
3320:
3321:
3322:
3323:
3324:
3325:
3326:
3327:
3328:
3329:
3330:
3331:
3332:
3333:
3334:
3335:
3336:
3337:
3338:
3339:
3340:
3341:
3342:
3343:
3344:
3345:
3346:
3347:
3348:
3349:
3350:
3351:
3352:
3353:
3354:
3355:
3356:
3357:
3358:
3359:
3360:
3361:
3362:
3363:
3364:
3365:
3366:
3367:
3368:
3369:
3370:
3371:
3372:
3373:
3374:
3375:
3376:
3377:
3378:
3379:
3380:
3381:
3382:
3383:
3384:
3385:
3386:
3387:
3388:
3389:
3390:
3391:
3392:
3393:
3394:
3395:
3396:
3397:
3398:
3399:
3400:
3401:
3402:
3403:
3404:
3405:
3406:
3407:
3408:
3409:
3410:
3411:
3412:
3413:
3414:
3415:
3416:
3417:
3418:
3419:
3420:
3421:
3422:
3423:
3424:
3425:
3426:
3427:
3428:
3429:
3430:
3431:
3432:
3433:
3434:
3435:
3436:
3437:
3438:
3439:
3440:
3441:
3442:
3443:
3444:
3445:
3446:
3447:
3448:
3449:
3450:
3451:
3452:
3453:
3454:
3455:
3456:
3457:
3458:
3459:
3460:
3461:
3462:
3463:
3464:
3465:
3466:
3467:
3468:
3469:
3470:
3471:
3472:
3473:
3474:
3475:
3476:
3477:
3478:
3479:
3480:
3481:
3482:
3483:
3484:
3485:
3486:
3487:
3488:
3489:
3490:
3491:
3492:
3493:
3494:
3495:
3496:
3497:
3498:
3499:
3500:
3501:
3502:
3503:
3504:
3505:
3506:
3507:
3508:
3509:
3510:
3511:
3512:
3513:
3514:
3515:
3516:
3517:
3518:
3519:
3520:
3521:
3522:
3523:
3524:
3525:
3526:
3527:
3528:
3529:
3530:
3531:
3532:
3533:
3534:
3535:
3536:
3537:
3538:
3539:
3540:
3541:
3542:
3543:
3544:
3545:
3546:
3547:
3548:
3549:
3550:
3551:
3552:
3553:
3554:
3555:
3556:
3557:
3558:
3559:
3560:
3561:
3562:
3563:
3564:
3565:
3566:
3567:
3568:
3569:
3570:
3571:
3572:
3573:
3574:
3575:
3576:
3577:
3578:
3579:
3580:
3581:
3582:
3583:
3584:
3585:
3586:
3587:
3588:
3589:
3590:
3591:
3592:
3593:
3594:
3595:
3596:
3597:
3598:
3599:
3600:
3601:
3602:
3603:
3604:
3605:
3606:
3607:
3608:
3609:
3610:
3611:
3612:
3613:
3614:
3615:
3616:
3617:
3618:
3619:
3620:
3621:
3622:
3623:
3624:
3625:
3626:
3627:
3628:
3629:
3630:
3631:
3632:
3633:
3634:
3635:
3636:
3637:
3638:
3639:
3640:
3641:
3642:
3643:
3644:
3645:
3646:
3647:
3648:
3649:
3650:
3651:
3652:
3653:
3654:
3655:
3656:
3657:
3658:
3659:
3660:
3661:
3662:
3663:
3664:
3665:
3666:
3667:
3668:
3669:
3670:
3671:
3672:
3673:
3674:
3675:
3676:
3677:
3678:
3679:
3680:
3681:
3682:
3683:
3684:
3685:
3686:
3687:
3688:
3689:
3690:
3691:
3692:
3693:
3694:
3695:
3696:
3697:
3698:
3699:
3700:
3701:
3702:
3703:
3704:
3705:
3706:
3707:
3708:
3709:
3710:
3711:
3712:
3713:
3714:
3715:
3716:
3717:
3718:
3719:
3720:
3721:
3722:
3723:
3724:
3725:
3726:
3727:
3728:
3729:
3730:
3731:
3732:
3733:
3734:
3735:
3736:
3737:
3738:
3739:
3740:
3741:
3742:
3743:
3744:
3745:
3746:
3747:
3748:
3749:
3750:
3751:
3752:
3753:
3754:
3755:
3756:
3757:
3758:
3759:
3760:
3761:
3762:
3763:
3764:
3765:
3766:
3767:
3768:
3769:
3770:
3771:
3772:
3773:
3774:
3775:
3776:
3777:
3778:
3779:
3780:
3781:
3782:
3783:
3784:
3785:
3786:
3787:
3788:
3789:
3790:
3791:
3792:
3793:
3794:
3795:
3796:
3797:
3798:
3799:
3800:
3801:
3802:
3803:
3804:
3805:
3806:
3807:
3808:
3809:
3810:
3811:
3812:
3813:
3814:
3815:
3816:
3817:
3818:
3819:
3820:
3821:
3822:
3823:
3824:
3825:
3826:
3827:
3828:
3829:
3830:
3831:
3832:
3833:
3834:
3835:
3836:
3837:
3838:
3839:
3840:
3841:
3842:
3843:
3844:
3845:
3846:
3847:
3848:
3849:
3850:
3851:
3852:
3853:
3854:
3855:
3856:
3857:
3858:
3859:
3860:
3861:
3862:
3863:
3864:
3865:
3866:
3867:
3868:
3869:
3870:
3871:
3872:
3873:
3874:
3875:
3876:
3877:
3878:
3879:
3880:
3881:
3882:
3883:
3884:
3885:
3886:
3887:
3888:
3889:
3890:
3891:
3892:
3893:
3894:
3895:
3896:
3897:
3898:
3899:
3900:
3901:
3902:
3903:
3904:
3905:
3906:
3907:
3908:
3909:
3910:
3911:
3912:
3913:
3914:
3915:
3916:
3917:
3918:
3919:
3920:
3921:
3922:
3923:
3924:
3925:
3926:
3927:
3928:
3929:
3930:
3931:
3932:
3933:
3934:
3935:
3936:
3937:
3938:
3939:
3940:
3941:
3942:
3943:
3944:
3945:
3946:
3947:
3948:
3949:
3950:
3951:
3952:
3953:
3954:
3955:
3956:
3957:
3958:
3959:
3960:
3961:
3962:
3963:
3964:
3965:
3966:
3967:
3968:
3969:
3970:
3971:
3972:
3973:
3974:
3975:
3976:
3977:
3978:
3979:
3980:
3981:
3982:
3983:
3984:
3985:
3986:
3987:
3988:
3989:
3990:
3991:
3992:
3993:
3994:
3995:
3996:
3997:
3998:
3999:
4000:
4001:
4002:
4003:
4004:
4005:
4006:
4007:
4008:
4009:
4010:
4011:
4012:
4013:
4014:
4015:
4016:
4017:
4018:
4019:
4020:
4021:
4022:
4023:
4024:
4025:
4026:
4027:
4028:
4029:
4030:
4031:
4032:
4033:
4034:
4035:
4036:
4037:
4038:
4039:
4040:
4041:
4042:
4043:
4044:
4045:
4046:
4047:
4048:
4049:
4050:
4051:
4052:
4053:
4054:
4055:
4056:
4057:
4058:
4059:
4060:
4061:
4062:
4063:
4064:
4065:
4066:
4067:
4068:
4069:
4070:
4071:
4072:
4073:
4074:
4075:
4076:
4077:
4078:
4079:
4080:
4081:
4082:
4083:
4084:
4085:
4086:
4087:
4088:
4089:
4090:
4091:
4092:
4093:
4094:
4095:
4096:
4097:
4098:
4099:
4100:
4101:
4102:
4103:
4104:
4105:
4106:
4107:
4108:
4109:
4110:
4111:
4112:
4113:
4114:
4115:
4116:
4117:
4118:
4119:
4120:
4121:
4122:
4123:
4124:
4125:
4126:
4127:
4128:
4129:
4130:
4131:
4132:
4133:
4134:
4135:
4136:
4137:
4138:
4139:
4140:
4141:
4142:
4143:
4144:
4145:
4146:
4147:
4148:
4149:
4150:
4151:
4152:
4153:
4154:
4155:
4156:
4157:
4158:
4159:
4160:
4161:
4162:
4163:
4164:
4165:
4166:
4167:
4168:
4169:
4170:
4171:
4172:
4173:
4174:
4175:
4176:
4177:
4178:
4179:
4180:
4181:
4182:
4183:
4184:
4185:
4186:
4187:
4188:
4189:
4190:
4191:
4192:
4193:
4194:
4195:
4196:
4197:
4198:
4199:
4200:
4201:
4202:
4203:
4204:
4205:
4206:
4207:
4208:
4209:
4210:
4211:
4212:
4213:
4214:
4215:
4216:
4217:
4218:
4219:
4220:
4221:
4222:
4223:
4224:
4225:
4226:
4227:
4228:
4229:
4230:
4231:
4232:
4233:
4234:
4235:
4236:
4237:
4238:
4239:
4240:
4241:
4242:
4243:
4244:
4245:
4246:
4247:
4248:
4249:
4250:
4251:
4252:
4253:
4254:
4255:
4256:
4257:
4258:
4259:
4260:
4261:
4262:
4263:
4264:
4265:
4266:
4267:
4268:
4269:
4270:
4271:
4272:
4273:
4274:
4275:
4276:
4277:
4278:
4279:
4280:
4281:
4282:
4283:
4284:
4285:
4286:
4287:
4288:
4289:
4290:
4291:
4292:
4293:
4294:
4295:
4296:
4297:
4298:
4299:
4300:
4301:
4302:
4303:
4304:
4305:
4306:
4307:
4308:
4309:
4310:
4311:
4312:
4313:
4314:
4315:
4316:
4317:
4318:
4319:
4320:
4321:
4322:
4323:
4324:
4325:
4326:
4327:
4328:
4329:
4330:
4331:
4332:
4333:
4334:
4335:
4336:
4337:
4338:
4339:
4340:
4341:
4342:
4343:
4344:
4345:
4346:
4347:
4348:
4349:
4350:
4351:
4352:
4353:
4354:
4355:
4356:
4357:
4358:
4359:
4360:
4361:
4362:
4363:
4364:
4365:
4366:
4367:
4368:
4369:
4370:
4371:
4372:
4373:
4374:
4375:
4376:
4377:
4378:
4379:
4380:
4381:
4382:
4383:
4384:
4385:
4386:
4387:
4388:
4389:
4390:
4391:
4392:
4393:
4394:
4395:
4396:
4397:
4398:
4399:
4400:
4401:
4402:
4403:
4404:
4405:
4406:
4407:
4408:
4409:
4410:
4411:
4412:
4413:
4414:
4415:
4416:
4417:
4418:
4419:
4420:
4421:
4422:
4423:
4424:
4425:
4426:
4427:
4428:
4429:
4430:
4431:
4432:
4433:
4434:
4435:
4436:
4437:
4438:
4439:
4440:
4441:
4442:
4443:
4444:
4445:
4446:
4447:
4448:
4449:
4450:
4451:
4452:
4453:
4454:
4455:
4456:
4457:
4458:
4459:
4460:
4461:
4462:
4463:
4464:
4465:
4466:
4467:
4468:
4469:
4470:
4471:
4472:
4473:
4474:
4475:
4476:
4477:
4478:
4479:
4480:
4481:
4482:
4483:
4484:
4485:
4486:
4487:
4488:
4489:
4490:
4491:
4492:
4493:
4494:
4495:
4496:
4497:
4498:
4499:
4500:
4501:
4502:
4503:
4504:
4505:
4506:
4507:
4508:
4509:
4510:
4511:
4512:
4513:
4514:
4515:
4516:
4517:
4518:
4519:
4520:
4521:
4522:
4523:
4524:
4525:
4526:
4527:
4528:
4529:
4530:
4531:
4532:
4533:
4534:
4535:
4536:
4537:
4538:
4539:
4540:
4541:
4542:
4543:
4544:
4545:
4546:
4547:
4548:
4549:
4550:
4551:
4552:
4553:
4554:
4555:
4556:
4557:
4558:
4559:
4560:
4561:
4562:
4563:
4564:
4565:
4566:
4567:
4568:
4569:
4570:
4571:
4572:
4573:
4574:
4575:
4576:
4577:
4578:
4579:
4580:
4581:
4582:
4583:
4584:
4585:
4586:
4587:
4588:
4589:
4590:
4591:
4592:
4593:
4594:
4595:
4596:
4597:
4598:
4599:
4600:
4601:
4602:
4603:
4604:
4605:
4606:
4607:
4608:
4609:
4610:
4611:
4612:
4613:
4614:
4615:
4616:
4617:
4618:
4619:
4620:
4621:
4622:
4623:
4624:
4625:
4626:
4627:
4628:
4629:
4630:
4631:
4632:
4633:
4634:
4635:
4636:
4637:
4638:
4639:
4640:
4641:
4642:
4643:
4644:
4645:
4646:
4647:
4648:
4649:
4650:
4651:
4652:
4653:
4654:
4655:
4656:
4657:
4658:
4659:
4660:
4661:
4662:
4663:
4664:
4665:
4666:
4667:
4668:
4669:
4670:
4671:
4672:
4673:
4674:
4675:
4676:
4677:
4678:
4679:
4680:
4681:
4682:
4683:
4684:
4685:
4686:
4687:
4688:
4689:
4690:
4691:
4692:
4693:
4694:
4695:
4696:
4697:
4698:
4699:
4700:
4701:
4702:
4703:
4704:
4705:
4706:
4707:
4708:
4709:
4710:
4711:
4712:
4713:
4714:
4715:
4716:
4717:
4718:
4719:
4720:
4721:
4722:
4723:
4724:
4725:
4726:
4727:
4728:
4729:
4730:
4731:
4732:
4733:
4734:
4735:
4736:
4737:
4738:
4739:
4740:
4741:
4742:
4743:
4744:
4745:
4746:
4747:
4748:
4749:
4750:
4751:
4752:
4753:
4754:
4755:
4756:
4757:
4758:
4759:
4760:
4761:
4762:
4763:
4764:
4765:
4766:
4767:
4768:
4769:
4770:
4771:
4772:
4773:
4774:
4775:
4776:
4777:
4778:
4779:
4780:
4781:
4782:
4783:
4784:
4785:
4786:
4787:
4788:
4789:
4790:
4791:
4792:
4793:
4794:
4795:
4796:
4797:
4798:
4799:
4800:
4801:
4802:
4803:
4804:
4805:
4806:
4807:
4808:
4809:
4810:
4811:
4812:
4813:
4814:
4815:
4816:
4817:
4818:
4819:
4820:
4821:
4822:
4823:
4824:
4825:
4826:
4827:
4828:
4829:
4830:
4831:
4832:
4833:
4834:
4835:
4836:
4837:
4838:
4839:
4840:
4841:
4842:
4843:
4844:
4845:
4846:
4847:
4848:
4849:
4850:
4851:
4852:
4853:
4854:
4855:
4856:
4857:
4858:
4859:
4860:
4861:
4862:
4863:
4864:
4865:
4866:
4867:
4868:
4869:
4870:
4871:
4872:
4873:
4874:
4875:
4876:
4877:
4878:
4879:
4880:
4881:
4882:
4883:
4884:
4885:
4886:
4887:
4888:
4889:
4890:
4891:
4892:
4893:
4894:
4895:
4896:
4897:
4898:
4899:
4900:
4901:
4902:
4903:
4904:
4905:
4906:
4907:
4908:
4909:
4910:
4911:
4912:
4913:
4914:
4915:
4916:
4917:
4918:
4919:
4920:
4921:
4922:
4923:
4924:
4925:
4926:
4927:
4928:
4929:
4930:
4931:
4932:
4933:
4934:
4935:
4936:
4937:
4938:
4939:
4940:
4941:
4942:
4943:
4944:
4945:
4946:
4947:
4948:
4949:
4950:
4951:
4952:
4953:
4954:
4955:
4956:
4957:
4958:
4959:
4960:
4961:
4962:
4963:
4964:
4965:
4966:
4967:
4968:
4969:
4970:
4971:
4972:
4973:
4974:
4975:
4976:
4977:
4978:
4979:
4980:
4981:
4982:
4983:
4984:
4985:
4986:
4987:
4988:
4989:
4990:
4991:
4992:
4993:
4994:
4995:
4996:
4997:
4998:
4999:
5000:
5001:
5002:
5003:
5004:
5005:
5006:
5007:
5008:
5009:
5010:
5011:
5012:
5013:
5014:
5015:
5016:
5017:
5018:
5019:
5020:
5021:
5022:
5023:
5024:
5025:
5026:
5027:
5028:
5029:
5030:
5031:
5032:
5033:
5034:
5035:
5036:
5037:
5038:
5039:
5040:
5041:
5042:
5043:
5044:
5045:
5046:
5047:
5048:
5049:
5050:
5051:
5052:
5053:
5054:
5055:
5056:
5057:
5058:
5059:
5060:
5061:
5062:
5063:
5064:
5065:
5066:
5067:
5068:
5069:
5070:
5071:
5072:
5073:
5074:
5075:
5076:
5077:
5078:
5079:
5080:
5081:
5082:
5083:
5084:
5085:
5086:
5087:
5088:
5089:
5090:
5091:
5092:
5093:
5094:
5095:
5096:
5097:
5098:
5099:
5100:
5101:
5102:
5103:
5104:
5105:
5106:
5107:
5108:
5109:
5110:
5111:
5112:
5113:
5114:
5115:
5116:
5117:
5118:
5119:
5120:
5121:
5122:
5123:
5124:
5125:
5126:
5127:
5128:
5129:
5130:
5131:
5132:
5133:
5134:
5135:
5136:
5137:
5138:
5139:
5140:
5141:
5142:
5143:
5144:
5145:
5146:
5147:
5148:
5149:
5150:
5151:
5152:
5153:
5154:
5155:
5156:
5157:
5158:
5159:
5160:
5161:
5162:
5163:
5164:
5165:
5166:
5167:
5168:
5169:
5170:
5171:
5172:
5173:
5174:
5175:
5176:
5177:
5178:
5179:
5180:
5181:
5182:
5183:
5184:
5185:
5186:
5187:
5188:
5189:
5190:
5191:
5192:
5193:
5194:
5195:
5196:
5197:
5198:
5199:
5200:
5201:
5202:
5203:
5204:
5205:
5206:
5207:
5208:
5209:
5210:
5211:
5212:
5213:
5214:
5215:
5216:
5217:
5218:
5219:
5220:
5221:
5222:
5223:
5224:
5225:
5226:
5227:
5228:
5229:
5230:
5231:
5232:
5233:
5234:
5235:
5236:
5237:
5238:
5239:
5240:
5241:
5242:
5243:
5244:
5245:
5246:
5247:
5248:
5249:
5250:
5251:
5252:
5253:
5254:
5255:
5256:
5257:
5258:
5259:
5260:
5261:
5262:
5263:
5264:
5265:
5266:
5267:
5268:
5269:
5270:
5271:
5272:
5273:
5274:
5275:
5276:
5277:
5278:
5279:
5280:
5281:
5282:
5283:
5284:
5285:
5286:
5287:
5288:
5289:
5290:
5291:
5292:
5293:
5294:
5295:
5296:
5297:
5298:
5299:
5300:
5301:
5302:
5303:
5304:
5305:
5306:
5307:
5308:
5309:
5310:
5311:
5312:
5313:
5314:
5315:
5316:
5317:
5318:
5319:
5320:
5321:
5322:
5323:
5324:
5325:
5326:
5327:
5328:
5329:
5330:
5331:
5332:
5333:
5334:
5335:
5336:
5337:
5338:
5339:
5340:
5341:
5342:
5343:
5344:
5345:
5346:
5347:
5348:
5349:
5350:
5351:
5352:
5353:
5354:
5355:
5356:
5357:
5358:
5359:
5360:
5361:
5362:
5363:
5364:
5365:
5366:
5367:
5368:
5369:
5370:
5371:
5372:
5373:
5374:
5375:
5376:
5377:
5378:
5379:
5380:
5381:
5382:
5383:
5384:
5385:
5386:
5387:
5388:
5389:
5390:
5391:
5392:
5393:
5394:
5395:
5396:
5397:
5398:
5399:
5400:
5401:
5402:
5403:
5404:
5405:
5406:
5407:
5408:
5409:
5410:
5411:
5412:
5413:
5414:
5415:
5416:
5417:
5418:
5419:
5420:
5421:
5422:
5423:
5424:
5425:
5426:
5427:
5428:
5429:
5430:
5431:
5432:
5433:
5434:
5435:
5436:
5437:
5438:
5439:
5440:
5441:
5442:
5443:
5444:
5445:
5446:
5447:
5448:
5449:
5450:
5451:
5452:
5453:
5454:
5455:
5456:
5457:
5458:
5459:
5460:
5461:
5462:
5463:
5464:
5465:
5466:
5467:
5468:
5469:
5470:
5471:
5472:
5473:
5474:
5475:
5476:
5477:
5478:
5479:
5480:
5481:
5482:
5483:
5484:
5485:
5486:
5487:
5488:
5489:
5490:
5491:
5492:
5493:
5494:
5495:
5496:
5497:
5498:
5499:
5500:
5501:
5502:
5503:
5504:
5505:
5506:
5507:
5508:
5509:
5510:
5511:
5512:
5513:
5514:
5515:
5516:
5517:
5518:
5519:
5520:
5521:
5522:
5523:
5524:
5525:
5526:
5527:
5528:
5529:
5530:
5531:
5532:
5533:
5534:
5535:
5536:
5537:
5538:
5539:
5540:
5541:
5542:
5543:
5544:
5545:
5546:
5547:
5548:
5549:
5550:
5551:
5552:
5553:
5554:
5555:
5556:
5557:
5558:
5559:
5560:
5561:
5562:
5563:
5564:
5565:
5566:
5567:
5568:
5569:
5570:
5571:
5572:
5573:
5574:
5575:
5576:
5577:
5578:
5579:
5580:
5581:
5582:
5583:
5584:
5585:
5586:
5587:
5588:
5589:
5590:
5591:
5592:
5593:
5594:
5595:
5596:
5597:
5598:
5599:
5600:
5601:
5602:
5603:
5604:
5605:
5606:
5607:
5608:
5609:
5610:
5611:
5612:
5613:
5614:
5615:
5616:
5617:
5618:
5619:
5620:
5621:
5622:
5623:
5624:
5625:
5626:
5627:
5628:
5629:
5630:
5631:
5632:
5633:
5634:
5635:
5636:
5637:
5638:
5639:
5640:
5641:
5642:
5643:
5644:
5645:
5646:
5647:
5648:
5649:
5650:
5651:
5652:
5653:
5654:
5655:
5656:
5657:
5658:
5659:
5660:
5661:
5662:
5663:
5664:
5665:
5666:
5667:
5668:
5669:
5670:
5671:
5672:
5673:
5674:
5675:
5676:
5677:
5678:
5679:
5680:
5681:
5682:
5683:
5684:
5685:
5686:
5687:
5688:
5689:
5690:
5691:
5692:
5693:
5694:
5695:
5696:
5697:
5698:
5699:
5700:
5701:
5702:
5703:
5704:
5705:
5706:
5707:
5708:
5709:
5710:
5711:
5712:
5713:
5714:
5715:
5716:
5717:
5718:
5719:
5720:
5721:
5722:
5723:
5724:
5725:
5726:
5727:
5728:
5729:
5730:
5731:
5732:
5733:
5734:
5735:
5736:
5737:
5738:
5739:
5740:
5741:
5742:
5743:
5744:
5745:
5746:
5747:
5748:
5749:
5750:
5751:
5752:
5753:
5754:
5755:
5756:
5757:
5758:
5759:
5760:
5761:
5762:
5763:
5764:
5765:
5766:
5767:
5768:
5769:
5770:
5771:
5772:
5773:
5774:
5775:
5776:
5777:
5778:
5779:
5780:
5781:
5782:
5783:
5784:
5785:
5786:
5787:
5788:
5789:
5790:
5791:
5792:
5793:
5794:
5795:
5796:
5797:
5798:
5799:
5800:
5801:
5802:
5803:
5804:
5805:
5806:
5807:
5808:
5809:
5810:
5811:
5812:
5813:
5814:
5815:
5816:
5817:
5818:
5819:
5820:
5821:
5822:
5823:
5824:
5825:
5826:
5827:
5828:
5829:
5830:
5831:
5832:
5833:
5834:
5835:
5836:
5837:
5838:
5839:
5840:
5841:
5842:
5843:
5844:
5845:
5846:
5847:
5848:
5849:
5850:
5851:
5852:
5853:
5854:
5855:
5856:
5857:
5858:
5859:
5860:
5861:
5862:
5863:
5864:
5865:
5866:
5867:
5868:
5869:
5870:
5871:
5872:
5873:
5874:
5875:
5876:
5877:
5878:
5879:
5880:
5881:
5882:
5883:
5884:
5885:
5886:
5887:
5888:
5889:
5890:
5891:
5892:
5893:
5894:
5895:
5896:
5897:
5898:
5899:
5900:
5901:
5902:
5903:
5904:
5905:
5906:
5907:
5908:
5909:
5910:
5911:
5912:
5913:
5914:
5915:
5916:
5917:
5918:
5919:
5920:
5921:
5922:
5923:
5924:
5925:
5926:
5927:
5928:
5929:
5930:
5931:
5932:
5933:
5934:
5935:
5936:
5937:
5938:
5939:
5940:
5941:
5942:
5943:
5944:
5945:
5946:
5947:
5948:
5949:
5950:
5951:
5952:
5953:
5954:
5955:
5956:
5957:
5958:
5959:
5960:
5961:
5962:
5963:
5964:
5965:
5966:
5967:
5968:
5969:
5970:
5971:
5972:
5973:
5974:
5975:
5976:
5977:
5978:
5979:
5980:
5981:
5982:
5983:
5984:
5985:
5986:
5987:
5988:
5989:
5990:
5991:
5992:
5993:
5994:
5995:
5996:
5997:
5998:
5999:
6000:
6001:
6002:
6003:
6004:
6005:
6006:
6007:
6008:
6009:
6010:
6011:
6012:
6013:
6014:
6015:
6016:
6017:
6018:
6019:
6020:
6021:
6022:
6023:
6024:
6025:
6026:
6027:
6028:
6029:
6030:
6031:
6032:
6033:
6034:
6035:
6036:
6037:
6038:
6039:
6040:
6041:
6042:
6043:
6044:
6045:
6046:
6047:
6048:
6049:
6050:
6051:
6052:
6053:
6054:
6055:
6056:
6057:
6058:
6059:
6060:
6061:
6062:
6063:
6064:
6065:
6066:
6067:
6068:
6069:
6070:
6071:
6072:
6073:
6074:
6075:
6076:
6077:
6078:
6079:
6080:
6081:
6082:
6083:
6084:
6085:
6086:
6087:
6088:
6089:
6090:
6091:
6092:
6093:
6094:
6095:
6096:
6097:
6098:
6099:
6100:
6101:
6102:
6103:
6104:
6105:
6106:
6107:
6108:
6109:
6110:
6111:
6112:
6113:
6114:
6115:
6116:
6117:
6118:
6119:
6120:
6121:
6122:
6123:
6124:
6125:
6126:
6127:
6128:
6129:
6130:
6131:
6132:
6133:
6134:
6135:
6136:
6137:
6138:
6139:
6140:
6141:
6142:
6143:
6144:
6145:
6146:
6147:
6148:
6149:
6150:
6151:
6152:
6153:
6154:
6155:
6156:
6157:
6158:
6159:
6160:
6161:
6162:
6163:
6164:
6165:
6166:
6167:
6168:
6169:
6170:
6171:
6172:
6173:
6174:
6175:
6176:
6177:
6178:
6179:
6180:
6181:
6182:
6183:
6184:
6185:
6186:
6187:
6188:
6189:
6190:
6191:
6192:
6193:
6194:
6195:
6196:
6197:
6198:
6199:
6200:
6201:
6202:
6203:
6204:
6205:
6206:
6207:
6208:
6209:
6210:
6211:
6212:
6213:
6214:
6215:
6216:
6217:
6218:
6219:
6220:
6221:
6222:
6223:
6224:
6225:
6226:
Min/Max


















Min/Max




























































































































































































































































































































































































































































































































Min/Max

















































































































































































































































































































































































































































































































































































































































































































































































































Min/Max






































































































































































































































































































































































































































































































































































































































































































































































































































































Min/Max





























































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































Min/Max
















































































































































































































































































































































































































































































































































































































Min/Max
























































































































Min/Max




























































































































































































































































































































































































































































































































































Min/Max



















Min/Max















































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































/*
* Copyright (c), Zeriph Enterprises
* All rights reserved.
*
* Contributor(s):
* Zechariah Perez, omni (at) zeriph (dot) com
*
* THIS SOFTWARE IS PROVIDED BY ZERIPH AND CONTRIBUTORS "AS IS" AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL ZERIPH AND CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/* DEV_NOTE: this file is not intended to be used directly by any user code!

i.e. do not #include <omni/xxx_impl.hxx> and do not compile this source directly.
this file is included directly in other source.
*/
// so as not to accidentally build this file with the source
// these macros are defined in chrono
#if !defined(OMNI_DATE_DATA_HXX_FW)
    #error "invalid preprocessor directive detected"
#endif

#define OMNI_DATE_INTERNAL_MAX_DATE_TIME_NUMBER_DIGITS_FW 8
#define OMNI_DATE_INTERNAL_MAX_OFFSET_FW (OMNI_TICKS_PER_HOUR * 14)
#define OMNI_DATE_INTERNAL_MIN_OFFSET_FW -OMNI_DATE_INTERNAL_MAX_OFFSET_FW
#define OMNI_DATE_INTERNAL_TOKEN_HASH_SIZE_FW 199
#define OMNI_DATE_INTERNAL_SECOND_PRIME_FW 197
#define OMNI_DATE_INTERNAL_MAX_SECONDS_FRACTION_DIGITS_FW 7
#define OMNI_DATE_INTERNAL_GMT_NAME_FW "GMT"
#define OMNI_DATE_INTERNAL_ORDER_YMD_FW 0 // The order of date is Year/Month/Day.
#define OMNI_DATE_INTERNAL_ORDER_MDY_FW 1 // The order of date is Month/Day/Year.
#define OMNI_DATE_INTERNAL_ORDER_DMY_FW 2 // The order of date is Day/Month/Year.
#define OMNI_DATE_INTERNAL_ORDER_YDM_FW 3 // The order of date is Year/Day/Month
#define OMNI_DATE_INTERNAL_ORDER_YM_FW 4 // Year/Month order.
#define OMNI_DATE_INTERNAL_ORDER_MY_FW 5 // Month/Year order.
#define OMNI_DATE_INTERNAL_ORDER_MD_FW 6 // Month/Day order.
#define OMNI_DATE_INTERNAL_ORDER_DM_FW 7 // Day/Month order.
#define OMNI_DATE_INTERNAL_DATE_SEP_OR_TZ_OFFSET_FW "-"
#define OMNI_DATE_INTERNAL_INV_DATE_SEP_FW "/"
#define OMNI_DATE_INTERNAL_INV_TIME_SEP_FW ":"
// Common Ignorable Symbols
#define OMNI_DATE_INTERNAL_IGNORABLE_PERIOD_FW "."
#define OMNI_DATE_INTERNAL_IGNORABLE_COMMA_FW ","
#define OMNI_DATE_INTERNAL_LOCAL_TIME_MARK_FW "T"

// TODO: this whole file is a jumbled mess .. the C# code was basically this way too :/ .. need to clean this whole file up

// TODO: The calendar/locale impl's are not going to be added to this version of Omni.
// for now we only support Gregorian calendars and no unicode stuff (e.g. Japanese symbols/etc.)

// TODO: need a "zone info" DB/locale info/calendar/A.D./ C.E./ J.T. .. other calendar "eras"

// DEV_NOTE: if/when it comes time to implement the above (calendar/locale/etc.), `svn up -r 23` has the "old" notes and code/logic for all of that
// to that, a lot of the names in here have been largely kept the same if only turned into snake_case, for posterity.

// DEV_NOTE: there are quite a few duplicated `_insert_hash` .. presumably this is due to the calendars (that are not in omni) and how the hash "map"
// is laid out. It could likely be a single list, but we're keeping it "as-is" because it works .. not to mention this is a massive parsing file
// and parsing is very O(n*n) type of complexity, so it's cool for now (oh C# .. :|)

namespace omni { namespace internal {
    namespace date_time_format {

        // -- start enums --

        // DEV_NOTE: we're keeping the enums in namespaces instead of using classes for 2 reasons:
        // 1 - avoids collision, 2 - using the Omni enum template consumes memory and is pointless
        // for these internal enum types. Maybe might switch to C++11 class enum's but likely not

        // DEV_NOTE: some enum value names (e.g. parse_state::D_Nd) will remain CamelCase for easier differentiation
        namespace parse_state {
            typedef enum enum_t {
                BEGIN = 0,
                N     = 1,    // have one number
                NN     = 2,    // have two numbers

                // The following are known to be part of a date
                D_Nd    = 3,    // date string: have number followed by date separator
                D_NN    = 4,    // date string: have two numbers
                D_NNd = 5,    // date string: have two numbers followed by date separator

                D_M     = 6,    // date string: have a month
                D_MN    = 7,    // date string: have a month and a number
                D_NM    = 8,    // date string: have a number and a month
                D_MNd = 9,    // date string: have a month and number followed by date separator
                D_NDS = 10, // date string: have one number followed a date suffix.

                D_Y     = 11, // date string: have a year.
                D_YN    = 12, // date string: have a year and a number
                D_YNd = 13, // date string: have a year and a number and a date separator
                D_YM    = 14, // date string: have a year and a month
                D_YMd = 15, // date string: have a year and a month and a date separator
                D_S     = 16, // have numbers followed by a date suffix.
                T_S     = 17, // have numbers followed by a time suffix.

                // The following are known to be part of a time
                T_Nt    = 18, // have num followed by time separator
                T_NNt = 19, // have two numbers followed by time separator

                ERR = 20, // this WAS `ERROR` but Windoes doesn't like names like that :|

                // The following are terminal states. These all have an action
                // associated with them; and transition back to BEGIN.
                DX_NN = 21, // day from two numbers
                DX_NNN = 22, // day from three numbers
                DX_MN = 23, // day from month and one number
                DX_NM = 24, // day from month and one number
                DX_MNN = 25, // day from month and two numbers
                DX_DS = 26, // a set of date suffixed numbers.
                DX_DSN = 27, // day from date suffixes and one number.
                DX_NDS = 28, // day from one number and date suffixes.
                DX_NNDS = 29, // day from one number and date suffixes.

                DX_YNN = 30, // date string: have a year and two number
                DX_YMN = 31, // date string: have a year, a month, and a number.
                DX_YN = 32, // date string: have a year and one number
                DX_YM = 33, // date string: have a year, a month.
                TX_N    = 34, // time from one number (must have ampm)
                TX_NN = 35, // time from two numbers
                TX_NNN = 36, // time from three numbers
                TX_TS = 37, // a set of time suffixed numbers.
                DX_NNY = 38
            } enum_t;
        }

        namespace parse_flags {
            typedef enum enum_t {
                HAVE_YEAR         = 0x00000001,
                HAVE_MONTH        = 0x00000002,
                HAVE_DAY         = 0x00000004,
                HAVE_HOUR         = 0x00000008,
                HAVE_MINUTE     = 0x00000010,
                HAVE_SECOND     = 0x00000020,
                HAVE_TIME         = 0x00000040,
                HAVE_DATE         = 0x00000080,
                TIMEZONE_USED     = 0x00000100,
                TIMEZONE_UTC     = 0x00000200,
                PARSED_MONTH_NAME = 0x00000400,
                CAPTURE_OFFSET    = 0x00000800,
                YEAR_DEFAULT     = 0x00001000,
                RFC1123_PATTERN = 0x00002000,
                UTC_SORT_PATTERN = 0x00004000
            } enum_t;
        }
        
        namespace token_type {
            typedef enum enum_t {
                // The valid token should start from 1.
                // Regular tokens. The range is from 0x00 ~ 0xff.
                NUMBER_TOKEN        = 1,        // The number. E.g. "12"
                YEAR_NUMBER_TOKEN = 2,        // The number which is considered as year number, which has 3 or more digits. E.g. "2003"
                AM                 = 3,        // AM time mark. E.g. "AM"
                PM                 = 4,        // PM time mark. E.g. "PM"
                MONTH_TOKEN         = 5,        // A word (or words) that represents a month name. E.g. "Microsoft"
                END_OF_STRING     = 6,        // End of string
                DAY_OF_WEEK_TOKEN = 7,        // A word (or words) that represents a day of week name. E.g. "Monday" or "Mon"
                TIME_ZONE_TOKEN     = 8,        // A word that represents a timezone name. E.g. "GMT"
                ERA_TOKEN         = 9,        // A word that represents a era name. E.g. "A.D."
                DATE_WORD_TOKEN     = 10,     // A word that can appear in a DateTime string, but serves no parsing semantics. E.g. "de" in Spanish culture.
                UNKNOWN_TOKEN     = 11,     // An unknown word, which signals an error in parsing.
                HEBREW_NUMBER     = 12,     // A number that is composed of Hebrew text. Hebrew calendar uses Hebrew digits for year values, month values, and day values.
                JAPANESE_ERA_TOKEN = 13,     // Era name for JapaneseCalendar
                TAIWAN_ERA_TOKEN    = 14,     // Era name for TaiwanCalendar
                IGNORABLE_SYMBOL    = 15,     // A separator like "," that is equivalent to whitespace
                // Separator tokens.
                SEP_UNK             = 0x100,     // Unknown separator.
                SEP_END             = 0x200,     // The end of the parsing string.
                SEP_SPACE         = 0x300,     // Whitespace (including comma).
                SEP_AM             = 0x400,     // AM time mark. E.g. "AM"
                SEP_PM             = 0x500,     // PM time mark. E.g. "PM"
                SEP_Date            = 0x600,     // date separator. E.g. "/"
                SEP_TIME            = 0x700,     // time separator. E.g. ":"
                SEP_YEAR_SUFFIX     = 0x800,     // Chinese/Japanese/Korean year suffix.
                SEP_MONTH_SUFFIX    = 0x900,     // Chinese/Japanese/Korean month suffix.
                SEP_DAY_SUFFIX     = 0xa00,     // Chinese/Japanese/Korean day suffix.
                SEP_HOUR_SUFFIX     = 0xb00,     // Chinese/Japanese/Korean hour suffix.
                SEP_MINUTE_SUFFIX = 0xc00,     // Chinese/Japanese/Korean minute suffix.
                SEP_SECOND_SUFFIX = 0xd00,     // Chinese/Japanese/Korean second suffix.
                SEP_LOCAL_TIME_MARK = 0xe00, // 'T', used in ISO 8601 format.
                SEP_DATE_OR_OFFSET = 0xf00, // '-' which could be a date separator or start of a time zone offset

                REGULAR_TOKEN_MASK = 0x00ff,
                SEPARATOR_TOKEN_MASK= 0xff00
            } enum_t;
        }

        namespace token {
            typedef enum enum_t {
                END                 = 0,    // '\0'
                NUM_END             = 1,    // Num[ ]*[\0]
                NUM_AM_PM         = 2,    // Num[ ]+AmPm
                NUM_SPACE         = 3,    // Num[ ]+^[Dsep|Tsep|'0\']
                NUM_DATE_SEP        = 4,    // Num[ ]*Dsep
                NUM_TIME_SEP        = 5,    // Num[ ]*Tsep
                MONTH_END         = 6,    // Month[ ]*'\0'
                MONTH_SPACE         = 7,    // Month[ ]+^[Dsep|Tsep|'\0']
                MONTH_DATE_SEP     = 8,    // Month[ ]*Dsep
                NUM_DATE_SUFFIX     = 9,    // Month[ ]*DSuff
                NUM_TIME_SUFFIX     = 10, // Month[ ]*TSuff
                DAY_OF_WEEK         = 11, // Day of week name
                YEAR_SPACE         = 12, // Year+^[Dsep|Tsep|'0\']
                YEAR_DATE_SEP     = 13, // Year+Dsep
                YEAR_END            = 14, // Year+['\0']
                TIME_ZONE         = 15, // timezone name
                ERA                 = 16, // era name
                NUM_UTC_TIME_MARK = 17, // Num + 'Z'
                // When you add a new token which will be in the
                // state table, add it after NUM_LOCAL_TIME_MARK.
                UNKNOWN             = 18, // unknown
                NUM_LOCAL_TIME_MARK = 19, // Num + 'T'
                MAX                 = 20    // marker
            } enum_t;
        }

        namespace time_mark {
            typedef enum enum_t {
                NOT_SET = -1,
                AM     = 0,
                PM     = 1
            } enum_t;
        }

        namespace format_flags {
            typedef enum enum_t {
                NONE                        = 0x00000000,
                USE_GENITIVE_MONTH         = 0x00000001,
                USE_LEAP_YEAR_MONTH         = 0x00000002,
                USE_SPACE_IN_MONTH_NAMES    = 0x00000004, // Has spaces or non-breaking space in the month names.
                USE_HEBREW_RULE             = 0x00000008, // Format/Parse using the Hebrew calendar rule.
                USE_SPACE_IN_DAY_NAMES     = 0x00000010, // Has spaces or non-breaking space in the day names.
                USE_DIGIT_PREFIX_IN_TOKENS = 0x00000020, // Has token starting with numbers.
                NOT_INITIALIZED             = -1
            } enum_t;
        }

        namespace found_date_pattern {
            typedef enum enum_t {
                NONE                = 0x0000,
                FOUND_YEAR_PATTERN = 0x0001,
                FOUND_MONTH_PATTERN = 0x0002,
                FOUND_DAY_PATTERN = 0x0004,
                FOUND_YMD_PATTERN = 0x0007 // FOUND_YEAR_PATTERN | FOUND_MONTH_PATTERN | FOUND_DAY_PATTERN;
            } enum_t;
        }

        namespace dt_substring_type {
            typedef enum enum_t {
                UNKNOWN = 0,
                INVALID = 1,
                NUMBER = 2,
                END = 3,
                OTHER = 4
            } enum_t;
        }

        // -- end enums --

        namespace compare_info {
            inline int32_t compare(const std::string& string1, std::size_t offset1, std::size_t length1, const std::string& string2, std::size_t offset2, std::size_t length2)
            {
                return omni::string::util::compare(string1, offset1, length1, string2, offset2, length2, omni::string::compare_options::IGNORE_CASE);
            }

            inline int32_t compare_ordinal(const std::string& string1, std::size_t offset1, std::size_t length1, const std::string& string2, std::size_t offset2, std::size_t length2)
            {
                int32_t result = omni::string::util::compare(string1, offset1, string2, offset2, (length1 < length2 ? length1 : length2), omni::string::compare_options::IGNORE_CASE);
                if ((length1 != length2) && result == 0) {
                    return (length1 > length2 ? 1 : -1);
                }
                return result;
            }
        }

        class parse_result
        {
            public:
                int16_t year;
                int16_t month;
                int16_t day;
                int16_t hour; // Set time default to 00:00:00.
                int16_t minute;
                int16_t second;
                double fraction;
                int16_t era;

                date_time_format::parse_flags::enum_t flags;
                omni::chrono::time_span time_zone_offset;
                omni::chrono::date_time parsed_date;
                omni::chrono::date_time_parse_failure failure;
                std::string failure_message;

                parse_result() :
                    year(-1), month(-1), day(-1),
                    hour(0), minute(0), second(0),
                    fraction(-1), era(-1),
                    flags(),
                    time_zone_offset(),
                    parsed_date(0),
                    failure(),
                    failure_message()
                {
                }

                parse_result(const parse_result& cp) :
                    year(cp.year),
                    month(cp.month),
                    day(cp.day),
                    hour(cp.hour),
                    minute(cp.minute),
                    second(cp.second),
                    fraction(cp.fraction),
                    era(cp.era),
                    flags(cp.flags),
                    time_zone_offset(cp.time_zone_offset),
                    parsed_date(cp.parsed_date),
                    failure(cp.failure),
                    failure_message(cp.failure_message)
                {
                }

                ~parse_result() {}

                parse_result& operator=(const parse_result& cp)
                {
                    this->year = cp.year;
                    this->month = cp.month;
                    this->day = cp.day;
                    this->hour = cp.hour;
                    this->minute = cp.minute;
                    this->second = cp.second;
                    this->fraction = cp.fraction;
                    this->era = cp.era;
                    this->flags = cp.flags;
                    this->time_zone_offset = cp.time_zone_offset;
                    this->parsed_date = cp.parsed_date;
                    this->failure = cp.failure;
                    this->failure_message = cp.failure_message;
                    return *this;
                }

                void set_date(int16_t new_year, int16_t new_month, int16_t new_day)
                {
                    this->year = new_year;
                    this->month = new_month;
                    this->day = new_day;
                }
                
                void set_failure(const omni::chrono::date_time_parse_failure& new_failure, const std::string& new_failure_message)
                {
                    this->failure = new_failure;
                    this->failure_message = new_failure_message;
                }
        };

        class token_hash_value
        {
            public:
                std::string token_string;
                token_type::enum_t token_type;
                int64_t token_value;
                bool empty;

                token_hash_value() :
                    token_string(),
                    token_type(token_type::UNKNOWN_TOKEN),
                    token_value(0),
                    empty(true)
                {}

                token_hash_value(const token_hash_value& cp) :
                    token_string(cp.token_string),
                    token_type(cp.token_type),
                    token_value(cp.token_value),
                    empty(cp.empty)
                {}

                token_hash_value(const std::string& _tokenString, token_type::enum_t _tokenType, int64_t _tokenValue) :
                    token_string(_tokenString),
                    token_type(_tokenType),
                    token_value(_tokenValue),
                    empty(false)
                {
                }
                
                token_hash_value& operator=(const token_hash_value& cp)
                {
                    this->token_string = cp.token_string;
                    this->token_type = cp.token_type;
                    this->token_value = cp.token_value;
                    this->empty = cp.empty;
                    return *this;
                }
        };

        class __dt_string; // forward declaration for format_info class

        class format_info
        {
            public:
                std::string am_designator;
                std::string pm_designator;
                std::string short_date_pattern;
                std::string long_date_pattern;
                std::string full_date_time_pattern;
                std::string general_short_time_pattern;
                std::string general_long_time_pattern;
                std::string month_day_pattern;
                std::string rfc_1123_pattern;
                std::string sortable_date_time_pattern;
                std::string short_time_pattern;
                std::string long_time_pattern;
                std::string universal_sortable_date_time_pattern;
                std::string year_month_pattern;
                std::string time_separator;
                std::string date_separator;
                omni::internal::date_time_format::format_flags::enum_t fmt_flags;
                volatile bool has_year_month_adjustment;
                volatile bool has_force_two_digit_years;

                format_info() :
                    am_designator(OMNI_DATE_FORMAT_INFO_AM_FW),
                    pm_designator(OMNI_DATE_FORMAT_INFO_PM_FW),
                    short_date_pattern("MM/dd/yyyy"),
                    long_date_pattern("dddd, dd MMMM yyyy"),
                    full_date_time_pattern("dddd, dd MMMM yyyy HH:mm:ss"),
                    general_short_time_pattern("MM/dd/yyyy HH:mm"),
                    general_long_time_pattern("MM/dd/yyyy HH:mm:ss"),
                    month_day_pattern("MMMM dd"),
                    rfc_1123_pattern("ddd, dd MMM yyyy HH':'mm':'ss 'GMT'"),
                    sortable_date_time_pattern("yyyy'-'MM'-'dd'T'HH':'mm':'ss"),
                    short_time_pattern("HH:mm"),
                    long_time_pattern("HH:mm:ss"),
                    universal_sortable_date_time_pattern("yyyy'-'MM'-'dd HH':'mm':'ss'Z'"),
                    year_month_pattern("yyyy MMMM"),
                    time_separator(":"),
                    date_separator("/"),
                    fmt_flags(format_flags::NONE),
                    has_year_month_adjustment(false),
                    has_force_two_digit_years(false),
                    m_dtfs(),
                    m_dtfi_token_hash()
                {
                }
                
                format_info(const format_info& cp) :
                    am_designator(cp.am_designator),
                    pm_designator(cp.pm_designator),
                    short_date_pattern(cp.short_date_pattern),
                    long_date_pattern(cp.long_date_pattern),
                    full_date_time_pattern(cp.full_date_time_pattern),
                    general_short_time_pattern(cp.general_short_time_pattern),
                    general_long_time_pattern(cp.general_long_time_pattern),
                    month_day_pattern(cp.month_day_pattern),
                    rfc_1123_pattern(cp.rfc_1123_pattern),
                    sortable_date_time_pattern(cp.sortable_date_time_pattern),
                    short_time_pattern(cp.short_time_pattern),
                    long_time_pattern(cp.long_time_pattern),
                    universal_sortable_date_time_pattern(cp.universal_sortable_date_time_pattern),
                    year_month_pattern(cp.year_month_pattern),
                    time_separator(cp.time_separator),
                    date_separator(cp.date_separator),
                    fmt_flags(cp.fmt_flags),
                    has_year_month_adjustment(cp.has_year_month_adjustment),
                    has_force_two_digit_years(cp.has_force_two_digit_years),
                    m_dtfs(cp.m_dtfs),
                    m_dtfi_token_hash(cp.m_dtfi_token_hash)
                {}

                ~format_info() {}

                format_info& operator=(const format_info& cp)
                {
                    this->am_designator = cp.am_designator;
                    this->pm_designator = cp.pm_designator;
                    this->short_date_pattern = cp.short_date_pattern;
                    this->long_date_pattern = cp.long_date_pattern;
                    this->full_date_time_pattern = cp.full_date_time_pattern;
                    this->general_short_time_pattern = cp.general_short_time_pattern;
                    this->general_long_time_pattern = cp.general_long_time_pattern;
                    this->month_day_pattern = cp.month_day_pattern;
                    this->rfc_1123_pattern = cp.rfc_1123_pattern;
                    this->sortable_date_time_pattern = cp.sortable_date_time_pattern;
                    this->short_time_pattern = cp.short_time_pattern;
                    this->long_time_pattern = cp.long_time_pattern;
                    this->universal_sortable_date_time_pattern = cp.universal_sortable_date_time_pattern;
                    this->year_month_pattern = cp.year_month_pattern;
                    this->time_separator = cp.time_separator;
                    this->date_separator = cp.date_separator;
                    this->fmt_flags = cp.fmt_flags;
                    this->has_year_month_adjustment = cp.has_year_month_adjustment;
                    this->has_force_two_digit_years = cp.has_force_two_digit_years;
                    this->m_dtfs = cp.m_dtfs;
                    this->m_dtfi_token_hash = cp.m_dtfi_token_hash;
                    return *this;
                }

                std::vector<std::string> get_all_date_time_patterns(char format)
                {
                    std::vector<std::string> result;
                    switch (format)
                    {
                        case 'd':
                            result.push_back("MM/dd/yyyy");
                            result.push_back("yyyy-MM-dd");
                            break;
                        case 'D':
                            result.push_back("dddd, dd MMMM yyyy");
                            break;
                        case 't':
                            result.push_back("HH:mm");
                            result.push_back("hh:mm tt");
                            result.push_back("H:mm");
                            result.push_back("h:mm tt");
                            break;
                        case 'T':
                            result.push_back("HH:mm:ss");
                            break;
                        case 'y': case 'Y':
                            result.push_back("yyyy MMMM");
                            break;
                        /*
                            DEV_NOTE: in the C# impl, it accounts for a few more format options, however ..
                            they don't seem to be actually used in the code?? Could be a calendar thing ??
                            The following are the cases we don't account for because they're literally not
                            called elsewhere in code:
                            
                            case 'f': result = GetCombinedPatterns(AllLongDatePatterns, AllShortTimePatterns, " "); break;
                            case 'F':
                            case 'U': result = GetCombinedPatterns(AllLongDatePatterns, AllLongTimePatterns, " "); break;
                            case 'g': result = GetCombinedPatterns(AllShortDatePatterns, AllShortTimePatterns, " "); break;
                            case 'G': result = GetCombinedPatterns(AllShortDatePatterns, AllLongTimePatterns, " "); break;
                            case 'm':
                            case 'M': result = new String[] {month_day_pattern}; break;
                            case 'o':
                            case 'O': result = new String[] {DateTimeFormat.RoundtripFormat}; break;
                            case 'r':
                            case 'R': result = new String[] {rfc1123Pattern}; break;
                            case 's': result = new String[] {sortableDateTimePattern}; break;
                            case 'u': result = new String[] {universal_sortable_date_time_pattern}; break;
                        */
                         default:
                            // This will NEVER get called since this is in our own code .. if someone outside of our code is calling this function, more power to them ;)
                            break;
                    }
                    return result;
                }

                bool has_spaces_in_month_names()
                {
                    return (this->fmt_flags & format_flags::USE_SPACE_IN_MONTH_NAMES) != 0;
                }

                bool has_spaces_in_day_names()
                {
                    return (this->fmt_flags & format_flags::USE_SPACE_IN_DAY_NAMES) != 0;
                }

                bool tokenize (
                    const omni::internal::date_time_format::token_type::enum_t& token_mask,
                    omni::internal::date_time_format::token_type::enum_t& token_type,
                    int64_t& token_value,
                    __dt_string& str
                );

                std::vector<std::string> internal_get_leap_year_names()
                {
                    std::vector<std::string> vals;
                    vals.push_back("January");
                    vals.push_back("February");
                    vals.push_back("March");
                    vals.push_back("April");
                    vals.push_back("May");
                    vals.push_back("June");
                    vals.push_back("July");
                    vals.push_back("August");
                    vals.push_back("September");
                    vals.push_back("October");
                    vals.push_back("November");
                    vals.push_back("December");
                    vals.push_back("");
                    return vals;
                }

                void reset()
                {
                    this->am_designator = OMNI_DATE_FORMAT_INFO_AM_FW;
                    this->pm_designator = OMNI_DATE_FORMAT_INFO_PM_FW;
                    this->short_date_pattern = "MM/dd/yyyy";
                    this->long_date_pattern = "dddd, dd MMMM yyyy";
                    this->short_time_pattern = "HH:mm";
                    this->long_time_pattern = "HH:mm:ss";
                    this->general_short_time_pattern = this->short_date_pattern + " " + this->short_time_pattern;
                    this->general_long_time_pattern = this->short_date_pattern + " " + this->long_time_pattern;
                    this->full_date_time_pattern = this->long_date_pattern + " " + this->long_time_pattern;
                    this->rfc_1123_pattern = "ddd, dd MMM yyyy HH':'mm':'ss 'GMT'";
                    this->sortable_date_time_pattern = "yyyy'-'MM'-'dd'T'HH':'mm':'ss";
                    this->universal_sortable_date_time_pattern = "yyyy'-'MM'-'dd HH':'mm':'ss'Z'";

                    this->month_day_pattern = "MMMM dd";
                    this->year_month_pattern = "yyyy MMMM";
                    this->time_separator = ":";
                    this->date_separator = "/";
                    this->has_year_month_adjustment = false;
                    this->has_force_two_digit_years = false;
                    this->fmt_flags = omni::internal::date_time_format::format_flags::NONE;

                    this->m_dtfi_token_hash.clear();
                }

            private:

                class date_time_format_scanner {
                    public:
                        date_time_format_scanner() : m_scanner_date_words() {}
                        date_time_format_scanner(const date_time_format_scanner& cp) : m_scanner_date_words(cp.m_scanner_date_words) {}
                        ~date_time_format_scanner() {}
                        date_time_format_scanner& operator=(const date_time_format_scanner& cp)
                        {
                            this->m_scanner_date_words = cp.m_scanner_date_words;
                            return *this;
                        }

                        std::vector<std::string> m_scanner_date_words;

                        std::size_t skip_white_space_and_non_letters(const std::string& pattern, std::size_t idx)
                        {
                            while (idx < pattern.size())
                            {
                                char ch = pattern[idx];
                                if (ch == '\\')
                                {
                                    // Escaped character. Look ahead one character.
                                    idx++;
                                    if (idx < pattern.size())
                                    {
                                        ch = pattern[idx];
                                        if (ch == '\'')
                                        {
                                            // Skip the leading single quote. We will
                                            // stop at the first letter.
                                            continue;
                                        }
                                        // Fall thru to check if this is a letter.
                                    } else
                                    {
                                        // End of string
                                        break;
                                    }
                                }
                                if (omni::char_util::is_letter(ch) || ch == '\'' || ch == '.')
                                {                
                                    break;
                                }
                                // Skip the current char since it is not a letter.
                                ++idx;
                            }
                            return idx;
                        }

                        void add_ignorable_symbols(const std::string& text)
                        {
                            // Add the ignorable symbol into the ArrayList.

                            // DEV_NOTE: this is what was in the C#: std::string temp = '\xe001' + text; // IgnorableSymbolChar + text;
                            // but that's a unicode (or wchar_t) and we're not handling that right now.
                            if (std::find(this->m_scanner_date_words.begin(), this->m_scanner_date_words.end(), text) == this->m_scanner_date_words.end()) {
                                this->m_scanner_date_words.push_back(text);
                            }
                        }

                        bool known_words_try_get_value(const std::string& key)
                        {
                            return (key == "/" || key == "-" || key == ".");
                        }

                        void add_date_words_or_postfix(const std::string& format_postfix, const std::string& str)
                        {
                            if (!str.empty()) {
                                // Some cultures use . like an abbreviation
                                if (str == ".") {
                                    this->add_ignorable_symbols(".");
                                    return;
                                }
                                if (!this->known_words_try_get_value(str)) {
                                    if (format_postfix == "MMMM") {
                                        // Add the word into the ArrayList as "\xfffe" + real month postfix.

                                        // DEV_NOTE: this is what was in the C#: std::string temp = '\xe000' + str; // MonthPostfixChar + str;
                                        // but that's a unicode (or wchar_t) and we're not handling that right now.
                                        if (std::find(this->m_scanner_date_words.begin(), this->m_scanner_date_words.end(), str) == this->m_scanner_date_words.end()) {
                                            this->m_scanner_date_words.push_back(str);
                                        }
                                    } else {
                                        if (std::find(this->m_scanner_date_words.begin(), this->m_scanner_date_words.end(), str) == this->m_scanner_date_words.end()) {
                                            this->m_scanner_date_words.push_back(str);
                                        }
                                        if (str[str.size() - 1] == '.') {
                                            // Old version ignore the trialing dot in the date words. Support this as well.
                                            std::string without_dot = str.substr(0, str.size() - 1);
                                            if (std::find(this->m_scanner_date_words.begin(), this->m_scanner_date_words.end(), without_dot) == this->m_scanner_date_words.end()) {
                                                this->m_scanner_date_words.push_back(without_dot);                                
                                            }
                                        }
                                    }
                                }
                            }
                            
                        }

                        std::size_t add_date_words(const std::string& pattern, std::size_t index, std::string format_postfix)
                        {
                            // Skip any whitespaces so we will start from a letter.
                            std::size_t new_index = this->skip_white_space_and_non_letters(pattern, index);
                            if (new_index != index && !format_postfix.empty()) {
                                // There are whitespaces. This will not be a postfix.
                                format_postfix.clear();
                            }
                            index = new_index;

                            // This is the first char added into date_word.
                            // Skip all non-letter character. We will add the first letter into DateWord.
                            std::string date_word;
                            // We assume that date words should start with a letter.
                            // Skip anything until we see a letter.
                            
                            while (index < pattern.size()) {
                                char ch = pattern[index];
                                if (ch == '\'') {
                                    // We have seen the end of quote. Add the word if we do not see it before,
                                    // and break the while loop.                    
                                    this->add_date_words_or_postfix(format_postfix, date_word);
                                    ++index;
                                    break;
                                } else if (ch == '\\') {
                                    // Escaped character. Look ahead one character
                                    // Skip escaped backslash.
                                    ++index;
                                    if (index < pattern.size()) {
                                        date_word += pattern[index];
                                        ++index;
                                    }
                                } else if (omni::char_util::is_white_space(ch)) {
                                    // Found a whitespace. We have to add the current date word/postfix.
                                    this->add_date_words_or_postfix(format_postfix, date_word);
                                    if (!format_postfix.empty()) {
                                        // Done with postfix. The rest will be regular date word.
                                        format_postfix.clear();
                                    }
                                    // Reset the date_word.
                                    date_word.clear();
                                    ++index;
                                } else {
                                    date_word += ch;                                        
                                    ++index;
                                }
                            }
                            return index;
                        }

                        std::size_t scan_repeat_char(const std::string& pattern, char ch, std::size_t index, std::size_t& count)
                        {
                            count = 1;
                            while (++index < pattern.size() && pattern[index] == ch) {
                                ++count;
                            }
                            // Return the updated position.
                            return index;
                        }

                        void scan_date_word(const std::string& pattern)
                        {
                            // Check if we have found all of the year/month/day pattern.
                            uint64_t ymd_flags = omni::internal::date_time_format::found_date_pattern::NONE;

                            std::size_t i = 0;
                            while (i < pattern.size()) {
                                char ch = pattern[i];
                                std::size_t char_count = 0;
                                
                                switch (ch) {
                                    case '\'':
                                        // Find a beginning quote. Search until the end quote.
                                        i = this->add_date_words(pattern, i+1, "");
                                        break;
                                    case 'M':
                                        i = this->scan_repeat_char(pattern, 'M', i, char_count);
                                        if (char_count >= 4) {
                                            if (i < pattern.size() && pattern[i] == '\'') {
                                                i = this->add_date_words(pattern, i+1, "MMMM");
                                            }
                                        }
                                        ymd_flags |= omni::internal::date_time_format::found_date_pattern::FOUND_MONTH_PATTERN;
                                        break;
                                    case 'y':
                                        i = this->scan_repeat_char(pattern, 'y', i, char_count);
                                        ymd_flags |= omni::internal::date_time_format::found_date_pattern::FOUND_YEAR_PATTERN;
                                        break;
                                    case 'd':
                                        i = this->scan_repeat_char(pattern, 'd', i, char_count);
                                        if (char_count <= 2) {
                                            // Only count "d" & "dd".
                                            // ddd, dddd are day names. Do not count them.
                                            ymd_flags |= omni::internal::date_time_format::found_date_pattern::FOUND_DAY_PATTERN;
                                        }
                                        break;
                                    case '\\':
                                        // Found a escaped char not in a quoted string. Skip the current backslash
                                        // and its next character.
                                        i += 2;
                                        break;
                                    case '.':
                                        if (ymd_flags == omni::internal::date_time_format::found_date_pattern::FOUND_YMD_PATTERN) {
                                            // If we find a dot immediately after the we have seen all of the y, m, d pattern.
                                            // treat it as a ignorable symbol. Check for comments in add_ignorable_symbols for
                                            // more details.
                                            this->add_ignorable_symbols(".");
                                            ymd_flags = omni::internal::date_time_format::found_date_pattern::NONE;
                                        }
                                        ++i;
                                        break;
                                    default:
                                        if (ymd_flags == omni::internal::date_time_format::found_date_pattern::FOUND_YMD_PATTERN && !omni::char_util::is_white_space(ch)) {
                                            // We are not seeing "." after YMD. Clear the flag.
                                            ymd_flags = omni::internal::date_time_format::found_date_pattern::NONE;
                                        }
                                        // We are not in quote. Skip the current character.
                                        ++i;
                                        break;
                                }
                            }
                        }

                        std::vector<std::string> get_date_words_of_dtfi(omni::internal::date_time_format::format_info& dtfi)
                        {
                            // Enumerate all LongDatePatterns, and get the DateWords and scan for month postfix.
                            std::vector<std::string> date_patterns = dtfi.get_all_date_time_patterns('D');
                            std::size_t i = 0;
                            
                            // Scan the long date patterns
                            for (i = 0; i < date_patterns.size(); ++i) {
                                this->scan_date_word(date_patterns[i]);
                            }

                            // Scan the short date patterns
                            date_patterns = dtfi.get_all_date_time_patterns('d');
                            for (i = 0; i < date_patterns.size(); ++i) {
                                this->scan_date_word(date_patterns[i]);
                            }
                            // Scan the YearMonth patterns.
                            date_patterns = dtfi.get_all_date_time_patterns('y');
                            for (i = 0; i < date_patterns.size(); ++i) {
                                this->scan_date_word(date_patterns[i]);
                            }

                            // Scan the month/day pattern
                            this->scan_date_word(dtfi.month_day_pattern);
                            
                            // Scan the long time patterns.
                            date_patterns = dtfi.get_all_date_time_patterns('T');
                            for (i = 0; i < date_patterns.size(); ++i) {
                                this->scan_date_word(date_patterns[i]);
                            }

                            // Scan the short time patterns.
                            date_patterns = dtfi.get_all_date_time_patterns('t');
                            for (i = 0; i < date_patterns.size(); ++i) {
                                this->scan_date_word(date_patterns[i]);
                            }

                            std::vector<std::string> result;
                            if (!this->m_scanner_date_words.empty()) {
                                result = this->m_scanner_date_words;
                            }

                            return result;
                        }
                };

                date_time_format_scanner m_dtfs;
                std::vector<omni::internal::date_time_format::token_hash_value> m_dtfi_token_hash;

                void _insert_at_current_hash_node(std::vector<omni::internal::date_time_format::token_hash_value>& hash_table, const std::string& str, char ch, omni::internal::date_time_format::token_type::enum_t token_type, int64_t token_value, std::size_t pos, int64_t hash_code, int64_t hash_probe)
                {
                    // Remember the current slot.
                    omni::internal::date_time_format::token_hash_value prev = hash_table[static_cast<std::size_t>(hash_code)];
                    // Insert the new node into the current slot.
                    hash_table[static_cast<std::size_t>(hash_code)] = omni::internal::date_time_format::token_hash_value(str, token_type, token_value);

                    while (++pos < OMNI_DATE_INTERNAL_TOKEN_HASH_SIZE_FW) {
                        hash_code += hash_probe;
                        if (hash_code >= OMNI_DATE_INTERNAL_TOKEN_HASH_SIZE_FW) {
                            hash_code -= OMNI_DATE_INTERNAL_TOKEN_HASH_SIZE_FW;
                        }

                        // Remember this slot
                        omni::internal::date_time_format::token_hash_value temp = hash_table[static_cast<std::size_t>(hash_code)];
                        if (omni::char_util::to_lower(temp.token_string[0]) != ch) {
                            continue;
                        }

                        // Put the previous slot into this slot.
                        hash_table[static_cast<std::size_t>(hash_code)] = prev;
                        if (temp.token_string.empty()) {
                            // Done
                            return;
                        }
                        prev = temp;
                    }
                }

                // DEV_NOTE: have `str` be a copied object because it gets edited in this function
                void _insert_hash(std::vector<omni::internal::date_time_format::token_hash_value>& hash_table, std::string str, omni::internal::date_time_format::token_type::enum_t token_type, int64_t token_value)
                {
                    // The month of the 13th month is allowed to be empty, so make sure that we ignore empty value here.
                    if (str.empty()) {
                        return;
                    }
                    omni::internal::date_time_format::token_hash_value value;
                    std::size_t i = 0;
                    // If there is whitespace characters in the beginning and end of the string, trim them since whitespaces are skipped by
                    // DateTime.Parse().
                    if (omni::char_util::is_white_space(str[0]) || omni::char_util::is_white_space(str[str.size() - 1])) {
                        str = omni::string::util::trim(str); // Trim white space characters.
                        // Could have space for separators
                        if (str.size() == 0)
                            return;
                        }
                    char ch = omni::char_util::to_lower(str[0]); // Char.ToLower(str[0], this->Culture);
                    int64_t hash_code = ch % OMNI_DATE_INTERNAL_TOKEN_HASH_SIZE_FW;
                    int64_t hash_probe = 1 + ch % OMNI_DATE_INTERNAL_SECOND_PRIME_FW;
                    do {
                        value = hash_table[static_cast<std::size_t>(hash_code)];
                        if (value.token_string.empty()) {
                            hash_table[static_cast<std::size_t>(hash_code)] = omni::internal::date_time_format::token_hash_value(str, token_type, token_value);
                            return;
                        } else {
                            // Collision happens. Find another slot.
                            if (str.size() >= value.token_string.size()) {
                                // If there are two tokens with the same prefix, we have to make sure that the longer token should be at the front of
                                // the shorter ones.
                                if (omni::string::util::compare(str, 0, value.token_string, 0, value.token_string.size(), omni::string::compare_options::IGNORE_CASE) == 0) {
                                    if (str.size() > value.token_string.size()) {
                                        // The str to be inserted has the same prefix as the current token, and str is longer.
                                        // Insert str into this node, and shift every node behind it.
                                        _insert_at_current_hash_node(hash_table, str, ch, token_type, token_value, i, hash_code, hash_probe);
                                        return;
                                    } else {
                                        // Same token. If they have different types (regular token vs separator token). Add them.
                                        // If we have the same regular token or separator token in the hash already, do NOT update the hash.
                                        // Therefore, the order of inserting token is significant here regarding what token_type will be kept in the hash.

                                        // Check the current value of RegularToken (stored in the lower 8-bit of token_type) , and insert the token_type into the hash ONLY when we don't have a RegularToken yet.
                                        // Also check the current value of SeparatorToken (stored in the upper 8-bit of token), and insert the token_type into the hash ONLY when we don't have the SeparatorToken yet.
                                        omni::internal::date_time_format::token_type::enum_t tok = token_type;
                                        omni::internal::date_time_format::token_type::enum_t curr_hash_tok = value.token_type;
                                        if (
                                            (((curr_hash_tok & omni::internal::date_time_format::token_type::REGULAR_TOKEN_MASK) == 0) && ((tok & omni::internal::date_time_format::token_type::REGULAR_TOKEN_MASK) != 0)) ||
                                            (((curr_hash_tok & omni::internal::date_time_format::token_type::SEPARATOR_TOKEN_MASK) == 0) && ((tok & omni::internal::date_time_format::token_type::SEPARATOR_TOKEN_MASK) != 0))
                                        ) {
                                            value.token_type = static_cast<omni::internal::date_time_format::token_type::enum_t>(value.token_type | token_type);
                                            if (token_value != 0) {
                                                value.token_value = token_value;
                                            }
                                        }
                                        // The token to be inserted is already in the table. Skip it.
                                    }
                                }
                            }
                        }
                        ++i;
                        hash_code += hash_probe;
                        if (hash_code >= OMNI_DATE_INTERNAL_TOKEN_HASH_SIZE_FW) {
                            hash_code -= OMNI_DATE_INTERNAL_TOKEN_HASH_SIZE_FW;
                        }
                    } while (i < OMNI_DATE_INTERNAL_TOKEN_HASH_SIZE_FW);
                }

                void _add_month_names(std::vector<omni::internal::date_time_format::token_hash_value>& temp, const std::string& month_postfix)
                {
                    for (std::size_t i = 1; i < omni::chrono::month::COUNT(); ++i) {
                        // We have to call public methods here to work with inherited DTFI.
                        // Insert the month name first, so that they are at the front of abbreviated month names.
                        if (!month_postfix.empty()) {
                            // Insert the month name with the postfix first, so it can be matched first.
                            this->_insert_hash(temp, (omni::chrono::month::get_name(i) + month_postfix), omni::internal::date_time_format::token_type::MONTH_TOKEN, static_cast<int64_t>(i));
                        } else
                        {
                            this->_insert_hash(temp, omni::chrono::month::get_name(i), omni::internal::date_time_format::token_type::MONTH_TOKEN, static_cast<int64_t>(i));
                        }
                        this->_insert_hash(temp, omni::chrono::month::get_abbreviated_name(i), omni::internal::date_time_format::token_type::MONTH_TOKEN, static_cast<int64_t>(i));
                    }
                }

                std::vector<omni::internal::date_time_format::token_hash_value> _create_token_hash_table()
                {
                    // DEV_NOTE: this function adds values into the list multiple times .. I haven't gone through the areas of this "hash" function
                    // fully to make sure "why" it does this; I'm assuming it has to do with how the C# version uses calendars and thus "hashes" it
                    // in certain areas, thus returning the "value" at that "hash" ... either way "it works (tm)", so not going to futz with it for now.
                    std::vector<omni::internal::date_time_format::token_hash_value> temp = m_dtfi_token_hash;
                    if (temp.capacity() == 0) {
                        for (std::size_t i = 0; i < OMNI_DATE_INTERNAL_TOKEN_HASH_SIZE_FW; ++i) {
                            temp.push_back(omni::internal::date_time_format::token_hash_value());
                        }

                        std::string sep = omni::string::util::trim(this->time_separator);

                        if (OMNI_DATE_INTERNAL_IGNORABLE_COMMA_FW != sep) {
                            this->_insert_hash(temp, OMNI_DATE_INTERNAL_IGNORABLE_COMMA_FW, omni::internal::date_time_format::token_type::IGNORABLE_SYMBOL, 0);
                        }
                        if (OMNI_DATE_INTERNAL_IGNORABLE_PERIOD_FW != sep) {
                            this->_insert_hash(temp, OMNI_DATE_INTERNAL_IGNORABLE_PERIOD_FW, omni::internal::date_time_format::token_type::IGNORABLE_SYMBOL, 0);
                        }

                        this->_insert_hash(temp, OMNI_DATE_FORMAT_INFO_AM_FW, static_cast<omni::internal::date_time_format::token_type::enum_t>(omni::internal::date_time_format::token_type::SEP_AM | omni::internal::date_time_format::token_type::AM), 0);
                        this->_insert_hash(temp, OMNI_DATE_FORMAT_INFO_PM_FW, static_cast<omni::internal::date_time_format::token_type::enum_t>(omni::internal::date_time_format::token_type::SEP_PM | omni::internal::date_time_format::token_type::PM), 1);
                        this->_insert_hash(temp, OMNI_DATE_INTERNAL_DATE_SEP_OR_TZ_OFFSET_FW, omni::internal::date_time_format::token_type::SEP_DATE_OR_OFFSET, 0);

                        std::vector<std::string> date_words = m_dtfs.get_date_words_of_dtfi(*this);
                        // Ensure the format flags is initialized.
                        // omni::internal::date_time_format::format_flags::enum_t flag = fmt_flags;

                        // For some cultures, the date separator works more like a comma, being allowed before or after any date part.
                        // In these cultures, we do not use normal date separator since we disallow date separator after a date terminal state.
                        // This is determined in DateTimeFormatInfoScanner. Use this flag to determine if we should treat date separator as ignorable symbol.
                        bool use_date_sep_as_ignorable_symbol = false;

                        std::string month_postfix;
                        if (!date_words.empty()) {
                            // There are DateWords. It could be a real date word (such as "de"), or a month_postfix.
                            // The month_postfix starts with '\xfffe' (MonthPostfixChar), followed by the real month_postfix.
                            for (std::size_t i = 0; i < date_words.size(); ++i) {
                                char val1 = date_words[i][0];
                                if (val1 == '\xe0') {
                                    if ((date_words[i].size() > 1) && ((date_words[i][1] == '\x00') || (date_words[i][1] == '\x01'))) {
                                        if (date_words[i][1] == '\x00') {
                                            // Get the real month postfix.
                                            month_postfix = date_words[i].substr(1);
                                            // Add the month name + postfix into the token.
                                            this->_add_month_names(temp, month_postfix);
                                        } else {
                                            std::string symbol = date_words[i].substr(1);
                                            this->_insert_hash(temp, symbol, omni::internal::date_time_format::token_type::IGNORABLE_SYMBOL, 0);
                                            if (omni::string::util::trim(this->date_separator) == symbol) {
                                                // The date separator is the same as the ignorable symbol.
                                                use_date_sep_as_ignorable_symbol = true;
                                            }
                                        }
                                    } else {
                                        this->_insert_hash(temp, date_words[i], omni::internal::date_time_format::token_type::DATE_WORD_TOKEN, 0);    
                                    }
                                } else {
                                    this->_insert_hash(temp, date_words[i], omni::internal::date_time_format::token_type::DATE_WORD_TOKEN, 0);
                                }
                            }
                        }

                        if (!use_date_sep_as_ignorable_symbol) {
                            // Use the normal date separator.
                            this->_insert_hash(temp, this->date_separator, omni::internal::date_time_format::token_type::SEP_Date, 0);
                        }
                        // Add the regular month names.
                        this->_add_month_names(temp, "");

                        // Add the abbreviated month names.
                        for (std::size_t i = 1; i <= omni::chrono::month::COUNT(); ++i) {
                            this->_insert_hash(temp, omni::chrono::month::get_abbreviated_name(i), omni::internal::date_time_format::token_type::MONTH_TOKEN, static_cast<int64_t>(i));
                        }

                        if ((fmt_flags & format_flags::USE_GENITIVE_MONTH) != 0) {
                            for (std::size_t i = 1; i < omni::chrono::month::COUNT(); ++i) {
                                this->_insert_hash(temp, omni::chrono::month::get_abbreviated_name(i), omni::internal::date_time_format::token_type::MONTH_TOKEN, static_cast<int64_t>(i));
                            }
                            this->_insert_hash(temp, "", omni::internal::date_time_format::token_type::MONTH_TOKEN, 13);
                        }

                        if ((fmt_flags & format_flags::USE_LEAP_YEAR_MONTH) != 0) {
                            for (std::size_t i = 1; i < omni::chrono::month::COUNT(); ++i) {
                                this->_insert_hash(temp, omni::chrono::month::get_name(i), omni::internal::date_time_format::token_type::MONTH_TOKEN, static_cast<int64_t>(i));
                            }
                            this->_insert_hash(temp, "", omni::internal::date_time_format::token_type::MONTH_TOKEN, 13);
                        }

                        for (std::size_t i = 0; i < omni::chrono::day::COUNT(); ++i) {
                            // We have to call public methods here to work with inherited DTFI.
                            this->_insert_hash(temp, omni::chrono::day::get_name(i), omni::internal::date_time_format::token_type::DAY_OF_WEEK_TOKEN, static_cast<int64_t>(i));
                            this->_insert_hash(temp, omni::chrono::day::get_abbreviated_name(i), omni::internal::date_time_format::token_type::DAY_OF_WEEK_TOKEN, static_cast<int64_t>(i));
                        }

                        this->_insert_hash(temp, OMNI_DATE_ERA_FW, omni::internal::date_time_format::token_type::ERA_TOKEN, 1);
                        this->_insert_hash(temp, OMNI_DATE_ERA_ABBR_FW, omni::internal::date_time_format::token_type::ERA_TOKEN, 1);
                        this->_insert_hash(temp, OMNI_DATE_FORMAT_INFO_AM_FW, static_cast<omni::internal::date_time_format::token_type::enum_t>(omni::internal::date_time_format::token_type::SEP_AM | omni::internal::date_time_format::token_type::AM), 0);
                        this->_insert_hash(temp, OMNI_DATE_FORMAT_INFO_PM_FW, static_cast<omni::internal::date_time_format::token_type::enum_t>(omni::internal::date_time_format::token_type::SEP_PM | omni::internal::date_time_format::token_type::PM), 1);

                        // Add invariant month names and day names.
                        for (std::size_t i = 1; i < omni::chrono::month::COUNT(); ++i) {
                            // We have to call public methods here to work with inherited DTFI.
                            // Insert the month name first, so that they are at the front of abbreviated month names.
                            this->_insert_hash(temp, omni::chrono::month::get_name(i), omni::internal::date_time_format::token_type::MONTH_TOKEN, static_cast<int64_t>(i));
                            this->_insert_hash(temp, omni::chrono::month::get_abbreviated_name(i), omni::internal::date_time_format::token_type::MONTH_TOKEN, static_cast<int64_t>(i));
                        }

                        for (std::size_t i = 0; i < omni::chrono::day::COUNT(); ++i) {
                            // We have to call public methods here to work with inherited DTFI.
                            this->_insert_hash(temp, omni::chrono::day::get_name(i), omni::internal::date_time_format::token_type::DAY_OF_WEEK_TOKEN, static_cast<int64_t>(i));
                            this->_insert_hash(temp, omni::chrono::day::get_abbreviated_name(i), omni::internal::date_time_format::token_type::DAY_OF_WEEK_TOKEN, static_cast<int64_t>(i));
                        }

                        this->_insert_hash(temp, OMNI_DATE_ERA_ABBR_FW, omni::internal::date_time_format::token_type::ERA_TOKEN, 1);

                        this->_insert_hash(temp, OMNI_DATE_INTERNAL_LOCAL_TIME_MARK_FW, omni::internal::date_time_format::token_type::SEP_LOCAL_TIME_MARK, 0);
                        this->_insert_hash(temp, OMNI_DATE_INTERNAL_GMT_NAME_FW, omni::internal::date_time_format::token_type::TIME_ZONE_TOKEN, 0);
                        this->_insert_hash(temp, OMNI_DATE_ZULU_NAME_FW, omni::internal::date_time_format::token_type::TIME_ZONE_TOKEN, 0);

                        this->_insert_hash(temp, OMNI_DATE_INTERNAL_INV_DATE_SEP_FW, omni::internal::date_time_format::token_type::SEP_Date, 0);
                        this->_insert_hash(temp, OMNI_DATE_INTERNAL_INV_TIME_SEP_FW, omni::internal::date_time_format::token_type::SEP_TIME, 0);

                        m_dtfi_token_hash = temp;
                    }
                    return temp;
                }
        };

        class date_time_token
        {
            public:
                omni::internal::date_time_format::token::enum_t dtt; // Store the token
                omni::internal::date_time_format::token_type::enum_t suffix; // Store the CJK Year/Month/Day suffix (if any)
                int64_t num;    // Store the number that we are parsing (if any)

                date_time_token() :
                    dtt(omni::internal::date_time_format::token::UNKNOWN),
                    suffix(omni::internal::date_time_format::token_type::SEP_UNK),
                    num(0)
                {}

                date_time_token(const date_time_token& cp) :
                    dtt(cp.dtt),
                    suffix(cp.suffix),
                    num(cp.num)
                {}

                ~date_time_token()
                {
                }

                date_time_token& operator=(const date_time_token& cp)
                {
                    this->dtt = cp.dtt;
                    this->suffix = cp.suffix;
                    this->num = cp.num;
                    return *this;
                }
        };

        // The buffer to store temporary parsing information.
        class date_time_raw_info
        {
            public:
                int64_t* num;
                int64_t num_count;
                int64_t month;
                int64_t year;
                int64_t day_of_week;
                int64_t era;
                omni::internal::date_time_format::time_mark::enum_t time_mark;
                double fraction;
                bool has_same_date_and_time_separators;
                bool time_zone;

                explicit date_time_raw_info(int64_t* buff) :
                    num(buff),
                    num_count(0),
                    month(-1),
                    year(-1),
                    day_of_week(-1),
                    era(-1),
                    time_mark(omni::internal::date_time_format::time_mark::NOT_SET),
                    fraction(-1),
                    has_same_date_and_time_separators(false),
                    time_zone(false)
                {
                }

                ~date_time_raw_info() {}

                void add_number(int64_t value)
                {
                    this->num[this->num_count++] = value;
                }

                int64_t get_number(int64_t index)
                {
                    return this->num[index];
                }

            private:
                // making these not user accessible because it should only be the "buffer" constructor that's used
                // so don't implicitly create any extra code
                date_time_raw_info();
                date_time_raw_info(const date_time_raw_info& cp);
                date_time_raw_info& operator=(const date_time_raw_info& cp);
        };

        class dt_sub_string
        {
            public:
                std::string s;
                int32_t index;
                int32_t length;
                omni::internal::date_time_format::dt_substring_type::enum_t type;
                int32_t value;

                dt_sub_string() :
                    s(),
                    index(0),
                    length(0),
                    type(dt_substring_type::UNKNOWN),
                    value(0)
                {}

                dt_sub_string(const dt_sub_string& cp) :
                    s(cp.s),
                    index(cp.index),
                    length(cp.length),
                    type(cp.type),
                    value(cp.value)
                {}

                ~dt_sub_string() {}

                dt_sub_string& operator=(const dt_sub_string& cp)
                {
                    this->s = cp.s;
                    this->index = cp.index;
                    this->length = cp.length;
                    this->type = cp.type;
                    this->value = cp.value;
                    return *this;
                }

                char operator[](int32_t relative_index)
                {
                    return this->s[static_cast<std::size_t>(this->index + relative_index)];
                }
        };

        // DEV_NOTE: keeping the `__` in the name for posterity since that's how it is in the C# impl
        class __dt_string
        {
            public:
                // this->value property: stores the real string to be parsed.
                std::string value;

                // this->index property: points to the character that we are currently parsing.
                int64_t index;

                // The length of this->value string.
                int64_t len;

                // The current character to be looked at.
                char current_char;

                // Flag to indicate if we encounter an digit, we should check for token or not.
                // In some cultures, such as mn-MN, it uses "\x0031\x00a0\x0434\x04af\x0433\x044d\x044d\x0440\x00a0\x0441\x0430\x0440" in month names.
                bool check_digit_token;

                __dt_string(const std::string& str, omni::internal::date_time_format::format_info& dtfi) :
                    value(str),
                    index(-1),
                    len(static_cast<int64_t>(str.length())),
                    current_char('\0'),
                    check_digit_token(((dtfi.fmt_flags & format_flags::USE_DIGIT_PREFIX_IN_TOKENS) != 0))
                {
                }

                __dt_string(const std::string& str, omni::internal::date_time_format::format_info& dtfi, bool check_token) :
                    value(str),
                    index(-1),
                    len(static_cast<int64_t>(str.length())),
                    current_char('\0'),
                    check_digit_token(check_token)
                {
                    OMNI_UNUSED(dtfi);
                }

                __dt_string(const __dt_string& cp) :
                    value(cp.value),
                    index(cp.index),
                    len(cp.len),
                    current_char(cp.current_char),
                    check_digit_token(cp.check_digit_token)
                {
                }

                ~__dt_string() {}

                __dt_string& operator=(const __dt_string& cp)
                {
                    this->value = cp.value;
                    this->index = cp.index;
                    this->len = cp.len;
                    this->current_char = cp.current_char;
                    this->check_digit_token = cp.check_digit_token;
                    return *this;
                }

                /*
                    advance the this->index.
                    Return true if this->index is NOT at the end of the string.

                    Typical usage:
                    while (str.get_next()) {
                        char ch = str.get_char()
                    }
                */
                 bool get_next()
                {
                    this->index++;
                    if (this->index < len) {
                        this->current_char = this->value[static_cast<std::size_t>(this->index)];
                        return true;
                    }
                    return false;
                }

                bool at_end()
                {
                    return this->index < this->len ? false : true;
                }

                bool advance(int64_t count)
                {
                    this->index += count;
                    if (this->index < this->len) {
                        this->current_char = this->value[static_cast<std::size_t>(this->index)];
                        return true;
                    }
                    return false;
                }

                // Used by DateTime.Parse() to get the next token.
                void get_regular_token(
                    omni::internal::date_time_format::token_type::enum_t& token_type,
                    int64_t& token_value,
                    omni::internal::date_time_format::format_info& dtfi,
                    bool recurse
                ) {
                    if (!recurse) {
                        token_value = 0;
                        if (this->index >= len) {
                            token_type = omni::internal::date_time_format::token_type::END_OF_STRING;
                            return;
                        }
                        token_type = omni::internal::date_time_format::token_type::UNKNOWN_TOKEN;
                    }

                    // Start:
                    if (omni::char_util::is_digit(this->current_char)) {
                        // This is a digit.
                        int64_t char_val = 0;
                        int64_t start = this->index;
                        token_value = this->current_char - '0';

                        // Collect other digits.
                        while (++this->index < len) {
                            this->current_char = this->value[static_cast<std::size_t>(this->index)];
                            char_val = this->current_char - '0';
                            if (char_val >= 0 && char_val <= 9) {
                                token_value = token_value * 10 + char_val;
                            } else {
                                break;
                            }
                        }

                        if (this->index - start > OMNI_DATE_INTERNAL_MAX_DATE_TIME_NUMBER_DIGITS_FW) {
                            token_type = omni::internal::date_time_format::token_type::NUMBER_TOKEN;
                            token_value = -1;
                        } else if (this->index - start < 3) {
                            token_type = omni::internal::date_time_format::token_type::NUMBER_TOKEN;
                        } else {
                            // If there are more than 3 digits, assume that it's a year value.
                            token_type = omni::internal::date_time_format::token_type::YEAR_NUMBER_TOKEN;
                        }

                        if (this->check_digit_token) {
                            omni::internal::date_time_format::token_type::enum_t temp_type = omni::internal::date_time_format::token_type::SEP_UNK;
                            int64_t temp_val = 0;
                            int64_t save = this->index;
                            char save_ch = this->current_char;
                            // Re-scan using the staring this->index to see if this is a token.
                            this->index = start; // To include the first digit.
                            this->current_char = this->value[static_cast<std::size_t>(this->index)];
                            // This DTFI has tokens starting with digits.
                            // E.g. mn-MN has month name like "\x0031\x00a0\x0434\x04af\x0433\x044d\x044d\x0440\x00a0\x0441\x0430\x0440"
                            if (dtfi.tokenize(omni::internal::date_time_format::token_type::REGULAR_TOKEN_MASK, temp_type, temp_val, *this)) {
                                token_type = temp_type;
                                token_value = temp_val;
                                // This is a token, so the this->index has been advanced properly in DTFI.Tokenizer().
                            } else {
                                // Use the number token value.
                                // Restore the index.
                                this->index = save;
                                this->current_char = save_ch;
                            }
                        }
                    } else if (omni::char_util::is_white_space(this->current_char)) {
                        // Just skip to the next character.
                        bool eof = true;
                        while (++this->index < this->len) {
                            this->current_char = this->value[static_cast<std::size_t>(this->index)];
                            if (!(omni::char_util::is_white_space(this->current_char))) {
                                // goto Start;
                                get_regular_token(token_type, token_value, dtfi, true);
                                eof = false;
                                break;
                            }
                        }
                        if (eof) {
                            // We have reached the end of string.
                            token_type = omni::internal::date_time_format::token_type::END_OF_STRING;
                        }
                    } else {
                        dtfi.tokenize(omni::internal::date_time_format::token_type::REGULAR_TOKEN_MASK, token_type, token_value, *this);
                    }
                }
                
                omni::internal::date_time_format::token_type::enum_t get_separator_token(omni::internal::date_time_format::format_info& dtfi, int64_t& index_before_sep, char& char_before_sep)
                {
                    index_before_sep = this->index;
                    char_before_sep = this->current_char;
                    if (!this->skip_white_space_current()) {
                        // Reach the end of the string.
                        return omni::internal::date_time_format::token_type::SEP_END;
                    }

                    if (!omni::char_util::is_digit(this->current_char)) {
                        // Not a digit. tokenize it.
                        omni::internal::date_time_format::token_type::enum_t token_type = omni::internal::date_time_format::token_type::SEP_UNK;
                        int64_t token_value = 0;
                        if (!dtfi.tokenize(omni::internal::date_time_format::token_type::SEPARATOR_TOKEN_MASK, token_type, token_value, *this)) {
                            return omni::internal::date_time_format::token_type::SEP_SPACE;
                        }
                        return token_type;
                    }

                    // Do nothing here. If we see a number, it will not be a separator. There is no need wasting time trying to find the separator token.
                    return omni::internal::date_time_format::token_type::SEP_SPACE;
                }

                bool match_specified_word(const std::string& target, int64_t end_idx)
                {
                    int64_t count = end_idx - this->index;
                    if (static_cast<std::size_t>(count) != target.size()) {
                        return false;
                    }
                    if ((this->index + count) > this->len) {
                        return false;
                    }
                    return (omni::internal::date_time_format::compare_info::compare(this->value, static_cast<std::size_t>(this->index), static_cast<std::size_t>(count), target, 0, static_cast<std::size_t>(count)) == 0);
                }

                bool match_specified_word(const std::string& target)
                {
                    return this->match_specified_word(target, static_cast<int64_t>(target.size() + static_cast<std::size_t>(this->index)));
                }

                bool match_specified_words(const std::string& target, bool check_word_boundary, std::size_t& match_len)
                {
                    const char* WS_CHECKS = " ";
                    std::size_t val_remaining = this->value.size() - static_cast<std::size_t>(this->index);
                    match_len = target.size();

                    if ((match_len > val_remaining) || (omni::internal::date_time_format::compare_info::compare(this->value, static_cast<std::size_t>(this->index), match_len, target, 0, match_len) != 0)) {
                        // Check word by word
                        std::size_t target_pos = 0; // Where we are in the target string
                        std::size_t this_pos = static_cast<std::size_t>(this->index); // Where we are in this string
                        std::size_t ws_idx = target.find_first_of(WS_CHECKS, target_pos);
                        if (ws_idx == std::string::npos) {
                            return false;
                        }
                        do {
                            std::size_t segment_len = ws_idx - target_pos;
                            if (this_pos >= this->value.size() - segment_len) { // Subtraction to prevent overflow.
                                return false;
                            }
                            if (segment_len == 0) {
                                // If segment_len == 0, it means that we have leading space in the target string.
                                // In that case, skip the leading spaces in the target and this string.
                                match_len--;
                            } else {
                                // Make sure we also have whitespace in the input string
                                if (!omni::char_util::is_white_space(this->value[this_pos + segment_len])) {
                                    return false;
                                }
                                if (omni::internal::date_time_format::compare_info::compare(this->value, this_pos, segment_len, target, target_pos, segment_len) !=0) {
                                    return false;
                                }
                                // advance the input string
                                this_pos = this_pos + segment_len + 1;
                            }
                            // advance our target string
                            target_pos = ws_idx + 1;


                            // Skip past multiple whitespace
                            while (this_pos < this->value.size() && omni::char_util::is_white_space(this->value[this_pos])) {
                                this_pos++;
                                match_len++;
                            }
                        } while ((ws_idx = target.find_first_of(WS_CHECKS, target_pos)) != std::string::npos);
                        // now check the last segment;
                        if (target_pos < target.size()) {
                            std::size_t segment_len = target.size() - target_pos;
                            if (this_pos > this->value.size() - segment_len) {
                                return false;
                            }
                            if (omni::internal::date_time_format::compare_info::compare(this->value, this_pos, segment_len, target, target_pos, segment_len) !=0) {
                                return false;
                            }
                        }
                    }

                    if (check_word_boundary) {
                        std::size_t next_char_idx = static_cast<std::size_t>(this->index) + match_len;
                        if (next_char_idx < this->value.size()) {
                            if (omni::char_util::is_letter(this->value[next_char_idx])) {
                                return false;
                            }
                        }
                    }
                    return true;
                }

                // Check to see if the string starting from this->index is a prefix of str.
                // If a match is found, true value is returned and this->index is updated to the next character to be parsed.
                // Otherwise, this->index is unchanged.
                bool match(const std::string& str)
                {
                    if (++this->index >= this->len) {
                        return false;
                    }

                    if (str.size() > (this->value.size() - static_cast<std::size_t>(this->index))) {
                        return false;
                    }

                    if (omni::internal::date_time_format::compare_info::compare_ordinal(this->value, static_cast<std::size_t>(this->index), str.size(), str, 0, str.size()) == 0) {
                        // Update the this->index to the end of the matching string.
                        // So the following get_next()/match() operation will get
                        // the next character to be parsed.
                        this->index += (str.size() - 1);
                        return true;
                    }
                    return false;
                }

                bool match(char ch)
                {
                    if (++this->index >= this->len) {
                        return false;
                    }
                    if (this->value[static_cast<std::size_t>(this->index)] == ch) {
                        this->current_char = ch;
                        return true;
                    }
                    this->index--;
                    return false;
                }

                int64_t match_longest_words(const std::vector<std::string>& words, int64_t& max_match_str_len)
                {
                    int64_t result = -1;
                    std::size_t match_len = 0;
                    for (std::size_t i = 0; i < words.size(); ++i) {
                        match_len = words[i].size();
                        if (this->match_specified_words(words[i], false, match_len)) {
                            if (match_len > static_cast<std::size_t>(max_match_str_len)) {
                                max_match_str_len = static_cast<int64_t>(match_len);
                                result = static_cast<int64_t>(i);
                            }
                        }
                    }
                    return result;
                }

                // Get the number of repeat character after the current character.
                // For a string "hh:mm:ss" at this->index of 3. get_repeat_count() = 2, and this->index
                // will point to the second ':'.
                std::size_t get_repeat_count()
                {
                    char repeatChar = this->value[static_cast<std::size_t>(this->index)];
                    std::size_t pos = static_cast<std::size_t>(this->index) + 1;
                    while ((pos < static_cast<std::size_t>(len)) && (this->value[pos] == repeatChar)) {
                        pos++;
                    }
                    std::size_t repeat_count = (pos - static_cast<std::size_t>(this->index));
                    // Update the this->index to the end of the repeated characters.
                    // So the following get_next() operation will get
                    // the next character to be parsed.
                    this->index = static_cast<int64_t>(pos - 1);
                    return repeat_count;
                }

                // Return false when end of string is encountered or a non-digit character is found.
                bool get_next_digit()
                {
                    if (++this->index >= this->len) {
                        return false;
                    }
                    return omni::char_util::is_digit(this->value[static_cast<std::size_t>(this->index)]);
                }

                // Get the current character.
                char get_char()
                {
                    return this->value[static_cast<std::size_t>(this->index)];
                }

                // Convert the current character to a digit, and return it.
                std::size_t get_digit()
                {
                    return static_cast<std::size_t>((this->value[static_cast<std::size_t>(this->index)] - '0'));
                }

                // Eat White Space ahead of the current position
                // Return false if end of string is encountered.
                void skip_white_spaces()
                {
                    // Look ahead to see if the next character is a whitespace.
                    while (this->index+1 < this->len) {
                        if (!omni::char_util::is_white_space(this->value[static_cast<std::size_t>(this->index)+1])) {
                            return;
                        }
                        this->index++;
                    }
                }

                // Skip white spaces from the current position
                // Return false if end of string is encountered.
                bool skip_white_space_current()
                {
                    if (this->index >= this->len) {
                        return false;
                    }
                    if (!omni::char_util::is_white_space(this->current_char)) {
                        return true;
                    }
                    while (++this->index < this->len) {
                        this->current_char = this->value[static_cast<std::size_t>(this->index)];
                        if (!omni::char_util::is_white_space(this->current_char)) {
                            return true;
                        }
                        // Nothing here.
                    }
                    return false;
                }

                void trim_tail()
                {
                    int64_t i = this->len - 1;
                    while (i >= 0 && omni::char_util::is_white_space(this->value[static_cast<std::size_t>(i)])) {
                        --i;
                    }
                    this->value = this->value.substr(0, static_cast<std::size_t>(i) + 1);
                    this->len = static_cast<int64_t>(this->value.size());
                }

                // Trim the trailing spaces within a quoted string.
                // Call this after trim_tail() is done.
                void remove_trailing_in_quote_spaces()
                {
                    int64_t i = this->len - 1;
                    if (i <= 1) {
                        return;
                    }
                    char ch = this->value[static_cast<std::size_t>(i)];
                    // Check if the last character is a quote.
                    if (ch == '\'' || ch == '\"') {
                        if (omni::char_util::is_white_space(this->value[static_cast<std::size_t>(i - 1)])) {
                            --i;
                            while (i >= 1 && omni::char_util::is_white_space(this->value[static_cast<std::size_t>(i - 1)])) {
                                --i;
                            }
                            this->value = this->value.erase(static_cast<std::size_t>(i), this->value.size() - 1 - static_cast<std::size_t>(i));
                            this->len = static_cast<int64_t>(this->value.size());
                        }
                    }
                }

                // Trim the leading spaces within a quoted string.
                // Call this after the leading spaces before quoted string are trimmed.
                void remove_leading_in_quote_spaces()
                {
                    if (this->len <= 2) {
                        return;
                    }
                    int64_t i = 0;
                    char ch = this->value[static_cast<std::size_t>(i)];
                    // Check if the last character is a quote.
                    if (ch == '\'' || ch == '\"') {
                        while ((i + 1) < this->len && omni::char_util::is_white_space(this->value[static_cast<std::size_t>(i + 1)])) {
                            ++i;
                        }
                        if (i != 0) {
                            this->value = this->value.erase(1, static_cast<std::size_t>(i));
                            this->len = static_cast<int64_t>(this->value.size());
                        }
                    }
                }

                omni::internal::date_time_format::dt_sub_string get_sub_string()
                {
                    omni::internal::date_time_format::dt_sub_string sub;
                    sub.index = static_cast<int32_t>(this->index);
                    sub.s = this->value;
                    while (this->index + sub.length < this->len) {
                        omni::internal::date_time_format::dt_substring_type::enum_t current_type;
                        char ch = this->value[static_cast<std::size_t>(this->index + sub.length)];
                        if (omni::char_util::is_digit(ch)) {
                            current_type = dt_substring_type::NUMBER;
                        } else {
                            current_type = dt_substring_type::OTHER;
                        }

                        if (sub.length == 0) {
                            sub.type = current_type;
                        } else {
                            if (sub.type != current_type) {
                                break;
                            }
                        }
                        sub.length++;
                        if (current_type == dt_substring_type::NUMBER) {
                            // Incorporate the number into the value
                            // Limit the digits to prevent overflow
                            if (sub.length > OMNI_DATE_INTERNAL_MAX_DATE_TIME_NUMBER_DIGITS_FW) {
                                sub.type = dt_substring_type::INVALID;
                                return sub;
                            }
                            int32_t number = ch - '0';
                            sub.value = sub.value * 10 + number;
                        } else {
                            // For non numbers, just return this length 1 token. This should be expanded
                            // to more types of thing if this parsing approach is used for things other
                            // than numbers and single characters
                            break;
                        }
                    }
                    if (sub.length == 0) {
                        sub.type = dt_substring_type::END;
                    }
                    return sub;
                }

                void consume_sub_string(const omni::internal::date_time_format::dt_sub_string& sub)
                {
                    this->index = sub.index + sub.length;
                    if (this->index < this->len) {
                        this->current_char = this->value[static_cast<std::size_t>(this->index)];
                    }
                }
        };

        // DEV_NOTE: Have to move this -after- class __dt_string because of the forward declaration
        bool format_info::tokenize
        (
            const omni::internal::date_time_format::token_type::enum_t& token_mask,
            omni::internal::date_time_format::token_type::enum_t& token_type,
            int64_t& token_value,
            omni::internal::date_time_format::__dt_string& str
        ) {
            token_type = omni::internal::date_time_format::token_type::UNKNOWN_TOKEN;
            token_value = 0;

            omni::internal::date_time_format::token_hash_value value;
            char ch = str.current_char;
            bool is_letter = omni::char_util::is_letter(ch);
            if (is_letter) {
                ch = omni::char_util::to_lower(ch);
            }

            std::size_t hash_code = static_cast<std::size_t>(ch % OMNI_DATE_INTERNAL_TOKEN_HASH_SIZE_FW);
            std::size_t hash_probe = static_cast<std::size_t>(1 + (ch % OMNI_DATE_INTERNAL_SECOND_PRIME_FW));
            std::size_t remaining = static_cast<std::size_t>(str.len - str.index);
            std::size_t i = 0;

            std::vector<omni::internal::date_time_format::token_hash_value> hash_table = this->m_dtfi_token_hash;
            if (hash_table.capacity() == 0) {
                hash_table = this->_create_token_hash_table();
            }
            do {
                value = hash_table[static_cast<std::size_t>(hash_code)];
                if (value.empty) {
                    // Not found.
                    break;
                }
                // Check this value has the right category (regular token or separator token) that we are looking for.
                if (((value.token_type & token_mask) > 0) && (value.token_string.size() <= remaining)) {
                    if (omni::string::util::compare(str.value, static_cast<std::size_t>(str.index), value.token_string, 0, value.token_string.size(), omni::string::compare_options::IGNORE_CASE) == 0) {
                        if (is_letter) {
                            // If this token starts with a letter, make sure that we won't allow partial match. So you can't tokenize "MarchWed" separately.
                            std::size_t next_char_idx = static_cast<std::size_t>(str.index) + value.token_string.size();
                            if (next_char_idx < static_cast<std::size_t>(str.len)) {
                                // Check word boundary. The next character should NOT be a letter.
                                if (omni::char_util::is_letter(str.value[next_char_idx])) {
                                    return false;
                                }
                            }
                        }
                        token_type = static_cast<omni::internal::date_time_format::token_type::enum_t>(value.token_type & token_mask);
                        token_value = value.token_value;
                        str.advance(static_cast<int64_t>(value.token_string.size()));
                        return true;
                    } else if (value.token_type == omni::internal::date_time_format::token_type::MONTH_TOKEN && this->has_spaces_in_month_names()) {
                        // For month token, we will match the month names which have spaces.
                        std::size_t match_str_len = 0;
                        if (str.match_specified_words(value.token_string, true, match_str_len)) {
                            token_type = static_cast<omni::internal::date_time_format::token_type::enum_t>(value.token_type & token_mask);
                            token_value = value.token_value;
                            str.advance(static_cast<int64_t>(match_str_len));
                            return true;
                        }
                    } else if (value.token_type == omni::internal::date_time_format::token_type::DAY_OF_WEEK_TOKEN && has_spaces_in_day_names()) {
                        // For month token, we will match the month names which have spaces.
                        std::size_t match_str_len = 0;
                        if (str.match_specified_words(value.token_string, true, match_str_len)) {
                            token_type = static_cast<omni::internal::date_time_format::token_type::enum_t>(value.token_type & token_mask);
                            token_value = value.token_value;
                            str.advance(static_cast<int64_t>(match_str_len));
                            return true;
                        }
                    }
                }
                ++i;
                hash_code += hash_probe;
                if (hash_code >= OMNI_DATE_INTERNAL_TOKEN_HASH_SIZE_FW) {
                    hash_code -= OMNI_DATE_INTERNAL_TOKEN_HASH_SIZE_FW;
                }
            } while (i < OMNI_DATE_INTERNAL_TOKEN_HASH_SIZE_FW);

            return false;
        }

        bool parse_fraction(omni::internal::date_time_format::__dt_string& str, double& result)
        {
            double base = 0.1;
            std::size_t digits = 0;
            char ch;
            result = 0;
            while (str.get_next() && omni::char_util::is_digit(ch = str.current_char)) {
                result += (ch - '0') * base;
                base *= 0.1;
                ++digits;
            }
            return (digits > 0);
        }

        bool parse_time_zone(omni::internal::date_time_format::__dt_string& str, omni::chrono::time_span& result)
        {
            // The hour/minute offset for timezone.
            int32_t hour_offset = 0;
            int32_t minute_offset = 0;
            omni::internal::date_time_format::dt_sub_string sub = str.get_sub_string();

            // Consume the +/- character that has already been read
            if (sub.length != 1) {
                return false;
            }

            char offset_char = sub[0];
            if ((offset_char != '+') && (offset_char != '-')) {
                return false;
            }
            str.consume_sub_string(sub);

            sub = str.get_sub_string();
            if (sub.type != dt_substring_type::NUMBER) {
                return false;
            }

            if (sub.length == 1 || sub.length == 2) {
                // Parsing "+8" or "+08"
                hour_offset = sub.value;
                str.consume_sub_string(sub);
                // See if we have minutes
                sub = str.get_sub_string();
                if (sub.length == 1 && sub[0] == ':') {
                    // Parsing "+8:00" or "+08:00"
                    str.consume_sub_string(sub);
                    sub = str.get_sub_string();
                    if (sub.type != dt_substring_type::NUMBER || sub.length < 1 || sub.length > 2) {
                        return false;
                    }
                    minute_offset = sub.value;
                    str.consume_sub_string(sub);
                }
            } else if (sub.length == 3 || sub.length == 4) {
                // Parsing "+800" or "+0800"
                hour_offset = sub.value / 100;
                minute_offset = sub.value % 100;
                str.consume_sub_string(sub);
            } else {
                // Wrong number of digits
                return false;
            }

            if (minute_offset < 0 || minute_offset >= 60) {
                return false;
            }

            result = omni::chrono::time_span(hour_offset, minute_offset, 0);
            if (offset_char == '-') {
                result = result.negate();
            }
            return true;
        }

        bool handle_time_zone(omni::internal::date_time_format::__dt_string& str, omni::internal::date_time_format::parse_result& result)
        {
            if ((str.index < str.len - 1)) {
                char next_ch = str.value[static_cast<std::size_t>(str.index)];
                // Skip whitespace, but don't update the index unless we find a time zone marker
                std::size_t ws_count = 0;
                while (omni::char_util::is_white_space(next_ch) && ((str.index + static_cast<int64_t>(ws_count)) < (str.len - 1))) {
                    ++ws_count;
                    next_ch = str.value[static_cast<std::size_t>(str.index) + ws_count];
                }
                if (next_ch == '+' || next_ch == '-') {
                    str.index += ws_count;
                    if ((result.flags & omni::internal::date_time_format::parse_flags::TIMEZONE_USED) != 0) {
                        // Should not have two timezone offsets.
                        result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                        return false;
                    }
                    result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::TIMEZONE_USED);
                    if (!omni::internal::date_time_format::parse_time_zone(str, result.time_zone_offset)) {
                        result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                        return false;
                    }
                }
            }
            return true;
        }

        omni::chrono::date_time get_date_time_now(const omni::internal::date_time_format::parse_result& result, const omni::chrono::date_time_styles& styles)
        {
            if ((result.flags & omni::internal::date_time_format::parse_flags::CAPTURE_OFFSET) != 0) {
                if ((result.flags & omni::internal::date_time_format::parse_flags::TIMEZONE_USED) != 0) {
                    // use the supplied offset to calculate 'Now'
                    return omni::chrono::date_time(
                        static_cast<uint64_t>(static_cast<int64_t>(omni::chrono::date_time::utc_now().ticks()) + result.time_zone_offset.ticks()),
                        omni::chrono::date_time_kind::UNSPECIFIED
                    );
                }
                else if ((styles & omni::chrono::date_time_styles::ASSUME_UNIVERSAL) != 0) {
                    // assume the offset is Utc
                    return omni::chrono::date_time::utc_now();
                }
            }

            // assume the offset is Local
            return omni::chrono::date_time::now();
        }

        void get_default_year(omni::internal::date_time_format::parse_result& result, omni::chrono::date_time_styles& styles)
        {
            result.year = static_cast<int16_t>(omni::internal::date_time_format::get_date_time_now(result, styles).year());
            result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::YEAR_DEFAULT);
        }

        bool get_year_month_day_order(const std::string& date_pattern, const omni::internal::date_time_format::format_info& dtfi, int64_t& order)
        {
            int64_t year_order = -1;
            int64_t month_order = -1;
            int64_t day_order    = -1;
            int64_t order_count = 0;
            bool in_quote = false;
            char ch;
            OMNI_UNUSED(dtfi);

            for (std::size_t i = 0; i < date_pattern.size() && order_count < 3; ++i) {
                ch = date_pattern[i];
                if (ch == '\\' || ch == '%') {
                    ++i;
                    continue; // Skip next character that is escaped by this backslash
                }

                if (ch == '\'' || ch == '"') {
                    in_quote = !in_quote;
                }

                if (!in_quote) {
                    if (ch == 'y') {
                        year_order = order_count++;
                        // Skip all year pattern characters.
                        for(; i+1 < date_pattern.size() && date_pattern[i+1] == 'y'; ++i) {
                            // Do nothing here.
                        }
                    } else if (ch == 'M') {
                        month_order = order_count++;
                        // Skip all month pattern characters.
                        for(; i+1 < date_pattern.size() && date_pattern[i+1] == 'M'; ++i) {
                            // Do nothing here.
                        }
                    } else if (ch == 'd') {
                        std::size_t pattern_count = 1;
                        // Skip all day pattern characters.
                        for(; i+1 < date_pattern.size() && date_pattern[i+1] == 'd'; ++i) {
                            ++pattern_count;
                        }
                        // Make sure this is not "ddd" or "dddd", which means day of week.
                        if (pattern_count <= 2) {
                            day_order = order_count++;
                        }
                    }
                }
            }

            if (year_order == 0 && month_order == 1 && day_order == 2) {
                order = OMNI_DATE_INTERNAL_ORDER_YMD_FW;
                return true;
            }
            if (month_order == 0 && day_order == 1 && year_order == 2) {
                order = OMNI_DATE_INTERNAL_ORDER_MDY_FW;
                return true;
            }
            if (day_order == 0 && month_order == 1 && year_order == 2) {
                order = OMNI_DATE_INTERNAL_ORDER_DMY_FW;
                return true;
            }
            if (year_order == 0 && day_order == 1 && month_order == 2) {
                order = OMNI_DATE_INTERNAL_ORDER_YDM_FW;
                return true;
            }
            order = -1;
            return false;
        }

        bool get_year_month_order(const std::string& pattern, const omni::internal::date_time_format::format_info& dtfi, int64_t& order)
        {
            int64_t year_order = -1;
            int64_t month_order = -1;
            int64_t order_count = 0;
            bool in_quote = false;
            char ch;
            OMNI_UNUSED(dtfi);

            for (std::size_t i = 0; i < pattern.size() && order_count < 2; ++i) {
                ch = pattern[i];
                if (ch == '\\' || ch == '%') {
                    ++i;
                    continue; // Skip next character that is escaped by this backslash
                }

                if (ch == '\'' || ch == '"') {
                    in_quote = !in_quote;
                }

                if (!in_quote) {
                    if (ch == 'y') {
                        year_order = order_count++;
                        // Skip all year pattern characters.
                        for(; i+1 < pattern.size() && pattern[i+1] == 'y'; ++i) {
                            // do nothing
                        }
                    } else if (ch == 'M') {
                        month_order = order_count++;
                        // Skip all month pattern characters.
                        for(; i+1 < pattern.size() && pattern[i+1] == 'M'; ++i) {
                            // do nothing
                        }
                    }
                }
            }

            if (year_order == 0 && month_order == 1) {
                order = OMNI_DATE_INTERNAL_ORDER_YM_FW;
                return true;
            }
            if (month_order == 0 && year_order == 1) {
                order = OMNI_DATE_INTERNAL_ORDER_MY_FW;
                return true;
            }
            order = -1;
            return false;
        }

        bool get_month_day_order(const std::string& pattern, const omni::internal::date_time_format::format_info& dtfi, int64_t& order)
        {
            int64_t month_order = -1;
            int64_t day_order    = -1;
            int64_t order_count = 0;
            bool in_quote = false;
            char ch;
            OMNI_UNUSED(dtfi);

            for (std::size_t i = 0; i < pattern.size() && order_count < 2; ++i) {
                ch = pattern[i];
                if (ch == '\\' || ch == '%') {
                    ++i;
                    continue; // Skip next character that is escaped by this backslash
                }

                if (ch == '\'' || ch == '"') {
                    in_quote = !in_quote;
                }

                if (!in_quote) {
                    if (ch == 'd') {
                        std::size_t pattern_count = 1;
                        // Skip all day pattern characters.
                        for(; i+1 < pattern.size() && pattern[i+1] == 'd'; ++i) {
                            ++pattern_count;
                        }
                        // Make sure this is not "ddd" or "dddd", which means day of week.
                        if (pattern_count <= 2) {
                            day_order = order_count++;
                        }
                    } else if (ch == 'M') {
                        month_order = order_count++;
                        // Skip all month pattern characters.
                        for(; i+1 < pattern.size() && pattern[i+1] == 'M'; ++i) {
                            // do nothing
                        }
                    }
                }
            }

            if (month_order == 0 && day_order == 1) {
                order = OMNI_DATE_INTERNAL_ORDER_MD_FW;
                return true;
            }
            if (day_order == 0 && month_order == 1) {
                order = OMNI_DATE_INTERNAL_ORDER_DM_FW;
                return true;
            }
            order = -1;
            return false;
        }

        // Adjust the two-digit year if necessary.
        bool try_adjust_year(omni::internal::date_time_format::parse_result& result, int16_t year, int16_t& adjusted_year)
        {
            OMNI_UNUSED(result);
            if (year < 100) {
                /*
                    DEV_NOTE: the following note is from the C# code .. there -was- a try..catch
                    in the code below, but it was replaced with a proper check of invalid years.
                    This C# note is just here for posterity.

                    // the Calendar classes need some real work. Many of the calendars that throw
                    // don't implement a fast/non-allocating (and non-throwing) IsValid{Year|Day|Month} method.
                    // we are making a targeted try/catch fix in the in-place release but will revisit this code
                    // in the next side-by-side release.

                */
                if ((year < 1) || (year > OMNI_DATE_MAX_YEAR)) {
                    adjusted_year = -1;
                    return false;
                }
                year = static_cast<int16_t>(omni::chrono::date_time::to_four_digit_year(static_cast<uint16_t>(year)));
            }
            adjusted_year = year;
            return true;
        }

        bool set_date_ymd(omni::internal::date_time_format::parse_result& result, uint16_t year, uint16_t month, uint16_t day)
        {
            // Note, longer term these checks should be done at the end of the parse. This current
            // way of checking creates order dependence with parsing the era name.
            if (omni::chrono::date_time::is_valid_day(year, month, day)) {
                result.set_date(static_cast<int16_t>(year), static_cast<int16_t>(month), static_cast<int16_t>(day)); // YMD
                return true;
            }
            return false;
        }

        bool set_date_mdy(omni::internal::date_time_format::parse_result& result, uint16_t month, uint16_t day, uint16_t year)
        {
            return omni::internal::date_time_format::set_date_ymd(result, year, month, day);
        }

        bool set_date_dmy(omni::internal::date_time_format::parse_result& result, uint16_t day, uint16_t month, uint16_t year)
        {
            return omni::internal::date_time_format::set_date_ymd(result, year, month, day);
        }

        bool set_date_ydm(omni::internal::date_time_format::parse_result& result, uint16_t year, uint16_t day, uint16_t month)
        {
            return omni::internal::date_time_format::set_date_ymd(result, year, month, day);
        }

        // Processing terminal case: DS.DX_NN
        bool get_day_of_nn(omni::internal::date_time_format::parse_result& result, omni::chrono::date_time_styles& styles, omni::internal::date_time_format::date_time_raw_info& raw, omni::internal::date_time_format::format_info& dtfi)
        {

            if ((result.flags & omni::internal::date_time_format::parse_flags::HAVE_DATE) != 0) {
                // Multiple dates in the input string
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                return false;
            }

            int64_t n1 = raw.get_number(0);
            int64_t n2 = raw.get_number(1);

            omni::internal::date_time_format::get_default_year(result, styles);

            int64_t order;
            if (!omni::internal::date_time_format::get_month_day_order(dtfi.month_day_pattern, dtfi, order)) {
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT_WITH_PARAMETER, "Format_BadDatePattern");
                return false;
            }

            if (order == OMNI_DATE_INTERNAL_ORDER_MD_FW) {
                if (omni::internal::date_time_format::set_date_ymd(result, static_cast<uint16_t>(result.year), static_cast<uint16_t>(n1), static_cast<uint16_t>(n2))) { // MD
                    result.flags = static_cast<omni::internal::date_time_format::parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::HAVE_DATE);
                    return true;
                }
            } else {
                if (omni::internal::date_time_format::set_date_ymd(result, static_cast<uint16_t>(result.year), static_cast<uint16_t>(n2), static_cast<uint16_t>(n1))) { // DM
                    result.flags = static_cast<omni::internal::date_time_format::parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::HAVE_DATE);
                    return true;
                }
            }
            result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
            return false;
        }

        // Processing terminal case: DS.DX_NNN
        bool get_day_of_nnn(omni::internal::date_time_format::parse_result& result, omni::internal::date_time_format::date_time_raw_info& raw, omni::internal::date_time_format::format_info& dtfi)
        {
            if ((result.flags & omni::internal::date_time_format::parse_flags::HAVE_DATE) != 0) {
                // Multiple dates in the input string
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                return false;
            }

            int64_t n1 = raw.get_number(0);
            int64_t n2 = raw.get_number(1);;
            int64_t n3 = raw.get_number(2);

            int64_t order;
            if (!omni::internal::date_time_format::get_year_month_day_order(dtfi.short_date_pattern, dtfi, order)) {
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT_WITH_PARAMETER, "Format_BadDatePattern");
                return false;
            }
            
            int16_t year;
            if (order == OMNI_DATE_INTERNAL_ORDER_YMD_FW) {
                if (omni::internal::date_time_format::try_adjust_year(result, static_cast<int16_t>(n1), year) && omni::internal::date_time_format::set_date_ymd(result, static_cast<uint16_t>(year), static_cast<uint16_t>(n2), static_cast<uint16_t>(n3))) { // YMD
                    result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::HAVE_DATE);
                    return true;
                }
            } else if (order == OMNI_DATE_INTERNAL_ORDER_MDY_FW) {
                if (omni::internal::date_time_format::try_adjust_year(result, static_cast<int16_t>(n3), year) && omni::internal::date_time_format::set_date_mdy(result, static_cast<uint16_t>(n1), static_cast<uint16_t>(n2), static_cast<uint16_t>(year))) { // MDY
                    result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::HAVE_DATE);
                    return true;
                }
            } else if (order == OMNI_DATE_INTERNAL_ORDER_DMY_FW) {
                if (omni::internal::date_time_format::try_adjust_year(result, static_cast<int16_t>(n3), year) && omni::internal::date_time_format::set_date_dmy(result, static_cast<uint16_t>(n1), static_cast<uint16_t>(n2), static_cast<uint16_t>(year))) { // DMY
                    result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::HAVE_DATE);
                    return true;
                }
            } else if (order == OMNI_DATE_INTERNAL_ORDER_YDM_FW) {
                if (omni::internal::date_time_format::try_adjust_year(result, static_cast<int16_t>(n1), year) && omni::internal::date_time_format::set_date_ydm(result, static_cast<uint16_t>(year), static_cast<uint16_t>(n2), static_cast<uint16_t>(n3))) { // YDM
                    result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::HAVE_DATE);
                    return true;
                }
            }
            result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
            return false;
        }

        bool get_day_of_mn(omni::internal::date_time_format::parse_result& result, omni::chrono::date_time_styles& styles, omni::internal::date_time_format::date_time_raw_info& raw, omni::internal::date_time_format::format_info& dtfi)
        {

            if ((result.flags & omni::internal::date_time_format::parse_flags::HAVE_DATE) != 0) {
                // Multiple dates in the input string
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                return false;
            }

            // The interpretation is based on the month_day_pattern and year_month_pattern
            //
            //    month_day_pattern year_month_pattern Interpretation
            //    --------------- ---------------- ---------------
            //    MMMM dd         MMMM yyyy         Day
            //    MMMM dd         yyyy MMMM         Day
            //    dd MMMM         MMMM yyyy         Year
            //    dd MMMM         yyyy MMMM         Day
            //
            // In the first and last cases, it could be either or neither, but a day is a better default interpretation
            // than a 2 digit year.

            int64_t month_day_order;
            if (!omni::internal::date_time_format::get_month_day_order(dtfi.month_day_pattern, dtfi, month_day_order)) {
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT_WITH_PARAMETER, "Format_BadDatePattern");
                return false;
            }
            if (month_day_order == OMNI_DATE_INTERNAL_ORDER_DM_FW) {
                int64_t year_month_order;
                if (!omni::internal::date_time_format::get_year_month_order(dtfi.year_month_pattern, dtfi, year_month_order)) {
                    result.set_failure(omni::chrono::date_time_parse_failure::FORMAT_WITH_PARAMETER, "Format_BadDatePattern");
                    return false;
                }
                if (year_month_order == OMNI_DATE_INTERNAL_ORDER_MY_FW) {
                    int16_t year;
                    if (!omni::internal::date_time_format::try_adjust_year(result, static_cast<int16_t>(raw.get_number(0)), year) || !omni::internal::date_time_format::set_date_ymd(result, static_cast<uint16_t>(year), static_cast<uint16_t>(raw.month), 1)) {
                        result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                        return false;
                    }
                    return true;
                }
            }

            omni::internal::date_time_format::get_default_year(result, styles);
            if (!omni::internal::date_time_format::set_date_ymd(result, static_cast<uint16_t>(result.year), static_cast<uint16_t>(raw.month), static_cast<uint16_t>(raw.get_number(0)))) {
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                return false;
            }
            return true;
        }

        bool get_day_of_nm(omni::internal::date_time_format::parse_result& result, omni::chrono::date_time_styles& styles, omni::internal::date_time_format::date_time_raw_info& raw, omni::internal::date_time_format::format_info& dtfi)
        {
            if ((result.flags & omni::internal::date_time_format::parse_flags::HAVE_DATE) != 0) {
                // Multiple dates in the input string
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                return false;
            }

            // The interpretation is based on the month_day_pattern and year_month_pattern
            //
            //    month_day_pattern year_month_pattern Interpretation
            //    --------------- ---------------- ---------------
            //    MMMM dd         MMMM yyyy         Day
            //    MMMM dd         yyyy MMMM         Year
            //    dd MMMM         MMMM yyyy         Day
            //    dd MMMM         yyyy MMMM         Day
            //
            // In the first and last cases, it could be either or neither, but a day is a better default interpretation
            // than a 2 digit year.

            int64_t month_day_order;
            if (!omni::internal::date_time_format::get_month_day_order(dtfi.month_day_pattern, dtfi, month_day_order)) {
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT_WITH_PARAMETER, "Format_BadDatePattern");
                return false;
            }
            if (month_day_order == OMNI_DATE_INTERNAL_ORDER_MD_FW) {
                int64_t year_month_order;
                if (!omni::internal::date_time_format::get_year_month_order(dtfi.year_month_pattern, dtfi, year_month_order)) {
                    result.set_failure(omni::chrono::date_time_parse_failure::FORMAT_WITH_PARAMETER, "Format_BadDatePattern");
                    return false;
                }
                if (year_month_order == OMNI_DATE_INTERNAL_ORDER_YM_FW) {
                    int16_t year;
                    if (!omni::internal::date_time_format::try_adjust_year(result, static_cast<int16_t>(raw.get_number(0)), year) || !omni::internal::date_time_format::set_date_ymd(result, static_cast<uint16_t>(year), static_cast<uint16_t>(raw.month), 1)) {
                        result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                        return false;
                    }
                    return true;
                }
            }

            omni::internal::date_time_format::get_default_year(result, styles);
            if (!omni::internal::date_time_format::set_date_ymd(result, static_cast<uint16_t>(result.year), static_cast<uint16_t>(raw.month), static_cast<uint16_t>(raw.get_number(0)))) {
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                return false;
            }
            return true;
        }

        bool get_day_of_mnn(omni::internal::date_time_format::parse_result& result, omni::internal::date_time_format::date_time_raw_info& raw, omni::internal::date_time_format::format_info& dtfi)
        {
            if ((result.flags & omni::internal::date_time_format::parse_flags::HAVE_DATE) != 0) {
                // Multiple dates in the input string
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                return false;
            }

            int64_t n1 = raw.get_number(0);
            int64_t n2 = raw.get_number(1);

            int64_t order;
            if (!omni::internal::date_time_format::get_year_month_day_order(dtfi.short_date_pattern, dtfi, order)) {
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT_WITH_PARAMETER, "Format_BadDatePattern");
                return false;
            }

            int16_t year;
            if (order == OMNI_DATE_INTERNAL_ORDER_MDY_FW) {
                if (omni::internal::date_time_format::try_adjust_year(result, static_cast<int16_t>(n2), year) && omni::chrono::date_time::is_valid_day(static_cast<uint16_t>(year), static_cast<uint16_t>(raw.month), static_cast<uint16_t>(n1))) {
                    result.set_date(year, static_cast<int16_t>(raw.month), static_cast<int16_t>(n1));     // MDY
                    result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::HAVE_DATE);
                    return true;
                } else if (omni::internal::date_time_format::try_adjust_year(result, static_cast<int16_t>(n1), year) && omni::chrono::date_time::is_valid_day(static_cast<uint16_t>(year), static_cast<uint16_t>(raw.month), static_cast<uint16_t>(n2))) {
                    result.set_date(year, static_cast<int16_t>(raw.month), static_cast<int16_t>(n2));     // YMD
                    result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::HAVE_DATE);
                    return true;
                }
            } else if (order == OMNI_DATE_INTERNAL_ORDER_YMD_FW) {
                if (omni::internal::date_time_format::try_adjust_year(result, static_cast<int16_t>(n1), year) && omni::chrono::date_time::is_valid_day(static_cast<uint16_t>(year), static_cast<uint16_t>(raw.month), static_cast<uint16_t>(n2))) {
                    result.set_date(year, static_cast<int16_t>(raw.month), static_cast<int16_t>(n2));     // YMD
                    result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::HAVE_DATE);
                    return true;
                } else if (omni::internal::date_time_format::try_adjust_year(result, static_cast<int16_t>(n2), year) && omni::chrono::date_time::is_valid_day(static_cast<uint16_t>(year), static_cast<uint16_t>(raw.month), static_cast<uint16_t>(n1))) {
                    result.set_date(year, static_cast<int16_t>(raw.month), static_cast<int16_t>(n1));     // DMY
                    result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::HAVE_DATE);
                    return true;
                }
            } else if (order == OMNI_DATE_INTERNAL_ORDER_DMY_FW) {
                if (omni::internal::date_time_format::try_adjust_year(result, static_cast<int16_t>(n2), year) && omni::chrono::date_time::is_valid_day(static_cast<uint16_t>(year), static_cast<uint16_t>(raw.month), static_cast<uint16_t>(n1))) {
                    result.set_date(year, static_cast<int16_t>(raw.month), static_cast<int16_t>(n1));     // DMY
                    result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::HAVE_DATE);
                    return true;
                } else if (omni::internal::date_time_format::try_adjust_year(result, static_cast<int16_t>(n1), year) && omni::chrono::date_time::is_valid_day(static_cast<uint16_t>(year), static_cast<uint16_t>(raw.month), static_cast<uint16_t>(n2))) {
                    result.set_date(year, static_cast<int16_t>(raw.month), static_cast<int16_t>(n2));     // YMD
                    result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::HAVE_DATE);
                    return true;
                }
            }

            result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
            return false;
        }

        bool get_day_of_ynn(omni::internal::date_time_format::parse_result& result, omni::internal::date_time_format::date_time_raw_info& raw, omni::internal::date_time_format::format_info& dtfi)
        {

            if ((result.flags & omni::internal::date_time_format::parse_flags::HAVE_DATE) != 0) {
                // Multiple dates in the input string
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                return false;
            }

            int64_t n1 = raw.get_number(0);
            int64_t n2 = raw.get_number(1);
            std::string pattern = dtfi.short_date_pattern;

            // For compatibility, don't throw if we can't determine the order, but default to YMD instead
            int64_t order;
            if (omni::internal::date_time_format::get_year_month_day_order(pattern, dtfi, order) && order == OMNI_DATE_INTERNAL_ORDER_YDM_FW) {
                if (omni::internal::date_time_format::set_date_ymd(result, static_cast<uint16_t>(raw.year), static_cast<uint16_t>(n2), static_cast<uint16_t>(n1))) {
                    result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::HAVE_DATE);
                    return true; // Year + DM
                }
            } else {
                if (omni::internal::date_time_format::set_date_ymd(result, static_cast<uint16_t>(raw.year), static_cast<uint16_t>(n1), static_cast<uint16_t>(n2))) {
                    result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::HAVE_DATE);
                    return true; // Year + MD
                }
            }
            result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
            return false;
        }

        bool get_day_of_nny(omni::internal::date_time_format::parse_result& result, omni::internal::date_time_format::date_time_raw_info& raw, omni::internal::date_time_format::format_info& dtfi)
        {

            if ((result.flags & omni::internal::date_time_format::parse_flags::HAVE_DATE) != 0) {
                // Multiple dates in the input string
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                return false;
            }

            int64_t n1 = raw.get_number(0);
            int64_t n2 = raw.get_number(1);

            int64_t order = 0;
            if (!omni::internal::date_time_format::get_year_month_day_order(dtfi.short_date_pattern, dtfi, order)) {
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT_WITH_PARAMETER, "Format_BadDatePattern");
                return false;
            }

            if (order == OMNI_DATE_INTERNAL_ORDER_MDY_FW || order == OMNI_DATE_INTERNAL_ORDER_YMD_FW) {
                if (omni::internal::date_time_format::set_date_ymd(result, static_cast<uint16_t>(raw.year), static_cast<uint16_t>(n1), static_cast<uint16_t>(n2))) {
                    result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::HAVE_DATE);
                    return true; // MD + Year
                }
            } else {
                if (omni::internal::date_time_format::set_date_ymd(result, static_cast<uint16_t>(raw.year), static_cast<uint16_t>(n2), static_cast<uint16_t>(n1))) {
                    result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::HAVE_DATE);
                    return true; // DM + Year
                }
            }
            result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
            return false;
        }

        bool get_day_of_ymn(omni::internal::date_time_format::parse_result& result, omni::internal::date_time_format::date_time_raw_info& raw, omni::internal::date_time_format::format_info& dtfi)
        {
            OMNI_UNUSED(dtfi);
            if ((result.flags & omni::internal::date_time_format::parse_flags::HAVE_DATE) != 0) {
                // Multiple dates in the input string
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                return false;
            }

            if (omni::internal::date_time_format::set_date_ymd(result, static_cast<uint16_t>(raw.year), static_cast<uint16_t>(raw.month), static_cast<uint16_t>(raw.get_number(0)))) {
                result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::HAVE_DATE);
                return true;
            }
            result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
            return false;
        }

        bool get_day_of_yn(omni::internal::date_time_format::parse_result& result, omni::internal::date_time_format::date_time_raw_info& raw, omni::internal::date_time_format::format_info& dtfi)
        {
            OMNI_UNUSED(dtfi);
            if ((result.flags & omni::internal::date_time_format::parse_flags::HAVE_DATE) != 0) {
                // Multiple dates in the input string
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                return false;
            }

            if (omni::internal::date_time_format::set_date_ymd(result, static_cast<uint16_t>(raw.year), static_cast<uint16_t>(raw.get_number(0)), 1)) {
                result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::HAVE_DATE);
                return true;
            }

            result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
            return false;
        }

        bool get_day_of_ym(omni::internal::date_time_format::parse_result& result, omni::internal::date_time_format::date_time_raw_info& raw, omni::internal::date_time_format::format_info& dtfi)
        {
            OMNI_UNUSED(dtfi);
            if ((result.flags & omni::internal::date_time_format::parse_flags::HAVE_DATE) != 0) {
                // Multiple dates in the input string
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                return false;
            }

            if (omni::internal::date_time_format::set_date_ymd(result, static_cast<uint16_t>(raw.year), static_cast<uint16_t>(raw.month), 1)) {
                result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::HAVE_DATE);
                return true;
            }

            result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
            return false;
        }

        bool get_time_of_n(omni::internal::date_time_format::parse_result& result, omni::internal::date_time_format::date_time_raw_info& raw)
        {
            if ((result.flags & omni::internal::date_time_format::parse_flags::HAVE_TIME) != 0) {
                // Multiple times in the input string
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                return false;
            }
            // In this case, we need a time mark. Check if so.
            if (raw.time_mark == omni::internal::date_time_format::time_mark::NOT_SET) {
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                return false;
            }
            result.hour = static_cast<int16_t>(raw.get_number(0));
            result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::HAVE_TIME);
            return true;
        }

        bool get_time_of_nn(omni::internal::date_time_format::parse_result& result, omni::internal::date_time_format::date_time_raw_info& raw)
        {
            if ((result.flags & omni::internal::date_time_format::parse_flags::HAVE_TIME) != 0) {
                // Multiple times in the input string
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                return false;
            }

            result.hour = static_cast<int16_t>(raw.get_number(0));
            result.minute = static_cast<int16_t>(raw.get_number(1));
            result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::HAVE_TIME);
            return true;
        }

        bool get_time_of_nnn(omni::internal::date_time_format::parse_result& result, omni::internal::date_time_format::date_time_raw_info& raw)
        {
            if ((result.flags & omni::internal::date_time_format::parse_flags::HAVE_TIME) != 0) {
                // Multiple times in the input string
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                return false;
            }
            result.hour = static_cast<int16_t>(raw.get_number(0));
            result.minute = static_cast<int16_t>(raw.get_number(1));
            result.second = static_cast<int16_t>(raw.get_number(2));
            result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::HAVE_TIME);
            return true;
        }

        bool get_date_of_dsn(omni::internal::date_time_format::parse_result& result, omni::internal::date_time_format::date_time_raw_info& raw)
        {
            if (raw.num_count != 1 || result.day != -1) {
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                return false;
            }
            result.day = static_cast<int16_t>(raw.get_number(0));
            return true;
        }

        bool get_date_of_nds(omni::internal::date_time_format::parse_result& result, omni::internal::date_time_format::date_time_raw_info& raw)
        {
            if (result.month == -1) {
                //Should have a month suffix
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                return false;
            }
            if (result.year != -1) {
                // Already has a year suffix
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                return false;
            }
            if (!omni::internal::date_time_format::try_adjust_year(result, static_cast<int16_t>(raw.get_number(0)), result.year)) {
                // the year value is of range
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                return false;
            }
            result.day = 1;
            return true;
        }

        bool get_date_of_nnds(omni::internal::date_time_format::parse_result& result, omni::internal::date_time_format::date_time_raw_info& raw, omni::internal::date_time_format::format_info& dtfi)
        {
            // For partial CJK Dates, the only valid formats are with a specified year, followed by two numbers, which
            // will be the Month and Day, and with a specified Month, when the numbers are either the year and day or
            // day and year, depending on the short date pattern.

            if ((result.flags & omni::internal::date_time_format::parse_flags::HAVE_YEAR) != 0) {
                if (((result.flags & omni::internal::date_time_format::parse_flags::HAVE_MONTH) == 0) && ((result.flags & omni::internal::date_time_format::parse_flags::HAVE_DAY) == 0)) {
                    if (omni::internal::date_time_format::try_adjust_year(result, static_cast<int16_t>(raw.year), result.year) && omni::internal::date_time_format::set_date_ymd(result, static_cast<uint16_t>(result.year), static_cast<uint16_t>(raw.get_number(0)), static_cast<uint16_t>(raw.get_number(1)))) {
                        return true;
                    }
                }
            } else if ((result.flags & omni::internal::date_time_format::parse_flags::HAVE_MONTH) != 0) {
                if (((result.flags & omni::internal::date_time_format::parse_flags::HAVE_YEAR) == 0) && ((result.flags & omni::internal::date_time_format::parse_flags::HAVE_DAY) == 0)) {
                    int64_t order;
                    if (!omni::internal::date_time_format::get_year_month_day_order(dtfi.short_date_pattern, dtfi, order)) {
                        result.set_failure(omni::chrono::date_time_parse_failure::FORMAT_WITH_PARAMETER, "Format_BadDatePattern");
                        return false;
                    }
                    int16_t year;
                    if (order == OMNI_DATE_INTERNAL_ORDER_YMD_FW) {
                        if (omni::internal::date_time_format::try_adjust_year(result, static_cast<int16_t>(raw.get_number(0)), year) && omni::internal::date_time_format::set_date_ymd(result, static_cast<uint16_t>(year), static_cast<uint16_t>(result.month), static_cast<uint16_t>(raw.get_number(1)))) {
                            return true;
                        }
                    } else {
                        if (omni::internal::date_time_format::try_adjust_year(result, static_cast<int16_t>(raw.get_number(1)), year) && omni::internal::date_time_format::set_date_ymd(result, static_cast<uint16_t>(year), static_cast<uint16_t>(result.month), static_cast<uint16_t>(raw.get_number(0)))){
                            return true;
                        }
                    }
                }
            }
            result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
            return false;
        }

        bool process_terminal_t_state(omni::internal::date_time_format::parse_state::enum_t dps, omni::internal::date_time_format::parse_result& result, omni::chrono::date_time_styles& styles, omni::internal::date_time_format::date_time_raw_info& raw, omni::internal::date_time_format::format_info& dtfi)
        {
            bool passed = true;
            switch (dps) {
                case omni::internal::date_time_format::parse_state::DX_NN:
                    passed = omni::internal::date_time_format::get_day_of_nn(result, styles, raw, dtfi);
                    break;
                case omni::internal::date_time_format::parse_state::DX_NNN:
                    passed = omni::internal::date_time_format::get_day_of_nnn(result, raw, dtfi);
                    break;
                case omni::internal::date_time_format::parse_state::DX_MN:
                    passed = omni::internal::date_time_format::get_day_of_mn(result, styles, raw, dtfi);
                    break;
                case omni::internal::date_time_format::parse_state::DX_NM:
                    passed = omni::internal::date_time_format::get_day_of_nm(result, styles, raw, dtfi);
                    break;
                case omni::internal::date_time_format::parse_state::DX_MNN:
                    passed = omni::internal::date_time_format::get_day_of_mnn(result, raw, dtfi);
                    break;
                case omni::internal::date_time_format::parse_state::DX_DS:
                    // The result has got the correct value. No need to process.
                    passed = true;
                    break;
                case omni::internal::date_time_format::parse_state::DX_YNN:
                    passed = omni::internal::date_time_format::get_day_of_ynn(result, raw, dtfi);
                    break;
                case omni::internal::date_time_format::parse_state::DX_NNY:
                    passed = omni::internal::date_time_format::get_day_of_nny(result, raw, dtfi);
                    break;
                case omni::internal::date_time_format::parse_state::DX_YMN:
                    passed = omni::internal::date_time_format::get_day_of_ymn(result, raw, dtfi);
                    break;
                case omni::internal::date_time_format::parse_state::DX_YN:
                    passed = omni::internal::date_time_format::get_day_of_yn(result, raw, dtfi);
                    break;
                case omni::internal::date_time_format::parse_state::DX_YM:
                    passed = omni::internal::date_time_format::get_day_of_ym(result, raw, dtfi);
                    break;
                case omni::internal::date_time_format::parse_state::TX_N:
                    passed = omni::internal::date_time_format::get_time_of_n(result, raw);
                    break;
                case omni::internal::date_time_format::parse_state::TX_NN:
                    passed = omni::internal::date_time_format::get_time_of_nn(result, raw);
                    break;
                case parse_state::TX_NNN:
                    passed = omni::internal::date_time_format::get_time_of_nnn(result, raw);
                    break;
                case omni::internal::date_time_format::parse_state::TX_TS:
                    // The result has got the correct value. Nothing to do.
                    passed = true;
                    break;
                case omni::internal::date_time_format::parse_state::DX_DSN:
                    passed = omni::internal::date_time_format::get_date_of_dsn(result, raw);
                    break;
                case omni::internal::date_time_format::parse_state::DX_NDS:
                    passed = omni::internal::date_time_format::get_date_of_nds(result, raw);
                    break;
                case omni::internal::date_time_format::parse_state::DX_NNDS:
                    passed = omni::internal::date_time_format::get_date_of_nnds(result, raw, dtfi);
                    break;

                // explicit handling (avoid warnings)
                case omni::internal::date_time_format::parse_state::BEGIN:
                case omni::internal::date_time_format::parse_state::N:
                case omni::internal::date_time_format::parse_state::NN:
                case omni::internal::date_time_format::parse_state::D_Nd:
                case omni::internal::date_time_format::parse_state::D_NN:
                case omni::internal::date_time_format::parse_state::D_NNd:
                case omni::internal::date_time_format::parse_state::D_M:
                case omni::internal::date_time_format::parse_state::D_MN:
                case omni::internal::date_time_format::parse_state::D_NM:
                case omni::internal::date_time_format::parse_state::D_MNd:
                case omni::internal::date_time_format::parse_state::D_NDS:
                case omni::internal::date_time_format::parse_state::D_Y:
                case omni::internal::date_time_format::parse_state::D_YN:
                case omni::internal::date_time_format::parse_state::D_YNd:
                case omni::internal::date_time_format::parse_state::D_YM:
                case omni::internal::date_time_format::parse_state::D_YMd:
                case omni::internal::date_time_format::parse_state::D_S:
                case omni::internal::date_time_format::parse_state::T_S:
                case omni::internal::date_time_format::parse_state::T_Nt:
                case omni::internal::date_time_format::parse_state::T_NNt:
                case omni::internal::date_time_format::parse_state::ERR:
                default: break;
            }
            
            if (!passed) {
                return false;
            }

            if (dps > omni::internal::date_time_format::parse_state::ERR) {
                // We have reached a terminal state. Reset the raw num count.
                raw.num_count = 0;
            }
            return true;
        }

        bool verify_valid_punctuation(omni::internal::date_time_format::__dt_string& str)
        {
            // Compatibility Behavior. Allow trailing NULLs and surrounding hashes
            char ch = str.value[static_cast<std::size_t>(str.index)];
            if (ch == '#') {
                bool found_start = false;
                bool found_end = false;
                for (std::size_t i = 0; i < static_cast<std::size_t>(str.len); ++i) {
                    ch = str.value[i];
                    if (ch == '#') {
                        if (found_start) {
                            if (found_end) {
                                // Having more than two hashes is invalid
                                return false;
                            } else {
                                found_end = true;
                            }
                        } else {
                            found_start = true;
                        }
                    } else if (ch == '\0') {
                        // Allow NULLs only at the end
                        if (!found_end) {
                            return false;
                        }
                    } else if ((!omni::char_util::is_white_space(ch))) {
                        // Anything other than whitespace outside hashes is invalid
                        if (!found_start || found_end) {
                            return false;
                        }
                    }
                }
                if (!found_end) {
                    // The has was un-paired
                    return false;
                }
                // Valid Hash usage: eat the hash and continue.
                str.get_next();
                return true;
            } else if (ch == '\0') {
                for (std::size_t i = static_cast<std::size_t>(str.index); i < static_cast<std::size_t>(str.len); ++i) {
                    if (str.value[i] != '\0') {
                        // NULLs are only valid if they are the only trailing character
                        return false;
                    }
                }
                // Move to the end of the string
                str.index = str.len;
                return true;
            }
            return false;
        }

        #if defined(OMNI_DATE_TIME_PARSE_USE_STATE_ARRAY)
            omni::internal::date_time_format::parse_state::enum_t date_parsing_state_tokens[][18] = {
                // BEGIN
                {
                    omni::internal::date_time_format::parse_state::BEGIN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::TX_N,
                    omni::internal::date_time_format::parse_state::N,
                    omni::internal::date_time_format::parse_state::D_Nd,
                    omni::internal::date_time_format::parse_state::T_Nt,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_M,
                    omni::internal::date_time_format::parse_state::D_M,
                    omni::internal::date_time_format::parse_state::D_S,
                    omni::internal::date_time_format::parse_state::T_S,
                    omni::internal::date_time_format::parse_state::BEGIN,
                    omni::internal::date_time_format::parse_state::D_Y,
                    omni::internal::date_time_format::parse_state::D_Y,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::BEGIN,
                    omni::internal::date_time_format::parse_state::BEGIN,
                    omni::internal::date_time_format::parse_state::ERR
                },
                // N
                {
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::DX_NN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::NN,
                    omni::internal::date_time_format::parse_state::D_NNd,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::DX_NM,
                    omni::internal::date_time_format::parse_state::D_NM,
                    omni::internal::date_time_format::parse_state::D_MNd,
                    omni::internal::date_time_format::parse_state::D_NDS,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::N,
                    omni::internal::date_time_format::parse_state::D_YN,
                    omni::internal::date_time_format::parse_state::D_YNd,
                    omni::internal::date_time_format::parse_state::DX_YN,
                    omni::internal::date_time_format::parse_state::N,
                    omni::internal::date_time_format::parse_state::N,
                    omni::internal::date_time_format::parse_state::ERR
                },
                // NN
                {
                    omni::internal::date_time_format::parse_state::DX_NN,
                    omni::internal::date_time_format::parse_state::DX_NNN,
                    omni::internal::date_time_format::parse_state::TX_N,
                    omni::internal::date_time_format::parse_state::DX_NNN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::T_Nt,
                    omni::internal::date_time_format::parse_state::DX_MNN,
                    omni::internal::date_time_format::parse_state::DX_MNN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::T_S,
                    omni::internal::date_time_format::parse_state::NN,
                    omni::internal::date_time_format::parse_state::DX_NNY,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::DX_NNY,
                    omni::internal::date_time_format::parse_state::NN,
                    omni::internal::date_time_format::parse_state::NN,
                    omni::internal::date_time_format::parse_state::ERR
                },
                // D_Nd
                {
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::DX_NN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_NN,
                    omni::internal::date_time_format::parse_state::D_NNd,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::DX_NM,
                    omni::internal::date_time_format::parse_state::D_MN,
                    omni::internal::date_time_format::parse_state::D_MNd,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_Nd,
                    omni::internal::date_time_format::parse_state::D_YN,
                    omni::internal::date_time_format::parse_state::D_YNd,
                    omni::internal::date_time_format::parse_state::DX_YN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_Nd,
                    omni::internal::date_time_format::parse_state::ERR
                },
                // D_NN
                {
                    omni::internal::date_time_format::parse_state::DX_NN,
                    omni::internal::date_time_format::parse_state::DX_NNN,
                    omni::internal::date_time_format::parse_state::TX_N,
                    omni::internal::date_time_format::parse_state::DX_NNN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::T_Nt,
                    omni::internal::date_time_format::parse_state::DX_MNN,
                    omni::internal::date_time_format::parse_state::DX_MNN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::DX_DS,
                    omni::internal::date_time_format::parse_state::T_S,
                    omni::internal::date_time_format::parse_state::D_NN,
                    omni::internal::date_time_format::parse_state::DX_NNY,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::DX_NNY,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_NN,
                    omni::internal::date_time_format::parse_state::ERR
                } ,
                // D_NNd
                {
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::DX_NNN,
                    omni::internal::date_time_format::parse_state::DX_NNN,
                    omni::internal::date_time_format::parse_state::DX_NNN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::DX_MNN,
                    omni::internal::date_time_format::parse_state::DX_MNN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::DX_DS,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_NNd,
                    omni::internal::date_time_format::parse_state::DX_NNY,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::DX_NNY,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_NNd,
                    omni::internal::date_time_format::parse_state::ERR
                },
                // D_M
                {
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::DX_MN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_MN,
                    omni::internal::date_time_format::parse_state::D_MNd,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_M,
                    omni::internal::date_time_format::parse_state::D_YM,
                    omni::internal::date_time_format::parse_state::D_YMd,
                    omni::internal::date_time_format::parse_state::DX_YM,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_M,
                    omni::internal::date_time_format::parse_state::ERR
                },
                // D_MN
                {
                    omni::internal::date_time_format::parse_state::DX_MN,
                    omni::internal::date_time_format::parse_state::DX_MNN,
                    omni::internal::date_time_format::parse_state::DX_MNN,
                    omni::internal::date_time_format::parse_state::DX_MNN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::T_Nt,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::DX_DS,
                    omni::internal::date_time_format::parse_state::T_S,
                    omni::internal::date_time_format::parse_state::D_MN,
                    omni::internal::date_time_format::parse_state::DX_YMN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::DX_YMN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_MN,
                    omni::internal::date_time_format::parse_state::ERR
                },
                // D_NM
                {
                    omni::internal::date_time_format::parse_state::DX_NM,
                    omni::internal::date_time_format::parse_state::DX_MNN,
                    omni::internal::date_time_format::parse_state::DX_MNN,
                    omni::internal::date_time_format::parse_state::DX_MNN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::T_Nt,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::DX_DS,
                    omni::internal::date_time_format::parse_state::T_S,
                    omni::internal::date_time_format::parse_state::D_NM,
                    omni::internal::date_time_format::parse_state::DX_YMN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::DX_YMN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_NM,
                    omni::internal::date_time_format::parse_state::ERR
                },
                // D_MNd
                {
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::DX_MNN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::DX_MNN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_MNd,
                    omni::internal::date_time_format::parse_state::DX_YMN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::DX_YMN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_MNd,
                    omni::internal::date_time_format::parse_state::ERR
                },
                // D_NDS
                {
                    omni::internal::date_time_format::parse_state::DX_NDS,
                    omni::internal::date_time_format::parse_state::DX_NNDS,
                    omni::internal::date_time_format::parse_state::DX_NNDS,
                    omni::internal::date_time_format::parse_state::DX_NNDS,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::T_Nt,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_NDS,
                    omni::internal::date_time_format::parse_state::T_S,
                    omni::internal::date_time_format::parse_state::D_NDS,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_NDS,
                    omni::internal::date_time_format::parse_state::ERR
                },
                // D_Y
                {
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::DX_YN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_YN,
                    omni::internal::date_time_format::parse_state::D_YNd,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::DX_YM,
                    omni::internal::date_time_format::parse_state::D_YM,
                    omni::internal::date_time_format::parse_state::D_YMd,
                    omni::internal::date_time_format::parse_state::D_YM,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_Y,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_Y,
                    omni::internal::date_time_format::parse_state::ERR
                },
                // D_YN
                {
                    omni::internal::date_time_format::parse_state::DX_YN,
                    omni::internal::date_time_format::parse_state::DX_YNN,
                    omni::internal::date_time_format::parse_state::DX_YNN,
                    omni::internal::date_time_format::parse_state::DX_YNN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::DX_YMN,
                    omni::internal::date_time_format::parse_state::DX_YMN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_YN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_YN,
                    omni::internal::date_time_format::parse_state::ERR
                },
                // D_YNd
                {
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::DX_YNN,
                    omni::internal::date_time_format::parse_state::DX_YNN,
                    omni::internal::date_time_format::parse_state::DX_YNN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::DX_YMN,
                    omni::internal::date_time_format::parse_state::DX_YMN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_YN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_YN,
                    omni::internal::date_time_format::parse_state::ERR
                },
                // D_YM
                {
                    omni::internal::date_time_format::parse_state::DX_YM,
                    omni::internal::date_time_format::parse_state::DX_YMN,
                    omni::internal::date_time_format::parse_state::DX_YMN,
                    omni::internal::date_time_format::parse_state::DX_YMN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_YM,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_YM,
                    omni::internal::date_time_format::parse_state::ERR
                },
                // D_YMd
                {
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::DX_YMN,
                    omni::internal::date_time_format::parse_state::DX_YMN,
                    omni::internal::date_time_format::parse_state::DX_YMN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_YM,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_YM,
                    omni::internal::date_time_format::parse_state::ERR
                },
                // D_S
                {
                    omni::internal::date_time_format::parse_state::DX_DS,
                    omni::internal::date_time_format::parse_state::DX_DSN,
                    omni::internal::date_time_format::parse_state::TX_N,
                    omni::internal::date_time_format::parse_state::T_Nt,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::T_Nt,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_S,
                    omni::internal::date_time_format::parse_state::T_S,
                    omni::internal::date_time_format::parse_state::D_S,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_S,
                    omni::internal::date_time_format::parse_state::ERR
                },
                // T_S
                {
                    omni::internal::date_time_format::parse_state::TX_TS,
                    omni::internal::date_time_format::parse_state::TX_TS,
                    omni::internal::date_time_format::parse_state::TX_TS,
                    omni::internal::date_time_format::parse_state::T_Nt,
                    omni::internal::date_time_format::parse_state::D_Nd,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::D_S,
                    omni::internal::date_time_format::parse_state::T_S,
                    omni::internal::date_time_format::parse_state::T_S,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::T_S,
                    omni::internal::date_time_format::parse_state::T_S,
                    omni::internal::date_time_format::parse_state::ERR
                },
                // T_Nt
                {
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::TX_NN,
                    omni::internal::date_time_format::parse_state::TX_NN,
                    omni::internal::date_time_format::parse_state::TX_NN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::T_NNt,
                    omni::internal::date_time_format::parse_state::DX_NM,
                    omni::internal::date_time_format::parse_state::D_NM,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::T_S,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::T_Nt,
                    omni::internal::date_time_format::parse_state::T_Nt,
                    omni::internal::date_time_format::parse_state::TX_NN
                },
                // T_NNt
                {
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::TX_NNN,
                    omni::internal::date_time_format::parse_state::TX_NNN,
                    omni::internal::date_time_format::parse_state::TX_NNN,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::T_S,
                    omni::internal::date_time_format::parse_state::T_NNt,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::ERR,
                    omni::internal::date_time_format::parse_state::T_NNt,
                    omni::internal::date_time_format::parse_state::T_NNt,
                    omni::internal::date_time_format::parse_state::TX_NNN
                },
            };
        #endif

        omni::internal::date_time_format::parse_state::enum_t date_parsing_state(const omni::internal::date_time_format::parse_state::enum_t& state, const omni::internal::date_time_format::token::enum_t& token)
        {
            /*
                DEV_NOTE: using the switch versus the array uses less static memory and also has built in error handling by having a default
                case if the values passed in are larger than one of the 2D array elements. Considering that this is entire code chunk is for
                a very large string parser for dates, one would likely be alright with the exceedingly small CPU cache hit the switch statement
                uses over the static memory.
                
                -- BUT --
                
                That's what the OMNI_DATE_TIME_PARSE_USE_STATE_ARRAY define is for .. let the user decide!
            */
             #if defined(OMNI_DATE_TIME_PARSE_USE_STATE_ARRAY)
                return omni::internal::date_time_format::date_parsing_state_tokens[static_cast<std::size_t>(state)][static_cast<std::size_t>(token)];
            #else
                switch (state) {
                    case omni::internal::date_time_format::parse_state::BEGIN: {
                        switch (token) {
                            case omni::internal::date_time_format::token::END: return omni::internal::date_time_format::parse_state::BEGIN;
                            case omni::internal::date_time_format::token::NUM_END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_AM_PM: return omni::internal::date_time_format::parse_state::TX_N;
                            case omni::internal::date_time_format::token::NUM_SPACE: return omni::internal::date_time_format::parse_state::N;
                            case omni::internal::date_time_format::token::NUM_DATE_SEP: return omni::internal::date_time_format::parse_state::D_Nd;
                            case omni::internal::date_time_format::token::NUM_TIME_SEP: return omni::internal::date_time_format::parse_state::T_Nt;
                            case omni::internal::date_time_format::token::MONTH_END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_SPACE: return omni::internal::date_time_format::parse_state::D_M;
                            case omni::internal::date_time_format::token::MONTH_DATE_SEP: return omni::internal::date_time_format::parse_state::D_M;
                            case omni::internal::date_time_format::token::NUM_DATE_SUFFIX: return omni::internal::date_time_format::parse_state::D_S;
                            case omni::internal::date_time_format::token::NUM_TIME_SUFFIX: return omni::internal::date_time_format::parse_state::T_S;
                            case omni::internal::date_time_format::token::DAY_OF_WEEK: return omni::internal::date_time_format::parse_state::BEGIN;
                            case omni::internal::date_time_format::token::YEAR_SPACE: return omni::internal::date_time_format::parse_state::D_Y;
                            case omni::internal::date_time_format::token::YEAR_DATE_SEP: return omni::internal::date_time_format::parse_state::D_Y;
                            case omni::internal::date_time_format::token::YEAR_END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::TIME_ZONE: return omni::internal::date_time_format::parse_state::BEGIN;
                            case omni::internal::date_time_format::token::ERA: return omni::internal::date_time_format::parse_state::BEGIN;
                            case omni::internal::date_time_format::token::NUM_UTC_TIME_MARK:
                            case omni::internal::date_time_format::token::UNKNOWN:
                            case omni::internal::date_time_format::token::NUM_LOCAL_TIME_MARK:
                            case omni::internal::date_time_format::token::MAX:
                            default: return omni::internal::date_time_format::parse_state::ERR;
                        }
                    } break;
                    case omni::internal::date_time_format::parse_state::N: {
                        switch (token) {
                            case omni::internal::date_time_format::token::END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_END: return omni::internal::date_time_format::parse_state::DX_NN;
                            case omni::internal::date_time_format::token::NUM_AM_PM: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_SPACE: return omni::internal::date_time_format::parse_state::NN;
                            case omni::internal::date_time_format::token::NUM_DATE_SEP: return omni::internal::date_time_format::parse_state::D_NNd;
                            case omni::internal::date_time_format::token::NUM_TIME_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_END: return omni::internal::date_time_format::parse_state::DX_NM;
                            case omni::internal::date_time_format::token::MONTH_SPACE: return omni::internal::date_time_format::parse_state::D_NM;
                            case omni::internal::date_time_format::token::MONTH_DATE_SEP: return omni::internal::date_time_format::parse_state::D_MNd;
                            case omni::internal::date_time_format::token::NUM_DATE_SUFFIX: return omni::internal::date_time_format::parse_state::D_NDS;
                            case omni::internal::date_time_format::token::NUM_TIME_SUFFIX: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::DAY_OF_WEEK: return omni::internal::date_time_format::parse_state::N;
                            case omni::internal::date_time_format::token::YEAR_SPACE: return omni::internal::date_time_format::parse_state::D_YN;
                            case omni::internal::date_time_format::token::YEAR_DATE_SEP: return omni::internal::date_time_format::parse_state::D_YNd;
                            case omni::internal::date_time_format::token::YEAR_END: return omni::internal::date_time_format::parse_state::DX_YN;
                            case omni::internal::date_time_format::token::TIME_ZONE: return omni::internal::date_time_format::parse_state::N;
                            case omni::internal::date_time_format::token::ERA: return omni::internal::date_time_format::parse_state::N;
                            case omni::internal::date_time_format::token::NUM_UTC_TIME_MARK:
                            case omni::internal::date_time_format::token::UNKNOWN:
                            case omni::internal::date_time_format::token::NUM_LOCAL_TIME_MARK:
                            case omni::internal::date_time_format::token::MAX:
                            default: return omni::internal::date_time_format::parse_state::ERR;
                        }
                    } break;
                    case omni::internal::date_time_format::parse_state::NN: {
                        switch (token) {
                            case omni::internal::date_time_format::token::END: return omni::internal::date_time_format::parse_state::DX_NN;
                            case omni::internal::date_time_format::token::NUM_END: return omni::internal::date_time_format::parse_state::DX_NNN;
                            case omni::internal::date_time_format::token::NUM_AM_PM: return omni::internal::date_time_format::parse_state::TX_N;
                            case omni::internal::date_time_format::token::NUM_SPACE: return omni::internal::date_time_format::parse_state::DX_NNN;
                            case omni::internal::date_time_format::token::NUM_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_TIME_SEP: return omni::internal::date_time_format::parse_state::T_Nt;
                            case omni::internal::date_time_format::token::MONTH_END: return omni::internal::date_time_format::parse_state::DX_MNN;
                            case omni::internal::date_time_format::token::MONTH_SPACE: return omni::internal::date_time_format::parse_state::DX_MNN;
                            case omni::internal::date_time_format::token::MONTH_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_DATE_SUFFIX: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_TIME_SUFFIX: return omni::internal::date_time_format::parse_state::T_S;
                            case omni::internal::date_time_format::token::DAY_OF_WEEK: return omni::internal::date_time_format::parse_state::NN;
                            case omni::internal::date_time_format::token::YEAR_SPACE: return omni::internal::date_time_format::parse_state::DX_NNY;
                            case omni::internal::date_time_format::token::YEAR_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::YEAR_END: return omni::internal::date_time_format::parse_state::DX_NNY;
                            case omni::internal::date_time_format::token::TIME_ZONE: return omni::internal::date_time_format::parse_state::NN;
                            case omni::internal::date_time_format::token::ERA: return omni::internal::date_time_format::parse_state::NN;
                            case omni::internal::date_time_format::token::NUM_UTC_TIME_MARK:
                            case omni::internal::date_time_format::token::UNKNOWN:
                            case omni::internal::date_time_format::token::NUM_LOCAL_TIME_MARK:
                            case omni::internal::date_time_format::token::MAX:
                            default: return omni::internal::date_time_format::parse_state::ERR;
                        }
                    } break;
                    case omni::internal::date_time_format::parse_state::D_Nd: {
                        switch (token) {
                            case omni::internal::date_time_format::token::END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_END: return omni::internal::date_time_format::parse_state::DX_NN;
                            case omni::internal::date_time_format::token::NUM_AM_PM: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_SPACE: return omni::internal::date_time_format::parse_state::D_NN;
                            case omni::internal::date_time_format::token::NUM_DATE_SEP: return omni::internal::date_time_format::parse_state::D_NNd;
                            case omni::internal::date_time_format::token::NUM_TIME_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_END: return omni::internal::date_time_format::parse_state::DX_NM;
                            case omni::internal::date_time_format::token::MONTH_SPACE: return omni::internal::date_time_format::parse_state::D_MN;
                            case omni::internal::date_time_format::token::MONTH_DATE_SEP: return omni::internal::date_time_format::parse_state::D_MNd;
                            case omni::internal::date_time_format::token::NUM_DATE_SUFFIX: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_TIME_SUFFIX: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::DAY_OF_WEEK: return omni::internal::date_time_format::parse_state::D_Nd;
                            case omni::internal::date_time_format::token::YEAR_SPACE: return omni::internal::date_time_format::parse_state::D_YN;
                            case omni::internal::date_time_format::token::YEAR_DATE_SEP: return omni::internal::date_time_format::parse_state::D_YNd;
                            case omni::internal::date_time_format::token::YEAR_END: return omni::internal::date_time_format::parse_state::DX_YN;
                            case omni::internal::date_time_format::token::TIME_ZONE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::ERA: return omni::internal::date_time_format::parse_state::D_Nd;
                            case omni::internal::date_time_format::token::NUM_UTC_TIME_MARK:
                            case omni::internal::date_time_format::token::UNKNOWN:
                            case omni::internal::date_time_format::token::NUM_LOCAL_TIME_MARK:
                            case omni::internal::date_time_format::token::MAX:
                            default: return omni::internal::date_time_format::parse_state::ERR;
                        }
                    } break;
                    case omni::internal::date_time_format::parse_state::D_NN: {
                        switch (token) {
                            case omni::internal::date_time_format::token::END: return omni::internal::date_time_format::parse_state::DX_NN;
                            case omni::internal::date_time_format::token::NUM_END: return omni::internal::date_time_format::parse_state::DX_NNN;
                            case omni::internal::date_time_format::token::NUM_AM_PM: return omni::internal::date_time_format::parse_state::TX_N;
                            case omni::internal::date_time_format::token::NUM_SPACE: return omni::internal::date_time_format::parse_state::DX_NNN;
                            case omni::internal::date_time_format::token::NUM_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_TIME_SEP: return omni::internal::date_time_format::parse_state::T_Nt;
                            case omni::internal::date_time_format::token::MONTH_END: return omni::internal::date_time_format::parse_state::DX_MNN;
                            case omni::internal::date_time_format::token::MONTH_SPACE: return omni::internal::date_time_format::parse_state::DX_MNN;
                            case omni::internal::date_time_format::token::MONTH_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_DATE_SUFFIX: return omni::internal::date_time_format::parse_state::DX_DS;
                            case omni::internal::date_time_format::token::NUM_TIME_SUFFIX: return omni::internal::date_time_format::parse_state::T_S;
                            case omni::internal::date_time_format::token::DAY_OF_WEEK: return omni::internal::date_time_format::parse_state::D_NN;
                            case omni::internal::date_time_format::token::YEAR_SPACE: return omni::internal::date_time_format::parse_state::DX_NNY;
                            case omni::internal::date_time_format::token::YEAR_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::YEAR_END: return omni::internal::date_time_format::parse_state::DX_NNY;
                            case omni::internal::date_time_format::token::TIME_ZONE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::ERA: return omni::internal::date_time_format::parse_state::D_NN;
                            case omni::internal::date_time_format::token::NUM_UTC_TIME_MARK:
                            case omni::internal::date_time_format::token::UNKNOWN:
                            case omni::internal::date_time_format::token::NUM_LOCAL_TIME_MARK:
                            case omni::internal::date_time_format::token::MAX:
                            default: return omni::internal::date_time_format::parse_state::ERR;
                        }
                    } break;
                    case omni::internal::date_time_format::parse_state::D_NNd: {
                        switch (token) {
                            case omni::internal::date_time_format::token::END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_END: return omni::internal::date_time_format::parse_state::DX_NNN;
                            case omni::internal::date_time_format::token::NUM_AM_PM: return omni::internal::date_time_format::parse_state::DX_NNN;
                            case omni::internal::date_time_format::token::NUM_SPACE: return omni::internal::date_time_format::parse_state::DX_NNN;
                            case omni::internal::date_time_format::token::NUM_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_TIME_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_END: return omni::internal::date_time_format::parse_state::DX_MNN;
                            case omni::internal::date_time_format::token::MONTH_SPACE: return omni::internal::date_time_format::parse_state::DX_MNN;
                            case omni::internal::date_time_format::token::MONTH_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_DATE_SUFFIX: return omni::internal::date_time_format::parse_state::DX_DS;
                            case omni::internal::date_time_format::token::NUM_TIME_SUFFIX: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::DAY_OF_WEEK: return omni::internal::date_time_format::parse_state::D_NNd;
                            case omni::internal::date_time_format::token::YEAR_SPACE: return omni::internal::date_time_format::parse_state::DX_NNY;
                            case omni::internal::date_time_format::token::YEAR_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::YEAR_END: return omni::internal::date_time_format::parse_state::DX_NNY;
                            case omni::internal::date_time_format::token::TIME_ZONE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::ERA: return omni::internal::date_time_format::parse_state::D_NNd;
                            case omni::internal::date_time_format::token::NUM_UTC_TIME_MARK:
                            case omni::internal::date_time_format::token::UNKNOWN:
                            case omni::internal::date_time_format::token::NUM_LOCAL_TIME_MARK:
                            case omni::internal::date_time_format::token::MAX:
                            default: return omni::internal::date_time_format::parse_state::ERR;
                        }
                    } break;
                    case omni::internal::date_time_format::parse_state::D_M: {
                        switch (token) {
                            case omni::internal::date_time_format::token::END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_END: return omni::internal::date_time_format::parse_state::DX_MN;
                            case omni::internal::date_time_format::token::NUM_AM_PM: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_SPACE: return omni::internal::date_time_format::parse_state::D_MN;
                            case omni::internal::date_time_format::token::NUM_DATE_SEP: return omni::internal::date_time_format::parse_state::D_MNd;
                            case omni::internal::date_time_format::token::NUM_TIME_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_SPACE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_DATE_SUFFIX: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_TIME_SUFFIX: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::DAY_OF_WEEK: return omni::internal::date_time_format::parse_state::D_M;
                            case omni::internal::date_time_format::token::YEAR_SPACE: return omni::internal::date_time_format::parse_state::D_YM;
                            case omni::internal::date_time_format::token::YEAR_DATE_SEP: return omni::internal::date_time_format::parse_state::D_YMd;
                            case omni::internal::date_time_format::token::YEAR_END: return omni::internal::date_time_format::parse_state::DX_YM;
                            case omni::internal::date_time_format::token::TIME_ZONE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::ERA: return omni::internal::date_time_format::parse_state::D_M;
                            case omni::internal::date_time_format::token::NUM_UTC_TIME_MARK:
                            case omni::internal::date_time_format::token::UNKNOWN:
                            case omni::internal::date_time_format::token::NUM_LOCAL_TIME_MARK:
                            case omni::internal::date_time_format::token::MAX:
                            default: return omni::internal::date_time_format::parse_state::ERR;
                        }
                    } break;
                    case omni::internal::date_time_format::parse_state::D_MN: {
                        switch (token) {
                            case omni::internal::date_time_format::token::END: return omni::internal::date_time_format::parse_state::DX_MN;
                            case omni::internal::date_time_format::token::NUM_END: return omni::internal::date_time_format::parse_state::DX_MNN;
                            case omni::internal::date_time_format::token::NUM_AM_PM: return omni::internal::date_time_format::parse_state::DX_MNN;
                            case omni::internal::date_time_format::token::NUM_SPACE: return omni::internal::date_time_format::parse_state::DX_MNN;
                            case omni::internal::date_time_format::token::NUM_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_TIME_SEP: return omni::internal::date_time_format::parse_state::T_Nt;
                            case omni::internal::date_time_format::token::MONTH_END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_SPACE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_DATE_SUFFIX: return omni::internal::date_time_format::parse_state::DX_DS;
                            case omni::internal::date_time_format::token::NUM_TIME_SUFFIX: return omni::internal::date_time_format::parse_state::T_S;
                            case omni::internal::date_time_format::token::DAY_OF_WEEK: return omni::internal::date_time_format::parse_state::D_MN;
                            case omni::internal::date_time_format::token::YEAR_SPACE: return omni::internal::date_time_format::parse_state::DX_YMN;
                            case omni::internal::date_time_format::token::YEAR_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::YEAR_END: return omni::internal::date_time_format::parse_state::DX_YMN;
                            case omni::internal::date_time_format::token::TIME_ZONE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::ERA: return omni::internal::date_time_format::parse_state::D_MN;
                            case omni::internal::date_time_format::token::NUM_UTC_TIME_MARK:
                            case omni::internal::date_time_format::token::UNKNOWN:
                            case omni::internal::date_time_format::token::NUM_LOCAL_TIME_MARK:
                            case omni::internal::date_time_format::token::MAX:
                            default: return omni::internal::date_time_format::parse_state::ERR;
                        }
                    } break;
                    case omni::internal::date_time_format::parse_state::D_NM: {
                        switch (token) {
                            case omni::internal::date_time_format::token::END: return omni::internal::date_time_format::parse_state::DX_NM;
                            case omni::internal::date_time_format::token::NUM_END: return omni::internal::date_time_format::parse_state::DX_MNN;
                            case omni::internal::date_time_format::token::NUM_AM_PM: return omni::internal::date_time_format::parse_state::DX_MNN;
                            case omni::internal::date_time_format::token::NUM_SPACE: return omni::internal::date_time_format::parse_state::DX_MNN;
                            case omni::internal::date_time_format::token::NUM_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_TIME_SEP: return omni::internal::date_time_format::parse_state::T_Nt;
                            case omni::internal::date_time_format::token::MONTH_END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_SPACE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_DATE_SUFFIX: return omni::internal::date_time_format::parse_state::DX_DS;
                            case omni::internal::date_time_format::token::NUM_TIME_SUFFIX: return omni::internal::date_time_format::parse_state::T_S;
                            case omni::internal::date_time_format::token::DAY_OF_WEEK: return omni::internal::date_time_format::parse_state::D_NM;
                            case omni::internal::date_time_format::token::YEAR_SPACE: return omni::internal::date_time_format::parse_state::DX_YMN;
                            case omni::internal::date_time_format::token::YEAR_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::YEAR_END: return omni::internal::date_time_format::parse_state::DX_YMN;
                            case omni::internal::date_time_format::token::TIME_ZONE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::ERA: return omni::internal::date_time_format::parse_state::D_NM;
                            case omni::internal::date_time_format::token::NUM_UTC_TIME_MARK:
                            case omni::internal::date_time_format::token::UNKNOWN:
                            case omni::internal::date_time_format::token::NUM_LOCAL_TIME_MARK:
                            case omni::internal::date_time_format::token::MAX:
                            default: return omni::internal::date_time_format::parse_state::ERR;
                        }
                    } break;
                    case omni::internal::date_time_format::parse_state::D_MNd: {
                        switch (token) {
                            case omni::internal::date_time_format::token::END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_END: return omni::internal::date_time_format::parse_state::DX_MNN;
                            case omni::internal::date_time_format::token::NUM_AM_PM: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_SPACE: return omni::internal::date_time_format::parse_state::DX_MNN;
                            case omni::internal::date_time_format::token::NUM_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_TIME_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_SPACE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_DATE_SUFFIX: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_TIME_SUFFIX: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::DAY_OF_WEEK: return omni::internal::date_time_format::parse_state::D_MNd;
                            case omni::internal::date_time_format::token::YEAR_SPACE: return omni::internal::date_time_format::parse_state::DX_YMN;
                            case omni::internal::date_time_format::token::YEAR_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::YEAR_END: return omni::internal::date_time_format::parse_state::DX_YMN;
                            case omni::internal::date_time_format::token::TIME_ZONE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::ERA: return omni::internal::date_time_format::parse_state::D_MNd;
                            case omni::internal::date_time_format::token::NUM_UTC_TIME_MARK:
                            case omni::internal::date_time_format::token::UNKNOWN:
                            case omni::internal::date_time_format::token::NUM_LOCAL_TIME_MARK:
                            case omni::internal::date_time_format::token::MAX:
                            default: return omni::internal::date_time_format::parse_state::ERR;
                        }
                    } break;
                    case omni::internal::date_time_format::parse_state::D_NDS: {
                        switch (token) {
                            case omni::internal::date_time_format::token::END: return omni::internal::date_time_format::parse_state::DX_NDS;
                            case omni::internal::date_time_format::token::NUM_END: return omni::internal::date_time_format::parse_state::DX_NNDS;
                            case omni::internal::date_time_format::token::NUM_AM_PM: return omni::internal::date_time_format::parse_state::DX_NNDS;
                            case omni::internal::date_time_format::token::NUM_SPACE: return omni::internal::date_time_format::parse_state::DX_NNDS;
                            case omni::internal::date_time_format::token::NUM_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_TIME_SEP: return omni::internal::date_time_format::parse_state::T_Nt;
                            case omni::internal::date_time_format::token::MONTH_END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_SPACE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_DATE_SUFFIX: return omni::internal::date_time_format::parse_state::D_NDS;
                            case omni::internal::date_time_format::token::NUM_TIME_SUFFIX: return omni::internal::date_time_format::parse_state::T_S;
                            case omni::internal::date_time_format::token::DAY_OF_WEEK: return omni::internal::date_time_format::parse_state::D_NDS;
                            case omni::internal::date_time_format::token::YEAR_SPACE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::YEAR_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::YEAR_END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::TIME_ZONE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::ERA: return omni::internal::date_time_format::parse_state::D_NDS;
                            case omni::internal::date_time_format::token::NUM_UTC_TIME_MARK:
                            case omni::internal::date_time_format::token::UNKNOWN:
                            case omni::internal::date_time_format::token::NUM_LOCAL_TIME_MARK:
                            case omni::internal::date_time_format::token::MAX:
                            default: return omni::internal::date_time_format::parse_state::ERR;
                        }
                    } break;
                    case omni::internal::date_time_format::parse_state::D_Y: {
                        switch (token) {
                            case omni::internal::date_time_format::token::END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_END: return omni::internal::date_time_format::parse_state::DX_YN;
                            case omni::internal::date_time_format::token::NUM_AM_PM: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_SPACE: return omni::internal::date_time_format::parse_state::D_YN;
                            case omni::internal::date_time_format::token::NUM_DATE_SEP: return omni::internal::date_time_format::parse_state::D_YNd;
                            case omni::internal::date_time_format::token::NUM_TIME_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_END: return omni::internal::date_time_format::parse_state::DX_YM;
                            case omni::internal::date_time_format::token::MONTH_SPACE: return omni::internal::date_time_format::parse_state::D_YM;
                            case omni::internal::date_time_format::token::MONTH_DATE_SEP: return omni::internal::date_time_format::parse_state::D_YMd;
                            case omni::internal::date_time_format::token::NUM_DATE_SUFFIX: return omni::internal::date_time_format::parse_state::D_YM;
                            case omni::internal::date_time_format::token::NUM_TIME_SUFFIX: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::DAY_OF_WEEK: return omni::internal::date_time_format::parse_state::D_Y;
                            case omni::internal::date_time_format::token::YEAR_SPACE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::YEAR_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::YEAR_END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::TIME_ZONE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::ERA: return omni::internal::date_time_format::parse_state::D_Y;
                            case omni::internal::date_time_format::token::NUM_UTC_TIME_MARK:
                            case omni::internal::date_time_format::token::UNKNOWN:
                            case omni::internal::date_time_format::token::NUM_LOCAL_TIME_MARK:
                            case omni::internal::date_time_format::token::MAX:
                            default: return omni::internal::date_time_format::parse_state::ERR;
                        }
                    } break;
                    case omni::internal::date_time_format::parse_state::D_YN: {
                        switch (token) {
                            case omni::internal::date_time_format::token::END: return omni::internal::date_time_format::parse_state::DX_YN;
                            case omni::internal::date_time_format::token::NUM_END: return omni::internal::date_time_format::parse_state::DX_YNN;
                            case omni::internal::date_time_format::token::NUM_AM_PM: return omni::internal::date_time_format::parse_state::DX_YNN;
                            case omni::internal::date_time_format::token::NUM_SPACE: return omni::internal::date_time_format::parse_state::DX_YNN;
                            case omni::internal::date_time_format::token::NUM_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_TIME_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_END: return omni::internal::date_time_format::parse_state::DX_YMN;
                            case omni::internal::date_time_format::token::MONTH_SPACE: return omni::internal::date_time_format::parse_state::DX_YMN;
                            case omni::internal::date_time_format::token::MONTH_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_DATE_SUFFIX: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_TIME_SUFFIX: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::DAY_OF_WEEK: return omni::internal::date_time_format::parse_state::D_YN;
                            case omni::internal::date_time_format::token::YEAR_SPACE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::YEAR_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::YEAR_END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::TIME_ZONE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::ERA: return omni::internal::date_time_format::parse_state::D_YN;
                            case omni::internal::date_time_format::token::NUM_UTC_TIME_MARK:
                            case omni::internal::date_time_format::token::UNKNOWN:
                            case omni::internal::date_time_format::token::NUM_LOCAL_TIME_MARK:
                            case omni::internal::date_time_format::token::MAX:
                            default: return omni::internal::date_time_format::parse_state::ERR;
                        }
                    } break;
                    case omni::internal::date_time_format::parse_state::D_YNd: {
                        switch (token) {
                            case omni::internal::date_time_format::token::END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_END: return omni::internal::date_time_format::parse_state::DX_YNN;
                            case omni::internal::date_time_format::token::NUM_AM_PM: return omni::internal::date_time_format::parse_state::DX_YNN;
                            case omni::internal::date_time_format::token::NUM_SPACE: return omni::internal::date_time_format::parse_state::DX_YNN;
                            case omni::internal::date_time_format::token::NUM_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_TIME_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_END: return omni::internal::date_time_format::parse_state::DX_YMN;
                            case omni::internal::date_time_format::token::MONTH_SPACE: return omni::internal::date_time_format::parse_state::DX_YMN;
                            case omni::internal::date_time_format::token::MONTH_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_DATE_SUFFIX: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_TIME_SUFFIX: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::DAY_OF_WEEK: return omni::internal::date_time_format::parse_state::D_YN;
                            case omni::internal::date_time_format::token::YEAR_SPACE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::YEAR_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::YEAR_END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::TIME_ZONE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::ERA: return omni::internal::date_time_format::parse_state::D_YN;
                            case omni::internal::date_time_format::token::NUM_UTC_TIME_MARK:
                            case omni::internal::date_time_format::token::UNKNOWN:
                            case omni::internal::date_time_format::token::NUM_LOCAL_TIME_MARK:
                            case omni::internal::date_time_format::token::MAX:
                            default: return omni::internal::date_time_format::parse_state::ERR;
                        }
                    } break;
                    case omni::internal::date_time_format::parse_state::D_YM: {
                        switch (token) {
                            case omni::internal::date_time_format::token::END: return omni::internal::date_time_format::parse_state::DX_YM;
                            case omni::internal::date_time_format::token::NUM_END: return omni::internal::date_time_format::parse_state::DX_YMN;
                            case omni::internal::date_time_format::token::NUM_AM_PM: return omni::internal::date_time_format::parse_state::DX_YMN;
                            case omni::internal::date_time_format::token::NUM_SPACE: return omni::internal::date_time_format::parse_state::DX_YMN;
                            case omni::internal::date_time_format::token::NUM_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_TIME_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_SPACE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_DATE_SUFFIX: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_TIME_SUFFIX: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::DAY_OF_WEEK: return omni::internal::date_time_format::parse_state::D_YM;
                            case omni::internal::date_time_format::token::YEAR_SPACE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::YEAR_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::YEAR_END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::TIME_ZONE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::ERA: return omni::internal::date_time_format::parse_state::D_YM;
                            case omni::internal::date_time_format::token::NUM_UTC_TIME_MARK:
                            case omni::internal::date_time_format::token::UNKNOWN:
                            case omni::internal::date_time_format::token::NUM_LOCAL_TIME_MARK:
                            case omni::internal::date_time_format::token::MAX:
                            default: return omni::internal::date_time_format::parse_state::ERR;
                        }
                    } break;
                    case omni::internal::date_time_format::parse_state::D_YMd: {
                        switch (token) {
                            case omni::internal::date_time_format::token::END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_END: return omni::internal::date_time_format::parse_state::DX_YMN;
                            case omni::internal::date_time_format::token::NUM_AM_PM: return omni::internal::date_time_format::parse_state::DX_YMN;
                            case omni::internal::date_time_format::token::NUM_SPACE: return omni::internal::date_time_format::parse_state::DX_YMN;
                            case omni::internal::date_time_format::token::NUM_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_TIME_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_SPACE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_DATE_SUFFIX: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_TIME_SUFFIX: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::DAY_OF_WEEK: return omni::internal::date_time_format::parse_state::D_YM;
                            case omni::internal::date_time_format::token::YEAR_SPACE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::YEAR_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::YEAR_END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::TIME_ZONE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::ERA: return omni::internal::date_time_format::parse_state::D_YM;
                            case omni::internal::date_time_format::token::NUM_UTC_TIME_MARK:
                            case omni::internal::date_time_format::token::UNKNOWN:
                            case omni::internal::date_time_format::token::NUM_LOCAL_TIME_MARK:
                            case omni::internal::date_time_format::token::MAX:
                            default: return omni::internal::date_time_format::parse_state::ERR;
                        }
                    } break;
                    case omni::internal::date_time_format::parse_state::D_S: {
                        switch (token) {
                            case omni::internal::date_time_format::token::END: return omni::internal::date_time_format::parse_state::DX_DS;
                            case omni::internal::date_time_format::token::NUM_END: return omni::internal::date_time_format::parse_state::DX_DSN;
                            case omni::internal::date_time_format::token::NUM_AM_PM: return omni::internal::date_time_format::parse_state::TX_N;
                            case omni::internal::date_time_format::token::NUM_SPACE: return omni::internal::date_time_format::parse_state::T_Nt;
                            case omni::internal::date_time_format::token::NUM_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_TIME_SEP: return omni::internal::date_time_format::parse_state::T_Nt;
                            case omni::internal::date_time_format::token::MONTH_END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_SPACE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_DATE_SUFFIX: return omni::internal::date_time_format::parse_state::D_S;
                            case omni::internal::date_time_format::token::NUM_TIME_SUFFIX: return omni::internal::date_time_format::parse_state::T_S;
                            case omni::internal::date_time_format::token::DAY_OF_WEEK: return omni::internal::date_time_format::parse_state::D_S;
                            case omni::internal::date_time_format::token::YEAR_SPACE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::YEAR_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::YEAR_END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::TIME_ZONE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::ERA: return omni::internal::date_time_format::parse_state::D_S;
                            case omni::internal::date_time_format::token::NUM_UTC_TIME_MARK:
                            case omni::internal::date_time_format::token::UNKNOWN:
                            case omni::internal::date_time_format::token::NUM_LOCAL_TIME_MARK:
                            case omni::internal::date_time_format::token::MAX:
                            default: return omni::internal::date_time_format::parse_state::ERR;
                        }
                    } break;
                    case omni::internal::date_time_format::parse_state::T_S: {
                        switch (token) {
                            case omni::internal::date_time_format::token::END: return omni::internal::date_time_format::parse_state::TX_TS;
                            case omni::internal::date_time_format::token::NUM_END: return omni::internal::date_time_format::parse_state::TX_TS;
                            case omni::internal::date_time_format::token::NUM_AM_PM: return omni::internal::date_time_format::parse_state::TX_TS;
                            case omni::internal::date_time_format::token::NUM_SPACE: return omni::internal::date_time_format::parse_state::T_Nt;
                            case omni::internal::date_time_format::token::NUM_DATE_SEP: return omni::internal::date_time_format::parse_state::D_Nd;
                            case omni::internal::date_time_format::token::NUM_TIME_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_SPACE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_DATE_SUFFIX: return omni::internal::date_time_format::parse_state::D_S;
                            case omni::internal::date_time_format::token::NUM_TIME_SUFFIX: return omni::internal::date_time_format::parse_state::T_S;
                            case omni::internal::date_time_format::token::DAY_OF_WEEK: return omni::internal::date_time_format::parse_state::T_S;
                            case omni::internal::date_time_format::token::YEAR_SPACE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::YEAR_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::YEAR_END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::TIME_ZONE: return omni::internal::date_time_format::parse_state::T_S;
                            case omni::internal::date_time_format::token::ERA: return omni::internal::date_time_format::parse_state::T_S;
                            case omni::internal::date_time_format::token::NUM_UTC_TIME_MARK:
                            case omni::internal::date_time_format::token::UNKNOWN:
                            case omni::internal::date_time_format::token::NUM_LOCAL_TIME_MARK:
                            case omni::internal::date_time_format::token::MAX:
                            default: return omni::internal::date_time_format::parse_state::ERR;
                        }
                    } break;
                    case omni::internal::date_time_format::parse_state::T_Nt: {
                        switch (token) {
                            case omni::internal::date_time_format::token::END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_END: return omni::internal::date_time_format::parse_state::TX_NN;
                            case omni::internal::date_time_format::token::NUM_AM_PM: return omni::internal::date_time_format::parse_state::TX_NN;
                            case omni::internal::date_time_format::token::NUM_SPACE: return omni::internal::date_time_format::parse_state::TX_NN;
                            case omni::internal::date_time_format::token::NUM_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_TIME_SEP: return omni::internal::date_time_format::parse_state::T_NNt;
                            case omni::internal::date_time_format::token::MONTH_END: return omni::internal::date_time_format::parse_state::DX_NM;
                            case omni::internal::date_time_format::token::MONTH_SPACE: return omni::internal::date_time_format::parse_state::D_NM;
                            case omni::internal::date_time_format::token::MONTH_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_DATE_SUFFIX: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_TIME_SUFFIX: return omni::internal::date_time_format::parse_state::T_S;
                            case omni::internal::date_time_format::token::DAY_OF_WEEK: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::YEAR_SPACE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::YEAR_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::YEAR_END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::TIME_ZONE: return omni::internal::date_time_format::parse_state::T_Nt;
                            case omni::internal::date_time_format::token::ERA: return omni::internal::date_time_format::parse_state::T_Nt;
                            case omni::internal::date_time_format::token::NUM_UTC_TIME_MARK: return omni::internal::date_time_format::parse_state::TX_NN;
                            case omni::internal::date_time_format::token::UNKNOWN:
                            case omni::internal::date_time_format::token::NUM_LOCAL_TIME_MARK:
                            case omni::internal::date_time_format::token::MAX:
                            default: return omni::internal::date_time_format::parse_state::ERR;
                        }
                    } break;
                    case omni::internal::date_time_format::parse_state::T_NNt: {
                        switch (token) {
                            case omni::internal::date_time_format::token::END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_END: return omni::internal::date_time_format::parse_state::TX_NNN;
                            case omni::internal::date_time_format::token::NUM_AM_PM: return omni::internal::date_time_format::parse_state::TX_NNN;
                            case omni::internal::date_time_format::token::NUM_SPACE: return omni::internal::date_time_format::parse_state::TX_NNN;
                            case omni::internal::date_time_format::token::NUM_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_TIME_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_SPACE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::MONTH_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_DATE_SUFFIX: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::NUM_TIME_SUFFIX: return omni::internal::date_time_format::parse_state::T_S;
                            case omni::internal::date_time_format::token::DAY_OF_WEEK: return omni::internal::date_time_format::parse_state::T_NNt;
                            case omni::internal::date_time_format::token::YEAR_SPACE: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::YEAR_DATE_SEP: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::YEAR_END: return omni::internal::date_time_format::parse_state::ERR;
                            case omni::internal::date_time_format::token::TIME_ZONE: return omni::internal::date_time_format::parse_state::T_NNt;
                            case omni::internal::date_time_format::token::ERA: return omni::internal::date_time_format::parse_state::T_NNt;
                            case omni::internal::date_time_format::token::NUM_UTC_TIME_MARK: return omni::internal::date_time_format::parse_state::TX_NNN;
                            case omni::internal::date_time_format::token::UNKNOWN:
                            case omni::internal::date_time_format::token::NUM_LOCAL_TIME_MARK:
                            case omni::internal::date_time_format::token::MAX:
                            default: return omni::internal::date_time_format::parse_state::ERR;
                        }
                    } break;

                    case omni::internal::date_time_format::parse_state::ERR:
                    case omni::internal::date_time_format::parse_state::DX_NN:
                    case omni::internal::date_time_format::parse_state::DX_NNN:
                    case omni::internal::date_time_format::parse_state::DX_MN:
                    case omni::internal::date_time_format::parse_state::DX_NM:
                    case omni::internal::date_time_format::parse_state::DX_MNN:
                    case omni::internal::date_time_format::parse_state::DX_DS:
                    case omni::internal::date_time_format::parse_state::DX_DSN:
                    case omni::internal::date_time_format::parse_state::DX_NDS:
                    case omni::internal::date_time_format::parse_state::DX_NNDS:
                    case omni::internal::date_time_format::parse_state::DX_YNN:
                    case omni::internal::date_time_format::parse_state::DX_YMN:
                    case omni::internal::date_time_format::parse_state::DX_YN:
                    case omni::internal::date_time_format::parse_state::DX_YM:
                    case omni::internal::date_time_format::parse_state::TX_N:
                    case omni::internal::date_time_format::parse_state::TX_NN:
                    case omni::internal::date_time_format::parse_state::TX_NNN:
                    case omni::internal::date_time_format::parse_state::TX_TS:
                    case omni::internal::date_time_format::parse_state::DX_NNY:
                    default: break;
                }
                return omni::internal::date_time_format::parse_state::ERR;
            #endif
        }

        // This is the lexer. Check the character at the current index, and put the found token in dtok and
        // some raw date/time information in raw.
        bool lex
        (
            omni::internal::date_time_format::parse_state::enum_t dps,
            omni::internal::date_time_format::__dt_string& str,
            omni::internal::date_time_format::date_time_token& dtok,
            omni::internal::date_time_format::date_time_raw_info& raw,
            omni::internal::date_time_format::parse_result& result,
            omni::internal::date_time_format::format_info& dtfi,
            omni::chrono::date_time_styles& styles
        ) {
            // https://learn.microsoft.com/en-us/dotnet/framework/configure-apps/file-schema/runtime/enableampmparseadjustment-element
            // enabled by default -- e.g. 4/10 6am == April 10, YYYY @ 6am
            bool enable_am_pm_parse_adjustment = true;
            omni::internal::date_time_format::token_type::enum_t token_type = omni::internal::date_time_format::token_type::SEP_UNK;
            int64_t token_value = 0;
            int64_t index_before_sep = 0;
            char char_before_sep = '\0';

            omni::internal::date_time_format::token_type::enum_t sep = omni::internal::date_time_format::token_type::SEP_UNK;
            dtok.dtt = omni::internal::date_time_format::token::UNKNOWN; // Assume the token is unkown.

            str.get_regular_token(token_type, token_value, dtfi, false);

            // Look at the regular token.
            switch (token_type) {
                case omni::internal::date_time_format::token_type::NUMBER_TOKEN:
                case omni::internal::date_time_format::token_type::YEAR_NUMBER_TOKEN: {
                    if (raw.num_count == 3 || token_value == -1) {
                        result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                        return false;
                    }
                    /*
                        This is a digit.

                        If the previous parsing state is omni::internal::date_time_format::parse_state::T_NNt (like 12:01), and we got another number,
                        so we will have a terminal state omni::internal::date_time_format::parse_state::TX_NNN (like 12:01:02).
                        If the previous parsing state is omni::internal::date_time_format::parse_state::T_Nt (like 12:), and we got another number,
                        so we will have a terminal state omni::internal::date_time_format::parse_state::TX_NN (like 12:01).

                        Look ahead to see if the following character is a decimal point or timezone offset.
                        This enables us to parse time in the forms of: "11:22:33.1234" or "11:22:33-08".
                    */
                     if (dps == omni::internal::date_time_format::parse_state::T_NNt) {
                        if ((str.index < str.len - 1)) {
                            char next_ch = str.value[static_cast<std::size_t>(str.index)];
                            if (next_ch == '.') {
                                // While parse_fraction can fail, it just means that there were no digits after
                                // the dot. In this case parse_fraction just removes the dot. This is actually
                                // valid for cultures like Albanian, that join the time marker to the time with
                                // with a dot: e.g. "9:03.MD"
                                omni::internal::date_time_format::parse_fraction(str, raw.fraction);
                            }
                        }
                    }
                    if (dps == omni::internal::date_time_format::parse_state::T_NNt || dps == omni::internal::date_time_format::parse_state::T_Nt) {
                        if ((str.index < str.len - 1)) {
                            if (!omni::internal::date_time_format::handle_time_zone(str, result)) {
                                return false;
                            }
                        }
                    }

                    dtok.num = token_value;
                    if (token_type == omni::internal::date_time_format::token_type::YEAR_NUMBER_TOKEN) {
                        if (raw.year == -1) {
                            raw.year = token_value;
                            // If we have number which has 3 or more digits (like "001" or "0001"), we assume this number is a year. Save the current raw.num_count in raw.year
                            switch (sep = str.get_separator_token(dtfi, index_before_sep, char_before_sep)) {
                                case omni::internal::date_time_format::token_type::SEP_END: {
                                    dtok.dtt = omni::internal::date_time_format::token::YEAR_END;
                                } break;
                                case omni::internal::date_time_format::token_type::SEP_AM:
                                case omni::internal::date_time_format::token_type::SEP_PM: {
                                    if (raw.time_mark == omni::internal::date_time_format::time_mark::NOT_SET) {
                                        raw.time_mark = (sep == omni::internal::date_time_format::token_type::SEP_AM ? time_mark::AM : time_mark::PM);
                                        dtok.dtt = omni::internal::date_time_format::token::YEAR_SPACE;
                                    } else {
                                        result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                                    }
                                } break;
                                case omni::internal::date_time_format::token_type::SEP_SPACE:
                                    dtok.dtt = omni::internal::date_time_format::token::YEAR_SPACE;
                                    break;
                                case omni::internal::date_time_format::token_type::SEP_Date:
                                    dtok.dtt = omni::internal::date_time_format::token::YEAR_DATE_SEP;
                                    break;
                                case omni::internal::date_time_format::token_type::SEP_TIME: {
                                    if (!raw.has_same_date_and_time_separators) {
                                        result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                                        return false;
                                    }
                                    // we have the date and time separators are same and getting a year number, then change the token to YEAR_DATE_SEP as
                                    // we are sure we are not parsing time.
                                    dtok.dtt = omni::internal::date_time_format::token::YEAR_DATE_SEP;
                                } break;
                                case omni::internal::date_time_format::token_type::SEP_DATE_OR_OFFSET: {
                                    // The separator is either a date separator or the start of a time zone offset. If the token will complete the date then
                                    // process just the number and roll back the index so that the outer loop can attempt to parse the time zone offset.
                                    if ((omni::internal::date_time_format::date_parsing_state(dps, omni::internal::date_time_format::token::YEAR_DATE_SEP) == omni::internal::date_time_format::parse_state::ERR) &&
                                        (omni::internal::date_time_format::date_parsing_state(dps, omni::internal::date_time_format::token::YEAR_SPACE) > omni::internal::date_time_format::parse_state::ERR))
                                    {
                                        str.index = index_before_sep;
                                        str.current_char = char_before_sep;
                                        dtok.dtt = omni::internal::date_time_format::token::YEAR_SPACE;
                                    } else {
                                        dtok.dtt = omni::internal::date_time_format::token::YEAR_DATE_SEP;
                                    }
                                } break;
                                case omni::internal::date_time_format::token_type::SEP_YEAR_SUFFIX:
                                case omni::internal::date_time_format::token_type::SEP_MONTH_SUFFIX:
                                case omni::internal::date_time_format::token_type::SEP_DAY_SUFFIX:
                                    dtok.dtt    = omni::internal::date_time_format::token::NUM_DATE_SUFFIX;
                                    dtok.suffix = sep;
                                    break;
                                case omni::internal::date_time_format::token_type::SEP_HOUR_SUFFIX:
                                case omni::internal::date_time_format::token_type::SEP_MINUTE_SUFFIX:
                                case omni::internal::date_time_format::token_type::SEP_SECOND_SUFFIX:
                                    dtok.dtt    = omni::internal::date_time_format::token::NUM_TIME_SUFFIX;
                                    dtok.suffix = sep;
                                    break;
                                case omni::internal::date_time_format::token_type::NUMBER_TOKEN:
                                case omni::internal::date_time_format::token_type::YEAR_NUMBER_TOKEN:
                                case omni::internal::date_time_format::token_type::AM:
                                case omni::internal::date_time_format::token_type::PM:
                                case omni::internal::date_time_format::token_type::MONTH_TOKEN:
                                case omni::internal::date_time_format::token_type::END_OF_STRING:
                                case omni::internal::date_time_format::token_type::DAY_OF_WEEK_TOKEN:
                                case omni::internal::date_time_format::token_type::TIME_ZONE_TOKEN:
                                case omni::internal::date_time_format::token_type::ERA_TOKEN:
                                case omni::internal::date_time_format::token_type::DATE_WORD_TOKEN:
                                case omni::internal::date_time_format::token_type::UNKNOWN_TOKEN:
                                case omni::internal::date_time_format::token_type::HEBREW_NUMBER:
                                case omni::internal::date_time_format::token_type::JAPANESE_ERA_TOKEN:
                                case omni::internal::date_time_format::token_type::TAIWAN_ERA_TOKEN:
                                case omni::internal::date_time_format::token_type::IGNORABLE_SYMBOL:
                                case omni::internal::date_time_format::token_type::SEP_UNK:
                                case omni::internal::date_time_format::token_type::REGULAR_TOKEN_MASK:
                                case omni::internal::date_time_format::token_type::SEPARATOR_TOKEN_MASK:
                                case omni::internal::date_time_format::token_type::SEP_LOCAL_TIME_MARK:
                                default:
                                    // Invalid separator after number number.
                                    result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                                    return false;
                            }
                            // Found the token already. Return now.
                            return true;
                        }
                        result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                        return false;
                    }

                    switch (sep = str.get_separator_token(dtfi, index_before_sep, char_before_sep)) {
                        /*
                            Note here we check if the num_count is less than three.
                            When we have more than three numbers, it will be caught as error in the state machine.
                        */
                         case omni::internal::date_time_format::token_type::SEP_END:
                            dtok.dtt = omni::internal::date_time_format::token::NUM_END;
                            raw.add_number(dtok.num);
                            break;
                        case omni::internal::date_time_format::token_type::SEP_AM:
                        case omni::internal::date_time_format::token_type::SEP_PM: {
                            if (raw.time_mark == omni::internal::date_time_format::time_mark::NOT_SET) {
                                raw.time_mark = (sep == omni::internal::date_time_format::token_type::SEP_AM ? time_mark::AM : time_mark::PM);
                                dtok.dtt = omni::internal::date_time_format::token::NUM_AM_PM;
                                // Fix AM/PM parsing case, e.g. "1/10 5 AM"
                                if (dps == omni::internal::date_time_format::parse_state::D_NN && enable_am_pm_parse_adjustment) {
                                    if (!omni::internal::date_time_format::process_terminal_t_state(omni::internal::date_time_format::parse_state::DX_NN, result, styles, raw, dtfi)) {
                                        return false;
                                    }
                                }
                                raw.add_number(dtok.num);
                            } else {
                                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                                break;
                            }
                            if (dps == omni::internal::date_time_format::parse_state::T_NNt || dps == omni::internal::date_time_format::parse_state::T_Nt) {
                                if (!omni::internal::date_time_format::handle_time_zone(str, result)) {
                                    return false;
                                }
                            }
                        } break;
                        case omni::internal::date_time_format::token_type::SEP_SPACE:
                            dtok.dtt = omni::internal::date_time_format::token::NUM_SPACE;
                            raw.add_number(dtok.num);
                            break;
                        case omni::internal::date_time_format::token_type::SEP_Date:
                            dtok.dtt = omni::internal::date_time_format::token::NUM_DATE_SEP;
                            raw.add_number(dtok.num);
                            break;
                        case omni::internal::date_time_format::token_type::SEP_DATE_OR_OFFSET:
                            // The separator is either a date separator or the start of a time zone offset. If the token will complete the date then
                            // process just the number and roll back the index so that the outer loop can attempt to parse the time zone offset.
                            if ((omni::internal::date_time_format::date_parsing_state(dps, omni::internal::date_time_format::token::NUM_DATE_SEP) == omni::internal::date_time_format::parse_state::ERR)
                                && (omni::internal::date_time_format::date_parsing_state(dps, omni::internal::date_time_format::token::NUM_SPACE) > omni::internal::date_time_format::parse_state::ERR)) {
                                str.index = index_before_sep;
                                str.current_char = char_before_sep;
                                dtok.dtt = omni::internal::date_time_format::token::NUM_SPACE;
                            } else {
                                dtok.dtt = omni::internal::date_time_format::token::NUM_DATE_SEP;
                            }
                            raw.add_number(dtok.num);
                            break;
                        case omni::internal::date_time_format::token_type::SEP_TIME:
                            if (raw.has_same_date_and_time_separators &&
                                (dps == omni::internal::date_time_format::parse_state::D_Y || dps == omni::internal::date_time_format::parse_state::D_YN || dps == omni::internal::date_time_format::parse_state::D_YNd || dps == omni::internal::date_time_format::parse_state::D_YM || dps == omni::internal::date_time_format::parse_state::D_YMd))
                            {
                                // we are parsing a date and we have the time separator same as date separator, so we mark the token as date separator
                                dtok.dtt = omni::internal::date_time_format::token::NUM_DATE_SEP;
                                raw.add_number(dtok.num);
                                break;
                            }
                            dtok.dtt = omni::internal::date_time_format::token::NUM_TIME_SEP;
                            raw.add_number(dtok.num);
                            break;
                        case omni::internal::date_time_format::token_type::SEP_YEAR_SUFFIX: {
                            if ((token_value < 1) || (token_value > OMNI_DATE_MAX_YEAR)) {
                                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                                return false;
                            }
                            dtok.num = omni::chrono::date_time::to_four_digit_year(static_cast<uint16_t>(token_value));
                            dtok.dtt = omni::internal::date_time_format::token::NUM_DATE_SUFFIX;
                            dtok.suffix = sep;
                        } break;
                        case omni::internal::date_time_format::token_type::SEP_MONTH_SUFFIX:
                        case omni::internal::date_time_format::token_type::SEP_DAY_SUFFIX:
                            dtok.dtt = omni::internal::date_time_format::token::NUM_DATE_SUFFIX;
                            dtok.suffix = sep;
                            break;
                        case omni::internal::date_time_format::token_type::SEP_HOUR_SUFFIX:
                        case omni::internal::date_time_format::token_type::SEP_MINUTE_SUFFIX:
                        case omni::internal::date_time_format::token_type::SEP_SECOND_SUFFIX:
                            dtok.dtt = omni::internal::date_time_format::token::NUM_TIME_SUFFIX;
                            dtok.suffix = sep;
                            break;
                        case omni::internal::date_time_format::token_type::SEP_LOCAL_TIME_MARK:
                            dtok.dtt = omni::internal::date_time_format::token::NUM_LOCAL_TIME_MARK;
                            raw.add_number(dtok.num);
                            break;
                        case omni::internal::date_time_format::token_type::NUMBER_TOKEN:
                        case omni::internal::date_time_format::token_type::YEAR_NUMBER_TOKEN:
                        case omni::internal::date_time_format::token_type::AM:
                        case omni::internal::date_time_format::token_type::PM:
                        case omni::internal::date_time_format::token_type::MONTH_TOKEN:
                        case omni::internal::date_time_format::token_type::END_OF_STRING:
                        case omni::internal::date_time_format::token_type::DAY_OF_WEEK_TOKEN:
                        case omni::internal::date_time_format::token_type::TIME_ZONE_TOKEN:
                        case omni::internal::date_time_format::token_type::ERA_TOKEN:
                        case omni::internal::date_time_format::token_type::DATE_WORD_TOKEN:
                        case omni::internal::date_time_format::token_type::UNKNOWN_TOKEN:
                        case omni::internal::date_time_format::token_type::HEBREW_NUMBER:
                        case omni::internal::date_time_format::token_type::JAPANESE_ERA_TOKEN:
                        case omni::internal::date_time_format::token_type::TAIWAN_ERA_TOKEN:
                        case omni::internal::date_time_format::token_type::IGNORABLE_SYMBOL:
                        case omni::internal::date_time_format::token_type::SEP_UNK:
                        case omni::internal::date_time_format::token_type::REGULAR_TOKEN_MASK:
                        case omni::internal::date_time_format::token_type::SEPARATOR_TOKEN_MASK:
                        default:
                            // Invalid separator after number number.
                            result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                            return false;
                    }
                } break;
                case omni::internal::date_time_format::token_type::HEBREW_NUMBER: {
                    if (token_value >= 100) {
                        // This is a year number
                        if (raw.year == -1) {
                            raw.year = token_value;
                            //
                            // If we have number which has 3 or more digits (like "001" or "0001"),
                            // we assume this number is a year. Save the current raw.num_count in
                            // raw.year.
                            //
                            switch (sep = str.get_separator_token(dtfi, index_before_sep, char_before_sep)) {
                                case omni::internal::date_time_format::token_type::SEP_END:
                                    dtok.dtt = omni::internal::date_time_format::token::YEAR_END;
                                    break;
                                case omni::internal::date_time_format::token_type::SEP_SPACE:
                                    dtok.dtt = omni::internal::date_time_format::token::YEAR_SPACE;
                                    break;
                                case omni::internal::date_time_format::token_type::SEP_DATE_OR_OFFSET: {
                                    // The separator is either a date separator or the start of a time zone offset. If the token will complete the date then
                                    // process just the number and roll back the index so that the outer loop can attempt to parse the time zone offset.
                                    if (omni::internal::date_time_format::date_parsing_state(dps, omni::internal::date_time_format::token::YEAR_SPACE) > omni::internal::date_time_format::parse_state::ERR) {
                                        str.index = index_before_sep;
                                        str.current_char = char_before_sep;
                                        dtok.dtt = omni::internal::date_time_format::token::YEAR_SPACE;
                                        break;
                                    }
                                    return false;
                                } break;
                                case omni::internal::date_time_format::token_type::SEP_AM:
                                case omni::internal::date_time_format::token_type::SEP_PM:
                                case omni::internal::date_time_format::token_type::SEP_Date:
                                case omni::internal::date_time_format::token_type::SEP_TIME:
                                case omni::internal::date_time_format::token_type::SEP_YEAR_SUFFIX:
                                case omni::internal::date_time_format::token_type::SEP_MONTH_SUFFIX:
                                case omni::internal::date_time_format::token_type::SEP_DAY_SUFFIX:
                                case omni::internal::date_time_format::token_type::SEP_HOUR_SUFFIX:
                                case omni::internal::date_time_format::token_type::SEP_MINUTE_SUFFIX:
                                case omni::internal::date_time_format::token_type::SEP_SECOND_SUFFIX:
                                case omni::internal::date_time_format::token_type::SEP_LOCAL_TIME_MARK:
                                case omni::internal::date_time_format::token_type::NUMBER_TOKEN:
                                case omni::internal::date_time_format::token_type::YEAR_NUMBER_TOKEN:
                                case omni::internal::date_time_format::token_type::AM:
                                case omni::internal::date_time_format::token_type::PM:
                                case omni::internal::date_time_format::token_type::MONTH_TOKEN:
                                case omni::internal::date_time_format::token_type::END_OF_STRING:
                                case omni::internal::date_time_format::token_type::DAY_OF_WEEK_TOKEN:
                                case omni::internal::date_time_format::token_type::TIME_ZONE_TOKEN:
                                case omni::internal::date_time_format::token_type::ERA_TOKEN:
                                case omni::internal::date_time_format::token_type::DATE_WORD_TOKEN:
                                case omni::internal::date_time_format::token_type::UNKNOWN_TOKEN:
                                case omni::internal::date_time_format::token_type::HEBREW_NUMBER:
                                case omni::internal::date_time_format::token_type::JAPANESE_ERA_TOKEN:
                                case omni::internal::date_time_format::token_type::TAIWAN_ERA_TOKEN:
                                case omni::internal::date_time_format::token_type::IGNORABLE_SYMBOL:
                                case omni::internal::date_time_format::token_type::SEP_UNK:
                                case omni::internal::date_time_format::token_type::REGULAR_TOKEN_MASK:
                                case omni::internal::date_time_format::token_type::SEPARATOR_TOKEN_MASK:
                                default:
                                    // Invalid separator after number number.
                                    result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                                    return false;
                            }
                        } else {
                            // Invalid separator after number number.
                            result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                            return false;
                        }
                    } else {
                        // This is a day number
                        dtok.num = token_value;
                        raw.add_number(dtok.num);

                        switch (sep = str.get_separator_token(dtfi, index_before_sep, char_before_sep)) {
                            // Note here we check if the num_count is less than three.
                            // When we have more than three numbers, it will be caught as error in the state machine.
                            case omni::internal::date_time_format::token_type::SEP_END:
                                dtok.dtt = omni::internal::date_time_format::token::NUM_END;
                                break;
                            case omni::internal::date_time_format::token_type::SEP_SPACE:
                            case omni::internal::date_time_format::token_type::SEP_Date:
                                dtok.dtt = omni::internal::date_time_format::token::NUM_DATE_SEP;
                                break;
                            case omni::internal::date_time_format::token_type::SEP_DATE_OR_OFFSET: {
                                // The separator is either a date separator or the start of a time zone offset. If the token will complete the date then
                                // process just the number and roll back the index so that the outer loop can attempt to parse the time zone offset.
                                if ((omni::internal::date_time_format::date_parsing_state(dps, omni::internal::date_time_format::token::NUM_DATE_SEP) == omni::internal::date_time_format::parse_state::ERR)
                                    && (omni::internal::date_time_format::date_parsing_state(dps, omni::internal::date_time_format::token::NUM_SPACE) > omni::internal::date_time_format::parse_state::ERR)) {
                                    str.index = index_before_sep;
                                    str.current_char = char_before_sep;
                                    dtok.dtt = omni::internal::date_time_format::token::NUM_SPACE;
                                } else {
                                    dtok.dtt = omni::internal::date_time_format::token::NUM_DATE_SEP;
                                }
                            } break;

                            case omni::internal::date_time_format::token_type::SEP_AM:
                            case omni::internal::date_time_format::token_type::SEP_PM:
                            case omni::internal::date_time_format::token_type::SEP_TIME:
                            case omni::internal::date_time_format::token_type::SEP_YEAR_SUFFIX:
                            case omni::internal::date_time_format::token_type::SEP_MONTH_SUFFIX:
                            case omni::internal::date_time_format::token_type::SEP_DAY_SUFFIX:
                            case omni::internal::date_time_format::token_type::SEP_HOUR_SUFFIX:
                            case omni::internal::date_time_format::token_type::SEP_MINUTE_SUFFIX:
                            case omni::internal::date_time_format::token_type::SEP_SECOND_SUFFIX:
                            case omni::internal::date_time_format::token_type::SEP_LOCAL_TIME_MARK:
                            case omni::internal::date_time_format::token_type::NUMBER_TOKEN:
                            case omni::internal::date_time_format::token_type::YEAR_NUMBER_TOKEN:
                            case omni::internal::date_time_format::token_type::AM:
                            case omni::internal::date_time_format::token_type::PM:
                            case omni::internal::date_time_format::token_type::MONTH_TOKEN:
                            case omni::internal::date_time_format::token_type::END_OF_STRING:
                            case omni::internal::date_time_format::token_type::DAY_OF_WEEK_TOKEN:
                            case omni::internal::date_time_format::token_type::TIME_ZONE_TOKEN:
                            case omni::internal::date_time_format::token_type::ERA_TOKEN:
                            case omni::internal::date_time_format::token_type::DATE_WORD_TOKEN:
                            case omni::internal::date_time_format::token_type::UNKNOWN_TOKEN:
                            case omni::internal::date_time_format::token_type::HEBREW_NUMBER:
                            case omni::internal::date_time_format::token_type::JAPANESE_ERA_TOKEN:
                            case omni::internal::date_time_format::token_type::TAIWAN_ERA_TOKEN:
                            case omni::internal::date_time_format::token_type::IGNORABLE_SYMBOL:
                            case omni::internal::date_time_format::token_type::SEP_UNK:
                            case omni::internal::date_time_format::token_type::REGULAR_TOKEN_MASK:
                            case omni::internal::date_time_format::token_type::SEPARATOR_TOKEN_MASK:
                            default:
                                // Invalid separator after number number.
                                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                                return false;
                        }
                    }
                } break;
                case omni::internal::date_time_format::token_type::DAY_OF_WEEK_TOKEN: {
                    if (raw.day_of_week == -1) {
                        // This is a day of week name.
                        raw.day_of_week = token_value;
                        dtok.dtt = omni::internal::date_time_format::token::DAY_OF_WEEK;
                    } else {
                        result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                        return false;
                    }
                } break;
                case omni::internal::date_time_format::token_type::MONTH_TOKEN: {
                    if (raw.month == -1) {
                        // This is a month name
                        sep = str.get_separator_token(dtfi, index_before_sep, char_before_sep);
                        switch (sep) {
                            case omni::internal::date_time_format::token_type::SEP_END: {
                                dtok.dtt = omni::internal::date_time_format::token::MONTH_END;
                            } break;
                            case omni::internal::date_time_format::token_type::SEP_SPACE: {
                                dtok.dtt = omni::internal::date_time_format::token::MONTH_SPACE;
                            } break;
                            case omni::internal::date_time_format::token_type::SEP_Date: {
                                dtok.dtt = omni::internal::date_time_format::token::MONTH_DATE_SEP;
                            } break;
                            case omni::internal::date_time_format::token_type::SEP_TIME: {
                                if (!raw.has_same_date_and_time_separators) {
                                    result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                                    return false;
                                }
                                // we have the date and time separators are same and getting a Month name, then change the token to MONTH_DATE_SEP as
                                // we are sure we are not parsing time.
                                dtok.dtt = omni::internal::date_time_format::token::MONTH_DATE_SEP;
                            } break;
                            case omni::internal::date_time_format::token_type::SEP_DATE_OR_OFFSET: {
                                // The separator is either a date separator or the start of a time zone offset. If the token will complete the date then
                                // process just the number and roll back the index so that the outer loop can attempt to parse the time zone offset.
                                if ((omni::internal::date_time_format::date_parsing_state(dps, omni::internal::date_time_format::token::MONTH_DATE_SEP) == omni::internal::date_time_format::parse_state::ERR)
                                    && (omni::internal::date_time_format::date_parsing_state(dps, omni::internal::date_time_format::token::MONTH_SPACE) > omni::internal::date_time_format::parse_state::ERR)) {
                                    str.index = index_before_sep;
                                    str.current_char = char_before_sep;
                                    dtok.dtt = omni::internal::date_time_format::token::MONTH_SPACE;
                                } else {
                                    dtok.dtt = omni::internal::date_time_format::token::MONTH_DATE_SEP;
                                }
                            } break;

                            case omni::internal::date_time_format::token_type::SEP_AM:
                            case omni::internal::date_time_format::token_type::SEP_PM:
                            case omni::internal::date_time_format::token_type::SEP_YEAR_SUFFIX:
                            case omni::internal::date_time_format::token_type::SEP_MONTH_SUFFIX:
                            case omni::internal::date_time_format::token_type::SEP_DAY_SUFFIX:
                            case omni::internal::date_time_format::token_type::SEP_HOUR_SUFFIX:
                            case omni::internal::date_time_format::token_type::SEP_MINUTE_SUFFIX:
                            case omni::internal::date_time_format::token_type::SEP_SECOND_SUFFIX:
                            case omni::internal::date_time_format::token_type::SEP_LOCAL_TIME_MARK:
                            case omni::internal::date_time_format::token_type::NUMBER_TOKEN:
                            case omni::internal::date_time_format::token_type::YEAR_NUMBER_TOKEN:
                            case omni::internal::date_time_format::token_type::AM:
                            case omni::internal::date_time_format::token_type::PM:
                            case omni::internal::date_time_format::token_type::MONTH_TOKEN:
                            case omni::internal::date_time_format::token_type::END_OF_STRING:
                            case omni::internal::date_time_format::token_type::DAY_OF_WEEK_TOKEN:
                            case omni::internal::date_time_format::token_type::TIME_ZONE_TOKEN:
                            case omni::internal::date_time_format::token_type::ERA_TOKEN:
                            case omni::internal::date_time_format::token_type::DATE_WORD_TOKEN:
                            case omni::internal::date_time_format::token_type::UNKNOWN_TOKEN:
                            case omni::internal::date_time_format::token_type::HEBREW_NUMBER:
                            case omni::internal::date_time_format::token_type::JAPANESE_ERA_TOKEN:
                            case omni::internal::date_time_format::token_type::TAIWAN_ERA_TOKEN:
                            case omni::internal::date_time_format::token_type::IGNORABLE_SYMBOL:
                            case omni::internal::date_time_format::token_type::SEP_UNK:
                            case omni::internal::date_time_format::token_type::REGULAR_TOKEN_MASK:
                            case omni::internal::date_time_format::token_type::SEPARATOR_TOKEN_MASK:
                            default:
                                //Invalid separator after month name
                                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                                return false;
                        }
                        raw.month = token_value;
                    } else {
                        result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                        return false;
                    }
                } break;
                case omni::internal::date_time_format::token_type::ERA_TOKEN: {
                    if (result.era != -1) {
                        result.era = static_cast<int16_t>(token_value);
                        dtok.dtt = omni::internal::date_time_format::token::ERA;
                    } else {
                        result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                        return false;
                    }
                } break;
                case omni::internal::date_time_format::token_type::JAPANESE_ERA_TOKEN: {
                    // Special case for Japanese. We allow Japanese era name to be used even if the calendar is not Japanese Calendar.
                    if (result.era != -1) {
                        result.era = static_cast<int16_t>(token_value);
                        dtok.dtt = omni::internal::date_time_format::token::ERA;
                    } else {
                        result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                        return false;
                    }
                } break;
                case omni::internal::date_time_format::token_type::TAIWAN_ERA_TOKEN: {
                    if (result.era != -1) {
                        result.era = static_cast<int16_t>(token_value);
                        dtok.dtt = omni::internal::date_time_format::token::ERA;
                    } else {
                        result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                        
                        return false;
                    }
                } break;
                case omni::internal::date_time_format::token_type::TIME_ZONE_TOKEN: {
                    // This is a timezone designator
                    // DEV_NOTE : for now, we only support "GMT" and "Z" (for Zulu time).
                    if ((result.flags & omni::internal::date_time_format::parse_flags::TIMEZONE_USED) != 0) {
                        // Should not have two timezone offsets.
                        result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                        return false;
                    }
                    dtok.dtt = omni::internal::date_time_format::token::TIME_ZONE;
                    result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::TIMEZONE_USED);
                    result.time_zone_offset = omni::chrono::time_span(0);
                    result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::TIMEZONE_UTC);
                } break;
                case omni::internal::date_time_format::token_type::END_OF_STRING: {
                    dtok.dtt = omni::internal::date_time_format::token::END;
                } break;
                case omni::internal::date_time_format::token_type::DATE_WORD_TOKEN:
                case omni::internal::date_time_format::token_type::IGNORABLE_SYMBOL: {
                    // Date words and ignorable symbols can just be skipped over
                } break;
                case omni::internal::date_time_format::token_type::AM:
                case omni::internal::date_time_format::token_type::PM: {
                    if (raw.time_mark == omni::internal::date_time_format::time_mark::NOT_SET) {
                        raw.time_mark = static_cast<omni::internal::date_time_format::time_mark::enum_t>(token_value);
                    } else {
                        result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                        return false;
                    }
                } break;
                case omni::internal::date_time_format::token_type::UNKNOWN_TOKEN: {
                    if (omni::char_util::is_letter(str.current_char)) {
                        result.set_failure(omni::chrono::date_time_parse_failure::FORMAT_WITH_PARAMETER, "Format_UnknowDateTimeWord");
                        return false;
                    }
                    if (((result.flags & omni::internal::date_time_format::parse_flags::CAPTURE_OFFSET) == 0)) {
                        str.get_next();
                        return true;
                    }

                    if ((str.current_char == '-' || str.current_char == '+') && ((result.flags & omni::internal::date_time_format::parse_flags::TIMEZONE_USED) == 0)) {
                        int32_t originalIndex = static_cast<int32_t>(str.index);
                        if (omni::internal::date_time_format::parse_time_zone(str, result.time_zone_offset)) {
                            result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::TIMEZONE_USED);
                            return true;
                        }
                        else {
                            // Time zone parse attempt failed. Fall through to punctuation handling.
                            str.index = originalIndex;
                        }
                    }
                    if (omni::internal::date_time_format::verify_valid_punctuation(str)) {
                        return true;
                    }

                    result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                    return false;
                } break;

                // explicit handling (avoid warnings)
                case omni::internal::date_time_format::token_type::SEP_UNK:
                case omni::internal::date_time_format::token_type::SEP_END:
                case omni::internal::date_time_format::token_type::SEP_SPACE:
                case omni::internal::date_time_format::token_type::SEP_AM:
                case omni::internal::date_time_format::token_type::SEP_PM:
                case omni::internal::date_time_format::token_type::SEP_Date:
                case omni::internal::date_time_format::token_type::SEP_TIME:
                case omni::internal::date_time_format::token_type::SEP_YEAR_SUFFIX:
                case omni::internal::date_time_format::token_type::SEP_MONTH_SUFFIX:
                case omni::internal::date_time_format::token_type::SEP_DAY_SUFFIX:
                case omni::internal::date_time_format::token_type::SEP_HOUR_SUFFIX:
                case omni::internal::date_time_format::token_type::SEP_MINUTE_SUFFIX:
                case omni::internal::date_time_format::token_type::SEP_SECOND_SUFFIX:
                case omni::internal::date_time_format::token_type::SEP_LOCAL_TIME_MARK:
                case omni::internal::date_time_format::token_type::SEP_DATE_OR_OFFSET:
                case omni::internal::date_time_format::token_type::REGULAR_TOKEN_MASK:
                case omni::internal::date_time_format::token_type::SEPARATOR_TOKEN_MASK:
                default: break;
            }

            
            return true;
        }

        // A date suffix is found, use this method to put the number into the result.
        bool process_date_time_suffix(omni::internal::date_time_format::parse_result& result, omni::internal::date_time_format::date_time_raw_info& raw, omni::internal::date_time_format::date_time_token& dtok)
        {
            switch (dtok.suffix) {
                case omni::internal::date_time_format::token_type::SEP_YEAR_SUFFIX: {
                    if ((result.flags & omni::internal::date_time_format::parse_flags::HAVE_YEAR) != 0) {
                        return false;
                    }
                    result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::HAVE_YEAR);
                    result.year = static_cast<int16_t>(dtok.num);
                    raw.year = dtok.num;
                } break;
                case omni::internal::date_time_format::token_type::SEP_MONTH_SUFFIX: {
                    if ((result.flags & omni::internal::date_time_format::parse_flags::HAVE_MONTH) != 0) {
                        return false;
                    }
                    result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::HAVE_MONTH);
                    result.month = static_cast<int16_t>(dtok.num);
                    raw.month = dtok.num;
                } break;
                case omni::internal::date_time_format::token_type::SEP_DAY_SUFFIX: {
                    if ((result.flags & omni::internal::date_time_format::parse_flags::HAVE_DAY) != 0) {
                        return false;
                    }
                    result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::HAVE_DAY);
                    result.day = static_cast<int16_t>(dtok.num);
                } break;
                case omni::internal::date_time_format::token_type::SEP_HOUR_SUFFIX: {
                    if ((result.flags & omni::internal::date_time_format::parse_flags::HAVE_HOUR) != 0) {
                        return false;
                    }
                    result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::HAVE_HOUR);
                    result.hour = static_cast<int16_t>(dtok.num);
                } break;
                case omni::internal::date_time_format::token_type::SEP_MINUTE_SUFFIX: {
                    if ((result.flags & omni::internal::date_time_format::parse_flags::HAVE_MINUTE) != 0) {
                        return false;
                    }
                    result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::HAVE_MINUTE);
                    result.minute = static_cast<int16_t>(dtok.num);
                } break;
                case omni::internal::date_time_format::token_type::SEP_SECOND_SUFFIX: {
                    if ((result.flags & omni::internal::date_time_format::parse_flags::HAVE_SECOND) != 0) {
                        return false;
                    }
                    result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::HAVE_SECOND);
                    result.second = static_cast<int16_t>(dtok.num);
                } break;

                // explicitly handle these (avoid warnings)
                case omni::internal::date_time_format::token_type::NUMBER_TOKEN:
                case omni::internal::date_time_format::token_type::YEAR_NUMBER_TOKEN:
                case omni::internal::date_time_format::token_type::AM:
                case omni::internal::date_time_format::token_type::PM:
                case omni::internal::date_time_format::token_type::MONTH_TOKEN:
                case omni::internal::date_time_format::token_type::END_OF_STRING:
                case omni::internal::date_time_format::token_type::DAY_OF_WEEK_TOKEN:
                case omni::internal::date_time_format::token_type::TIME_ZONE_TOKEN:
                case omni::internal::date_time_format::token_type::ERA_TOKEN:
                case omni::internal::date_time_format::token_type::DATE_WORD_TOKEN:
                case omni::internal::date_time_format::token_type::UNKNOWN_TOKEN:
                case omni::internal::date_time_format::token_type::HEBREW_NUMBER:
                case omni::internal::date_time_format::token_type::JAPANESE_ERA_TOKEN:
                case omni::internal::date_time_format::token_type::TAIWAN_ERA_TOKEN:
                case omni::internal::date_time_format::token_type::IGNORABLE_SYMBOL:
                case omni::internal::date_time_format::token_type::SEP_UNK:
                case omni::internal::date_time_format::token_type::SEP_END:
                case omni::internal::date_time_format::token_type::SEP_SPACE:
                case omni::internal::date_time_format::token_type::SEP_AM:
                case omni::internal::date_time_format::token_type::SEP_PM:
                case omni::internal::date_time_format::token_type::SEP_Date:
                case omni::internal::date_time_format::token_type::SEP_TIME:
                case omni::internal::date_time_format::token_type::SEP_LOCAL_TIME_MARK:
                case omni::internal::date_time_format::token_type::SEP_DATE_OR_OFFSET:
                case omni::internal::date_time_format::token_type::REGULAR_TOKEN_MASK:
                case omni::internal::date_time_format::token_type::SEPARATOR_TOKEN_MASK:
                default: break;
            }
            return true;
        }

        void adjust_time_mark(omni::internal::date_time_format::format_info& dtfi, omni::internal::date_time_format::date_time_raw_info& raw)
        {
            // Special case for culture which uses AM as empty string.
            // E.g. af-ZA (0x0436)
            //    S1159                 \x0000
            //    S2359                 nm
            // In this case, if we are parsing a string like "2005/09/14 12:23", we will assume this is in AM.

            if (raw.time_mark == omni::internal::date_time_format::time_mark::NOT_SET) {
                if (!dtfi.am_designator.empty() && !dtfi.pm_designator.empty()) {
                    if (dtfi.am_designator.size() == 0 && dtfi.pm_designator.size() != 0) {
                        raw.time_mark = omni::internal::date_time_format::time_mark::AM;
                    }
                    if (dtfi.pm_designator.size() == 0 && dtfi.am_designator.size() != 0) {
                        raw.time_mark = omni::internal::date_time_format::time_mark::PM;
                    }
                }
            }
        }

        bool check_default_date_time(omni::internal::date_time_format::parse_result& result, const omni::chrono::date_time_styles& styles)
        {
            if ((result.flags & omni::internal::date_time_format::parse_flags::CAPTURE_OFFSET) != 0) {
                /*
                    DateTimeOffset.Parse should allow dates without a year, but only if there is also no time zone marker;
                    e.g. "May 1 5pm" is OK, but "May 1 5pm -08:30" is not. This is somewhat pragmatic, since we would
                    have to re-architect parsing completely to allow this one case to correctly handle things like leap
                    years and leap months. Is is an extremely corner case, and DateTime is basically incorrect in that
                    case today.
                    
                    values like "11:00Z" or "11:00 -3:00" are also acceptable
                    
                    if ((month or day is set) and (year is not set and time zone is set))
                */
                 if (((result.month != -1) || (result.day != -1))
                    && ((result.year == -1 || ((result.flags & omni::internal::date_time_format::parse_flags::YEAR_DEFAULT) != 0)) && (result.flags & omni::internal::date_time_format::parse_flags::TIMEZONE_USED) != 0))
                {
                    result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_MissingIncompleteDate");
                    return false;
                }
            }

            if ((result.year == -1) || (result.month == -1) || (result.day == -1)) {
                /*
                    The following table describes the behaviors of getting the default value
                    when a certain year/month/day values are missing.

                    An "X" means that the value exists. And "--" means that value is missing.

                    Year    Month Day => ResultYear ResultMonth     ResultDay     Note

                    X     X     X     Parsed year Parsed month    Parsed day
                    X     X     --     Parsed Year Parsed month    First day     If we have year and month, assume the first day of that month.
                    X     --     X     Parsed year First month     Parsed day     If the month is missing, assume first month of that year.
                    X     --     --     Parsed year First month     First day     If we have only the year, assume the first day of that year.

                    --     X     X     CurrentYear Parsed month    Parsed day     If the year is missing, assume the current year.
                    --     X     --     CurrentYear Parsed month    First day     If we have only a month value, assume the current year and current day.
                    --     --     X     CurrentYear First month     Parsed day     If we have only a day value, assume current year and first month.
                    --     --     --     CurrentYear Current month Current day     So this means that if the date string only contains time, you will get current date.

                */
                omni::chrono::date_time now = omni::internal::date_time_format::get_date_time_now(result, styles);
                if (result.month == -1 && result.day == -1) {
                    if (result.year == -1) {
                        if ((styles & omni::chrono::date_time_styles::NO_CURRENT_DATE_DEFAULT) != 0) {
                            // If there is no year/month/day values, and NoCurrentDateDefault flag is used,
                            // set the year/month/day value to the beginning year/month/day of DateTime().
                            // Note we should be using Gregorian for the year/month/day.
                            // cal = GregorianCalendar.GetDefaultInstance();
                            result.year = result.month = result.day = 1;
                        } else {
                            // Year/Month/Day are all missing.
                            result.year = static_cast<int16_t>(now.year()); // cal.GetYear(now);
                            result.month = static_cast<int16_t>(now.month()); // cal.GetMonth(now);
                            result.day = static_cast<int16_t>(now.day()); // cal.GetDayOfMonth(now);
                        }
                    } else {
                        // Month/Day are both missing.
                        result.month = 1;
                        result.day = 1;
                    }
                } else {
                    if (result.year == -1) {
                        result.year = static_cast<int16_t>(now.year()); // cal.GetYear(now);
                    }
                    if (result.month == -1) {
                        result.month = 1;
                    }
                    if (result.day == -1) {
                        result.day = 1;
                    }
                }
            }
            // Set Hour/Minute/Second to zero if these value are not in str.
            if (result.hour == -1) { result.hour = 0; }
            if (result.minute == -1) { result.minute = 0; }
            if (result.second == -1) { result.second = 0; }
            if (result.era == -1) { result.era = 0; }
            return true;
        }

        // Adjust the specified time to universal time based on the supplied timezone.
        // E.g. when parsing "2001/06/08 14:00-07:00",
        // the time is 2001/06/08 14:00, and time_zone_offset = -07:00.
        // The result will be "2001/06/08 21:00"
        bool adjust_time_zone_to_universal(omni::internal::date_time_format::parse_result& result)
        {
            int64_t result_ticks = static_cast<int64_t>(result.parsed_date.ticks());
            result_ticks -= result.time_zone_offset.ticks();
            if (result_ticks < 0) {
                result_ticks += OMNI_TICKS_PER_DAY; // OMNI_TICKS_PER_DAY;
            }

            if (static_cast<uint64_t>(result_ticks) < omni::chrono::date_time::min_ticks() || static_cast<uint64_t>(result_ticks) > omni::chrono::date_time::max_ticks()) {
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_DateOutOfRange");
                return false;
            }
            result.parsed_date = omni::chrono::date_time(static_cast<uint64_t>(result_ticks), omni::chrono::date_time_kind::UTC);
            return true;
        }

        bool adjust_time_zone_to_local(omni::internal::date_time_format::parse_result& result, bool is_time_only)
        {
            int64_t result_ticks = static_cast<int64_t>(result.parsed_date.ticks());
            // Convert to local ticks
            // TimeZoneInfo tz = TimeZoneInfo.Local;
            // bool isAmbiguousLocalDst = false;
            if (result_ticks < OMNI_TICKS_PER_DAY) {
                // This is time of day.

                // Adjust timezone.
                result_ticks -= result.time_zone_offset.ticks();
                // If the time is time of day, use the current timezone offset.
                result_ticks += (is_time_only ? omni::chrono::date_time::now() : result.parsed_date).ticks();

                if (result_ticks < 0) {
                    result_ticks += OMNI_TICKS_PER_DAY;
                }
            } else {
                // Adjust timezone to GMT.
                result_ticks -= result.time_zone_offset.ticks();
                if (static_cast<uint64_t>(result_ticks) < omni::chrono::date_time::min_ticks() || static_cast<uint64_t>(result_ticks) > omni::chrono::date_time::max_ticks()) {
                    // If the result ticks is greater than DateTime.MaxValue, we can not create a DateTime from this ticks.
                    // In this case, keep using the old code.
                    result_ticks += result.parsed_date.utc_offset().ticks();
                } else {
                    // Convert the GMT time to local time.
                    omni::chrono::date_time utc_dt(static_cast<uint64_t>(result_ticks), omni::chrono::date_time_kind::LOCAL);
                    result_ticks += utc_dt.utc_offset().ticks();
                    if (utc_dt.is_dst()) {
                        result_ticks += OMNI_TICKS_PER_HOUR;
                    }
                }
            }
            if (static_cast<uint64_t>(result_ticks) < omni::chrono::date_time::min_ticks() || static_cast<uint64_t>(result_ticks) > omni::chrono::date_time::max_ticks()) {
                result.parsed_date = omni::chrono::date_time::min_value();
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_DateOutOfRange");
                return false;
            }
            result.parsed_date = omni::chrono::date_time(static_cast<uint64_t>(result_ticks), omni::chrono::date_time_kind::LOCAL); //, isAmbiguousLocalDst);
            return true;
        }

        // Apply validation and adjustments specific to DateTimeOffset
        bool date_time_offset_time_zone_post_processing(omni::internal::date_time_format::parse_result& result, const omni::chrono::date_time_styles& styles)
        {
            // For DateTimeOffset, default to the Utc or Local offset when an offset was not specified by the input string.
            if ((result.flags & omni::internal::date_time_format::parse_flags::TIMEZONE_USED) == 0) {
                if ((styles & omni::chrono::date_time_styles::ASSUME_UNIVERSAL) != 0) {
                    // AssumeUniversal causes the offset to default to zero (0)
                    result.time_zone_offset = omni::chrono::time_span::zero();
                }
                else {
                    // AssumeLocal causes the offset to default to Local. This flag is on by default for DateTimeOffset.
                    result.time_zone_offset = result.parsed_date.utc_offset();
                }
            }

            int64_t offset_ticks = result.time_zone_offset.ticks();
            // there should be no overflow, because the offset can be no more than -+100 hours and the date already fits within a DateTime.
            int64_t utc_ticks = static_cast<int64_t>(result.parsed_date.ticks()) - offset_ticks;

            // For DateTimeOffset, both the parsed time and the corresponding UTC value must be within the boundaries of a DateTime instance.
            if (static_cast<uint64_t>(utc_ticks) < omni::chrono::date_time::min_ticks() || static_cast<uint64_t>(utc_ticks) > omni::chrono::date_time::max_ticks()) {
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_UTCOutOfRange");
                return false;
            }

            // the offset must be within +- 14:00 hours.
            if (offset_ticks < OMNI_DATE_INTERNAL_MIN_OFFSET_FW || offset_ticks > OMNI_DATE_INTERNAL_MAX_OFFSET_FW) {
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_OffsetOutOfRange");
                return false;
            }

            // DateTimeOffset should still honor the AdjustToUniversal flag for consistency with DateTime. It means you
            // want to return an adjusted UTC value, so store the utc_ticks in the DateTime and set the offset to zero
            if ((styles & omni::chrono::date_time_styles::ADJUST_TO_UNIVERSAL) != 0) {
                if (((result.flags & omni::internal::date_time_format::parse_flags::TIMEZONE_USED) == 0) && ((styles & omni::chrono::date_time_styles::ASSUME_UNIVERSAL) == 0)) {
                    // Handle the special case where the time_zone_offset was defaulted to Local
                    bool toUtcResult = omni::internal::date_time_format::adjust_time_zone_to_universal(result);
                    result.time_zone_offset = omni::chrono::time_span::zero();
                    return toUtcResult;
                }

                // The constructor should always succeed because of the range check earlier in the function
                // Although it is UTC, internally DateTimeOffset does not use this flag
                result.parsed_date = omni::chrono::date_time(static_cast<uint64_t>(utc_ticks), omni::chrono::date_time_kind::UTC);
                result.time_zone_offset = omni::chrono::time_span::zero();
            }

            return true;
        }

        // Handles time zone adjustments and sets DateTimeKind values as required by the styles
        bool determine_time_zone_adjustments(omni::internal::date_time_format::parse_result& result, const omni::chrono::date_time_styles& styles, bool is_time_only)
        {
            if ((result.flags & omni::internal::date_time_format::parse_flags::CAPTURE_OFFSET) != 0) {
                // This is a DateTimeOffset parse, so the offset will actually be captured directly, and no adjustment is required in most cases
                return omni::internal::date_time_format::date_time_offset_time_zone_post_processing(result, styles);
            } else {
                int64_t offset_ticks = result.time_zone_offset.ticks();
                // the DateTime offset must be within +- 14:00 hours.
                if (offset_ticks < OMNI_DATE_INTERNAL_MIN_OFFSET_FW || offset_ticks > OMNI_DATE_INTERNAL_MAX_OFFSET_FW) {
                    result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_OffsetOutOfRange");
                    return false;
                }
            }

            // The flags AssumeUniversal and AssumeLocal only apply when the input does not have a time zone
            if ((result.flags & omni::internal::date_time_format::parse_flags::TIMEZONE_USED) == 0) {

                // If AssumeLocal or AssumeLocal is used, there will always be a kind specified. As in the
                // case when a time zone is present, it will default to being local unless AdjustToUniversal
                // is present. These comparisons determine whether setting the kind is sufficient, or if a
                // time zone adjustment is required. For consistency with the rest of parsing, it is desirable
                // to fall through to the Adjust methods below, so that there is consist handling of boundary
                // cases like wrapping around on time-only dates and temporarily allowing an adjusted date
                // to exceed DateTime.MaxValue
                if ((styles & omni::chrono::date_time_styles::ASSUME_LOCAL) != 0) {
                    if ((styles & omni::chrono::date_time_styles::ADJUST_TO_UNIVERSAL) != 0) {
                        result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::TIMEZONE_USED);
                        result.time_zone_offset = result.parsed_date.utc_offset();
                    } else {
                        result.parsed_date = omni::chrono::date_time::specify_kind(result.parsed_date, omni::chrono::date_time_kind::LOCAL);
                        return true;
                    }
                } else if ((styles & omni::chrono::date_time_styles::ASSUME_UNIVERSAL) != 0) {
                    if ((styles & omni::chrono::date_time_styles::ADJUST_TO_UNIVERSAL) != 0) {
                        result.parsed_date = omni::chrono::date_time::specify_kind(result.parsed_date, omni::chrono::date_time_kind::UTC);
                        return true;
                    } else {
                        result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::TIMEZONE_USED);
                        result.time_zone_offset = omni::chrono::time_span::zero();
                    }
                } else {
                    // No time zone and no Assume flags, so DateTimeKind.Unspecified is fine
                    return true;
                }
            }
            if (((styles & omni::chrono::date_time_styles::ROUNDTRIP_KIND) != 0) && ((result.flags & omni::internal::date_time_format::parse_flags::TIMEZONE_UTC) != 0)) {
                result.parsed_date = omni::chrono::date_time::specify_kind(result.parsed_date, omni::chrono::date_time_kind::UTC);
                return true;
            }

            if ((styles & omni::chrono::date_time_styles::ADJUST_TO_UNIVERSAL) != 0) {
                return (omni::internal::date_time_format::adjust_time_zone_to_universal(result));
            }
            return (omni::internal::date_time_format::adjust_time_zone_to_local(result, is_time_only));
        }

        bool parse_digits(omni::internal::date_time_format::__dt_string& str, int64_t min_digit_len, int64_t max_digit_len, int64_t& result)
        {
            int64_t start_index = str.index;
            int64_t tok_len = 0;
            result = 0;
            while (tok_len < max_digit_len) {
                if (!str.get_next_digit()) {
                    --str.index;
                    break;
                }
                result = result * 10 + static_cast<int64_t>(str.get_digit());
                ++tok_len;
            }
            if (tok_len < min_digit_len) {
                str.index = start_index;
                return false;
            }
            return true;
        }

        bool parse_digits(omni::internal::date_time_format::__dt_string& str, int64_t digit_len, int64_t& result)
        {
            if (digit_len == 1) {
                // 1 really means 1 or 2 for this call
                return omni::internal::date_time_format::parse_digits(str, 1, 2, result);
            }
            else {
                return omni::internal::date_time_format::parse_digits(str, digit_len, digit_len, result);
            }
        }

        bool parse_iso_8601(omni::internal::date_time_format::date_time_raw_info& raw, omni::internal::date_time_format::__dt_string& str, const omni::chrono::date_time_styles& styles, omni::internal::date_time_format::parse_result& result)
        {
            int64_t hour, minute;
            int64_t second = 0;
            double part_second = 0;
            --str.index;

            str.skip_white_spaces();
            if (!omni::internal::date_time_format::parse_digits(str, 2, hour)) {
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                return false;
            }
            str.skip_white_spaces();
            if (!str.match(':')) {
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                return false;
            }
            str.skip_white_spaces();
            if (!omni::internal::date_time_format::parse_digits(str, 2, minute)) {
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                return false;
            }
            str.skip_white_spaces();
            if (str.match(':')) {
                str.skip_white_spaces();
                if (!omni::internal::date_time_format::parse_digits(str, 2, second)) {
                    result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                    return false;
                }
                if (str.match('.')) {
                    if (!omni::internal::date_time_format::parse_fraction(str, part_second)) {
                        result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                        return false;
                    }
                    --str.index;
                }
                str.skip_white_spaces();
            }
            if (str.get_next()) {
                char ch = str.get_char();
                if (ch == '+' || ch == '-') {
                    result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::TIMEZONE_USED);
                    if (!omni::internal::date_time_format::parse_time_zone(str, result.time_zone_offset)) {
                        result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                        return false;
                    }
                } else if (ch == 'Z' || ch == 'z') {
                    result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::TIMEZONE_USED);
                    result.time_zone_offset = omni::chrono::time_span::zero();
                    result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::TIMEZONE_UTC);
                } else {
                    --str.index;
                }
                str.skip_white_spaces();
                if (str.match('#')) {
                    if (!omni::internal::date_time_format::verify_valid_punctuation(str)) {
                        result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                        return false;
                    }
                    str.skip_white_spaces();
                }
                if (str.match('\0')) {
                    if (!omni::internal::date_time_format::verify_valid_punctuation(str)) {
                        result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                        return false;
                    }
                }
                if (str.get_next()) {
                    // If this is true, there were non-white space characters remaining in the DateTime
                    result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                    return false;
                }
            }

            omni::chrono::date_time time = omni::chrono::date_time::min_value();
            //Calendar calendar = GregorianCalendar.GetDefaultInstance();
            if (!omni::chrono::date_time::try_create(static_cast<uint16_t>(raw.year), static_cast<uint16_t>(raw.get_number(0)), static_cast<uint16_t>(raw.get_number(1)), static_cast<uint16_t>(hour), static_cast<uint16_t>(minute), static_cast<uint16_t>(second), 0, time)) {
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT_BAD_DATE_TIME_CALENDAR, "Format_BadDateTimeCalendar");
                return false;
            }

            time = time.add_ticks(static_cast<int64_t>(omni::math::round(part_second * OMNI_TICKS_PER_SECOND)));
            result.parsed_date = time;
            if (!omni::internal::date_time_format::determine_time_zone_adjustments(result, styles, false)) {
                return false;
            }
            return true;
        }

        bool adjust_hour(int16_t& hour, omni::internal::date_time_format::time_mark::enum_t time_mark)
        {
            if (time_mark != omni::internal::date_time_format::time_mark::NOT_SET) {
                if (time_mark == omni::internal::date_time_format::time_mark::AM) {
                    if (hour < 0 || hour > 12) {
                        return false;
                    }
                    hour = (hour == 12) ? 0 : hour;
                } else {
                    if (hour < 0 || hour > 23) {
                        return false;
                    }
                    if (hour < 12) {
                        hour += 12;
                    }
                }
            }
            return true;
        }

        // This is the real method to do the parsing work.
        bool try_parse
        (
            const std::string& date_str,
            omni::internal::date_time_format::format_info& dtfi,
            omni::chrono::date_time_styles& styles,
            omni::internal::date_time_format::parse_result& result
        ) {
            if (date_str.empty()) {
                return false;
            }

            omni::chrono::date_time time = omni::chrono::date_time::min_value();
            // First try the predefined format.
            omni::internal::date_time_format::parse_state::enum_t dps = omni::internal::date_time_format::parse_state::BEGIN;
            bool is_terminal_state = false;

            omni::internal::date_time_format::date_time_token dtok; // The buffer to store the parsing token
            dtok.suffix = omni::internal::date_time_format::token_type::SEP_UNK;

            int64_t number_pointer[3] = {0};
            omni::internal::date_time_format::date_time_raw_info raw(&number_pointer[0]); // The buffer to store temporary parsing information.

            raw.has_same_date_and_time_separators = (dtfi.date_separator == dtfi.time_separator);

            // result.calendar = dtfi.Calendar;
            result.era = 0; // Calendar.CurrentEra;

            // The string to be parsed. Use a __dt_string wrapper so that we can trace the index which
            // indicates the beginning of next token
            omni::internal::date_time_format::__dt_string str(date_str, dtfi);
            str.get_next();

            // The following loop will break when we reach the end of the str.
            do {
                // Call the lexer to get the next token
                // If we find a era in lex(), the era value will be in raw.era.
                if (!omni::internal::date_time_format::lex(dps, str, dtok, raw, result, dtfi, styles)) {
                    return false;
                }

                // If the token is not unknown, process it.
                // Otherwise, just discard it.
                if (dtok.dtt != omni::internal::date_time_format::token::UNKNOWN) {
                    // Check if we got any CJK Date/Time suffix.
                    // Since the Date/Time suffix tells us the number belongs to year/month/day/hour/minute/second,
                    // store the number in the appropriate field in the result.
                    if (dtok.suffix != omni::internal::date_time_format::token_type::SEP_UNK) {
                        if (!omni::internal::date_time_format::process_date_time_suffix(result, raw, dtok)) {
                            result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                            return false;
                        }

                        dtok.suffix = omni::internal::date_time_format::token_type::SEP_UNK; // Reset suffix to SEP_UNK;
                    }

                    if (dtok.dtt == omni::internal::date_time_format::token::NUM_LOCAL_TIME_MARK) {
                        if (dps == omni::internal::date_time_format::parse_state::D_YNd || dps == omni::internal::date_time_format::parse_state::D_YN) {
                            // Consider this as ISO 8601 format:
                            // "yyyy-MM-dd'T'HH:mm:ss"                 1999-10-31T02:00:00
                            return (omni::internal::date_time_format::parse_iso_8601(raw, str, styles, result));
                        } else {
                            result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                            return false;
                        }
                    }

                    if (raw.has_same_date_and_time_separators) {
                        if (dtok.dtt == omni::internal::date_time_format::token::YEAR_END || dtok.dtt == omni::internal::date_time_format::token::YEAR_SPACE || dtok.dtt == omni::internal::date_time_format::token::YEAR_DATE_SEP) {
                            // When time and date separators are same and we are hitting a year number while the first parsed part of the string was recognized
                            // as part of time (and not a date) omni::internal::date_time_format::parse_state::T_Nt, omni::internal::date_time_format::parse_state::T_NNt then change the state to be a date so we try to parse it as a date instead
                            if (dps == omni::internal::date_time_format::parse_state::T_Nt) {
                                dps = omni::internal::date_time_format::parse_state::D_Nd;
                            } else if (dps == omni::internal::date_time_format::parse_state::T_NNt) {
                                dps = omni::internal::date_time_format::parse_state::D_NNd;
                            }
                        }

                        bool atEnd = str.at_end();
                        if (omni::internal::date_time_format::date_parsing_state(dps, dtok.dtt) == omni::internal::date_time_format::parse_state::ERR || atEnd) {
                            switch (dtok.dtt) {
                                // we have the case of Serbia have dates in forms 'd.M.yyyy.' so we can expect '.' after the date parts.
                                // changing the token to end with space instead of Date Separator will avoid failing the parsing.
                                case omni::internal::date_time_format::token::YEAR_DATE_SEP: dtok.dtt = atEnd ? omni::internal::date_time_format::token::YEAR_END : omni::internal::date_time_format::token::YEAR_SPACE; break;
                                case omni::internal::date_time_format::token::NUM_DATE_SEP: dtok.dtt = atEnd ? omni::internal::date_time_format::token::NUM_END : omni::internal::date_time_format::token::NUM_SPACE; break;
                                case omni::internal::date_time_format::token::NUM_TIME_SEP: dtok.dtt = atEnd ? omni::internal::date_time_format::token::NUM_END : omni::internal::date_time_format::token::NUM_SPACE; break;
                                case omni::internal::date_time_format::token::MONTH_DATE_SEP: dtok.dtt = atEnd ? omni::internal::date_time_format::token::MONTH_END : omni::internal::date_time_format::token::MONTH_SPACE; break;

                                // handle these explicitly (avoid warnings)
                                case omni::internal::date_time_format::token::END:
                                case omni::internal::date_time_format::token::NUM_END:
                                case omni::internal::date_time_format::token::NUM_AM_PM:
                                case omni::internal::date_time_format::token::NUM_SPACE:
                                case omni::internal::date_time_format::token::MONTH_END:
                                case omni::internal::date_time_format::token::MONTH_SPACE:
                                case omni::internal::date_time_format::token::NUM_DATE_SUFFIX:
                                case omni::internal::date_time_format::token::NUM_TIME_SUFFIX:
                                case omni::internal::date_time_format::token::DAY_OF_WEEK:
                                case omni::internal::date_time_format::token::YEAR_SPACE:
                                case omni::internal::date_time_format::token::YEAR_END:
                                case omni::internal::date_time_format::token::TIME_ZONE:
                                case omni::internal::date_time_format::token::ERA:
                                case omni::internal::date_time_format::token::NUM_UTC_TIME_MARK:
                                case omni::internal::date_time_format::token::UNKNOWN:
                                case omni::internal::date_time_format::token::NUM_LOCAL_TIME_MARK:
                                case omni::internal::date_time_format::token::MAX:
                                default: break;
                            }
                        }
                    }

                    // advance to the next state, and continue
                    dps = omni::internal::date_time_format::date_parsing_state(dps, dtok.dtt);

                    if (dps == omni::internal::date_time_format::parse_state::ERR) {
                        result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                        return false;
                    } else if (dps > omni::internal::date_time_format::parse_state::ERR) {
                        if ((dtfi.fmt_flags & format_flags::USE_HEBREW_RULE) != 0) {
                            return false;
                        } else {
                            if (!omni::internal::date_time_format::process_terminal_t_state(dps, result, styles, raw, dtfi)) {
                                return false;
                            }
                        }
                        is_terminal_state = true;

                        // If we have reached a terminal state, start over from omni::internal::date_time_format::parse_state::BEGIN again.
                        // For example, when we parsed "1999-12-23 13:30", we will reach a terminal state at "1999-12-23",
                        // and we start over so we can continue to parse "12:30".
                        dps = omni::internal::date_time_format::parse_state::BEGIN;
                    }
                }
            } while (dtok.dtt != omni::internal::date_time_format::token::END && dtok.dtt != omni::internal::date_time_format::token::NUM_END && dtok.dtt != omni::internal::date_time_format::token::MONTH_END);

            if (!is_terminal_state) {
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                return false;
            }

            omni::internal::date_time_format::adjust_time_mark(dtfi, raw);
            if (!omni::internal::date_time_format::adjust_hour(result.hour, raw.time_mark)) {
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                return false;
            }

            // Check if the parsed string only contains hour/minute/second values.
            bool is_time_only = (result.year == -1 && result.month == -1 && result.day == -1);

            // Check if any year/month/day is missing in the parsing string.
            // If yes, get the default value from today's date.
            if (!omni::internal::date_time_format::check_default_date_time(result, styles)) {
                return false;
            }

            if (!omni::chrono::date_time::try_create(static_cast<uint16_t>(result.year), static_cast<uint16_t>(result.month), static_cast<uint16_t>(result.day), static_cast<uint16_t>(result.hour), static_cast<uint16_t>(result.minute), static_cast<uint16_t>(result.second), 0, time)) {
                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT_BAD_DATE_TIME_CALENDAR, "Format_BadDateTimeCalendar");
                return false;
            }
            if (raw.fraction > 0) {
                time = time.add_ticks(static_cast<int64_t>(omni::math::round(raw.fraction * OMNI_TICKS_PER_SECOND)));
            }

            // We have to check day of week before we adjust to the time zone.
            // Otherwise, the value of day of week may change after adjusting to the time zone.
            if (raw.day_of_week != -1) {
                // Check if day of week is correct.
                if (raw.day_of_week != static_cast<int64_t>(time.day_of_week())) {
                    result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDayOfWeek");
                    return false;
                }
            }

            result.parsed_date = time;

            if (!omni::internal::date_time_format::determine_time_zone_adjustments(result, styles, is_time_only)) {
                return false;
            }

            return true;
        }

        bool try_parse(const std::string& date_str, omni::internal::date_time_format::format_info& dtfi, const omni::chrono::date_time_styles& styles, omni::chrono::date_time& result)
        {
            omni::chrono::date_time_styles style_data = styles;
            omni::internal::date_time_format::parse_result data;
            if (omni::internal::date_time_format::try_parse(date_str, dtfi, style_data, data)) {
                result = data.parsed_date;
                return true;
            }
            return false;
        }

        bool try_parse(const std::string& date_str, omni::internal::date_time_format::format_info& dtfi, const omni::chrono::date_time_styles& styles, omni::chrono::date_time& result, omni::chrono::date_time_parse_failure& fail_reason)
        {
            omni::chrono::date_time_styles style_data = styles;
            omni::internal::date_time_format::parse_result data;
            fail_reason = omni::chrono::date_time_parse_failure::NONE;
            if (omni::internal::date_time_format::try_parse(date_str, dtfi, style_data, data)) {
                result = data.parsed_date;
                return true;
            }
            fail_reason = data.failure;
            return false;
        }

        omni::chrono::date_time parse(const std::string& date_str, omni::internal::date_time_format::format_info& dtfi, const omni::chrono::date_time_styles& styles)
        {
            omni::chrono::date_time_styles style_data = styles;
            omni::internal::date_time_format::parse_result result;
            if (omni::internal::date_time_format::try_parse(date_str, dtfi, style_data, result)) {
                return result.parsed_date;
            }
            OMNI_ERR_RETV_FW("Invalid date time string detected", omni::exceptions::invalid_parse(), omni::chrono::date_time())
        }

        namespace date_time_parse
        {
            struct parsing_info
            {
                // Calendar calendar;
                int16_t day_of_week;
                date_time_format::time_mark::enum_t time_mark;

                bool use_hour_12;
                bool use_two_digit_year;
                bool allow_inner_ws;
                bool allow_trailing_ws;
                bool custom_number_parser;

                void init()
                {
                    this->day_of_week = -1;
                    this->time_mark = date_time_format::time_mark::NOT_SET;
                    this->use_hour_12 = false;
                    this->use_two_digit_year = false;
                    this->allow_inner_ws = false;
                    this->allow_trailing_ws = false;
                    this->custom_number_parser = false;
                }
            };

            std::string get_real_format(const std::string& format, const omni::internal::date_time_format::format_info& dtfi)
            {
                std::string real_format;
                switch (format[0]) {
                    case 'd':     // Short Date
                        real_format = dtfi.short_date_pattern;
                        break;
                    case 'D':     // Long Date
                        real_format = dtfi.long_date_pattern;
                        break;
                    case 'f':     // Full (long date + short time)
                        real_format = dtfi.long_date_pattern + " " + dtfi.short_time_pattern;
                        break;
                    case 'F':     // Full (long date + long time)
                        real_format = dtfi.full_date_time_pattern;
                        break;
                    case 'g':     // General (short date + short time)
                        real_format = dtfi.general_short_time_pattern;
                        break;
                    case 'G':     // General (short date + long time)
                        real_format = dtfi.general_long_time_pattern;
                        break;
                    case 'm':
                    case 'M':     // Month/Day Date
                        real_format = dtfi.month_day_pattern;
                        break;
                    case 'o':
                    case 'O':
                        real_format = "yyyy'-'MM'-'dd'T'HH':'mm':'ss.fffffffK"; // RoundtripFormat;
                        break;
                    case 'r':
                    case 'R':     // RFC 1123 Standard
                        real_format = dtfi.rfc_1123_pattern;
                        break;
                    case 's':     // Sortable without Time Zone Info
                        real_format = dtfi.sortable_date_time_pattern;
                        break;
                    case 't':     // Short Time
                        real_format = dtfi.short_time_pattern;
                        break;
                    case 'T':     // Long Time
                        real_format = dtfi.long_time_pattern;
                        break;
                    case 'u':     // Universal with Sortable format
                        real_format = dtfi.universal_sortable_date_time_pattern;
                        break;
                    case 'U':     // Universal with Full (long date + long time) format
                        real_format = dtfi.full_date_time_pattern;
                        break;
                    case 'y':
                    case 'Y':     // Year/Month Date
                        real_format = dtfi.year_month_pattern;
                        break;
                    default:
                        OMNI_ERR_RETV_FW("Invalid format specified", omni::exceptions::invalid_string_format(), std::string())
                }
                return real_format;
            }

            std::string expand_predefined_format(const std::string& format, omni::internal::date_time_format::format_info& dtfi, omni::internal::date_time_format::date_time_parse::parsing_info& parse_info, omni::internal::date_time_format::parse_result& result)
            {
                OMNI_UNUSED(parse_info);
                // Check the format to see if we need to override the dtfi to be invariant info,
                // and see if we need to set up the userUniversalTime flag.
                switch (format[0]) {
                    case 'o':
                    case 'O':     // Round Trip Format
                        // parseInfo.calendar = GregorianCalendar.GetDefaultInstance();
                        dtfi.reset();
                        break;
                    case 'r':
                    case 'R':     // RFC 1123 Standard. (in Universal time)
                        // parseInfo.calendar = GregorianCalendar.GetDefaultInstance();
                        dtfi.reset();

                        if ((result.flags & omni::internal::date_time_format::parse_flags::CAPTURE_OFFSET) != 0) {
                            result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::RFC1123_PATTERN);
                        }
                        break;
                    case 's':     // Sortable format (in local time)
                        dtfi.reset();
                        // parseInfo.calendar = GregorianCalendar.GetDefaultInstance();
                        break;
                    case 'u':     // Universal time format in sortable format.
                        // parseInfo.calendar = GregorianCalendar.GetDefaultInstance();
                        dtfi.reset();

                        if ((result.flags & omni::internal::date_time_format::parse_flags::CAPTURE_OFFSET) != 0) {
                            result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::UTC_SORT_PATTERN);
                        }
                        break;
                    case 'U':     // Universal time format with culture-dependent format.
                        // parseInfo.calendar = GregorianCalendar.GetDefaultInstance();
                        result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::TIMEZONE_USED);
                        result.time_zone_offset = omni::chrono::time_span::zero();
                        result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::TIMEZONE_UTC);
                        break;
                    default: break;
                }

                // Expand the pre-defined format character to the real format from DateTimeFormatInfo.
                return omni::internal::date_time_format::date_time_parse::get_real_format(format, dtfi);
            }

            bool check_new_value(int16_t& current_val, int16_t new_val, omni::internal::date_time_format::parse_result& result)
            {
                if (current_val == -1) {
                    current_val = new_val;
                    return true;
                } else {
                    if (new_val != current_val) {
                        result.set_failure(omni::chrono::date_time_parse_failure::FORMAT_WITH_PARAMETER, "Format_RepeatDateTimePattern");
                        return false;
                    }
                }
                return true;
            }
            
            bool match_abbreviated_month_name(omni::internal::date_time_format::__dt_string& str, omni::internal::date_time_format::format_info& dtfi, int64_t& result)
            {
                int64_t max_match_str_len = 0;
                result = -1;
                if (str.get_next()) {
                    // Scan the month names (note that some calendars has 13 months) and find the matching month name which has the max string length.
                    // We need to do this because some cultures (e.g. "cs-CZ") which have abbreviated month names with the same prefix.
                    for (std::size_t i = 1; i < omni::chrono::month::COUNT(); ++i) {
                        std::string search_str = omni::chrono::month::get_abbreviated_name(i);
                        std::size_t match_str_len = search_str.size();
                        if ( dtfi.has_spaces_in_month_names()
                                ? str.match_specified_words(search_str, false, match_str_len)
                                : str.match_specified_word(search_str)) {
                            if (static_cast<int64_t>(match_str_len) > max_match_str_len) {
                                max_match_str_len = static_cast<int64_t>(match_str_len);
                                result = static_cast<int64_t>(i);
                            }
                        }
                    }

                    // Search leap year form.
                    if ((dtfi.fmt_flags & omni::internal::date_time_format::format_flags::USE_LEAP_YEAR_MONTH) != 0) {
                        int64_t temp_res = str.match_longest_words(dtfi.internal_get_leap_year_names(), max_match_str_len);
                        // We found a longer match in the leap year month name. Use this as the result.
                        // The result from match_longest_words is 0 ~ length of word array.
                        // So we increment the result by one to become the month value.
                        if (temp_res >= 0) {
                            result = temp_res + 1;
                        }
                    }
                }
                if (result > 0) {
                    str.index += (max_match_str_len - 1);
                    return true;
                }
                return false;
            }

            bool match_month_name(omni::internal::date_time_format::__dt_string& str, omni::internal::date_time_format::format_info& dtfi, int64_t& result)
            {
                int64_t max_match_str_len = 0;
                result = -1;
                if (str.get_next()) {
                    // Scan the month names (note that some calendars has 13 months) and find the matching month name which has the max string length.
                    // We need to do this because some cultures (e.g. "vi-VN") which have month names with the same prefix.
                    for (std::size_t i = 1; i < omni::chrono::month::COUNT(); ++i) {
                        std::string search_str = omni::chrono::month::get_name(i);
                        std::size_t match_str_len = search_str.size();
                        if ( dtfi.has_spaces_in_month_names()
                                ? str.match_specified_words(search_str, false, match_str_len)
                                : str.match_specified_word(search_str)) {
                            if (static_cast<int64_t>(match_str_len) > max_match_str_len) {
                                max_match_str_len = static_cast<int64_t>(match_str_len);
                                result = static_cast<int64_t>(i);
                            }
                        }
                    }

                    // Search genitive form.
                    if ((dtfi.fmt_flags & format_flags::USE_GENITIVE_MONTH) != 0) {
                        int64_t temp_res = str.match_longest_words(dtfi.internal_get_leap_year_names(), max_match_str_len);
                        // We found a longer match in the genitive month name. Use this as the result.
                        // The result from match_longest_words is 0 ~ length of word array.
                        // So we increment the result by one to become the month value.
                        if (temp_res >= 0) {
                            result = temp_res + 1;
                        }
                    }

                    // Search leap year form.
                    if ((dtfi.fmt_flags & format_flags::USE_LEAP_YEAR_MONTH) != 0) {
                        int64_t temp_res = str.match_longest_words(dtfi.internal_get_leap_year_names(), max_match_str_len);
                        // We found a longer match in the leap year month name. Use this as the result.
                        // The result from match_longest_words is 0 ~ length of word array.
                        // So we increment the result by one to become the month value.
                        if (temp_res >= 0) {
                            result = temp_res + 1;
                        }
                    }
                }

                if (result > 0) {
                    str.index += (max_match_str_len - 1);
                    return true;
                }
                return false;
            }

            bool match_abbreviated_day_name(omni::internal::date_time_format::__dt_string& str, omni::internal::date_time_format::format_info& dtfi, int64_t& result)
            {
                int64_t max_match_str_len = 0;
                result = -1;
                if (str.get_next()) {
                    for (std::size_t i = omni::chrono::day_of_week::SUNDAY; i <= omni::chrono::day_of_week::SATURDAY; ++i) {
                        std::string search_str = omni::chrono::day::get_abbreviated_name(i);
                        std::size_t match_str_len = search_str.size();
                        if ( dtfi.has_spaces_in_day_names()
                                ? str.match_specified_words(search_str, false, match_str_len)
                                : str.match_specified_word(search_str)) {
                            if (static_cast<int64_t>(match_str_len) > max_match_str_len) {
                                max_match_str_len = static_cast<int64_t>(match_str_len);
                                result = static_cast<int64_t>(i);
                            }
                        }
                    }
                }
                if (result >= 0) {
                    str.index += max_match_str_len - 1;
                    return true;
                }
                return false;
            }

            bool match_day_name(omni::internal::date_time_format::__dt_string& str, omni::internal::date_time_format::format_info& dtfi, int64_t& result)
            {
                // Turkish (tr-TR) got day names with the same prefix.
                int64_t max_match_str_len = 0;
                result = -1;
                if (str.get_next()) {
                    for (std::size_t i = omni::chrono::day_of_week::SUNDAY; i <= omni::chrono::day_of_week::SATURDAY; ++i) {
                        std::string search_str = omni::chrono::day::get_name(i);
                        std::size_t match_str_len = search_str.size();
                        if ( dtfi.has_spaces_in_day_names()
                                ? str.match_specified_words(search_str, false, match_str_len)
                                : str.match_specified_word(search_str)) {
                            if (static_cast<int64_t>(match_str_len) > max_match_str_len) {
                                max_match_str_len = static_cast<int64_t>(match_str_len);
                                result = static_cast<int64_t>(i);
                            }
                        }
                    }
                }
                if (result >= 0) {
                    str.index += max_match_str_len - 1;
                    return true;
                }
                return false;
            }

            bool match_era_name(omni::internal::date_time_format::__dt_string& str, omni::internal::date_time_format::format_info& dtfi, int16_t& result)
            {
                OMNI_UNUSED(dtfi);
                if (str.get_next()) {
                    std::string search_str = OMNI_DATE_ERA_FW;
                    if (str.match_specified_word(search_str)) {
                        str.index += (search_str.size() - 1);
                        result = 0;
                        return true;
                    }
                    search_str = OMNI_DATE_ERA_ABBR_FW;
                    if (str.match_specified_word(search_str)) {
                        str.index += (search_str.size() - 1);
                        result = 0;
                        return true;
                    }
                }
                return false;
            }

            bool match_time_mark(omni::internal::date_time_format::__dt_string& str, omni::internal::date_time_format::format_info& dtfi, time_mark::enum_t& result)
            {
                result = omni::internal::date_time_format::time_mark::NOT_SET;
                // In some cultures have empty strings in AM/PM mark. E.g. af-ZA (0x0436), the AM mark is "", and PM mark is "nm".
                if (dtfi.am_designator.size() == 0) {
                    result = omni::internal::date_time_format::time_mark::AM;
                }
                if (dtfi.pm_designator.size() == 0) {
                    result = omni::internal::date_time_format::time_mark::PM;
                }

                if (str.get_next()) {
                    std::string search_str = dtfi.am_designator;
                    if (search_str.size() > 0) {
                        if (str.match_specified_word(search_str)) {
                            // Found an AM time mark with length > 0.
                            str.index += (search_str.size() - 1);
                            result = omni::internal::date_time_format::time_mark::AM;
                            return true;
                        }
                    }
                    search_str = dtfi.pm_designator;
                    if (search_str.size() > 0) {
                        if (str.match_specified_word(search_str)) {
                            // Found a PM time mark with length > 0.
                            str.index += (search_str.size() - 1);
                            result = omni::internal::date_time_format::time_mark::PM;
                            return true;
                        }
                    }
                    --str.index; // Undo the get_next call.
                }
                if (result != omni::internal::date_time_format::time_mark::NOT_SET) {
                    // If one of the AM/PM marks is empty string, return the result.
                    return true;
                }
                return false;
            }

            bool match_abbreviated_time_mark(omni::internal::date_time_format::__dt_string& str, omni::internal::date_time_format::format_info& dtfi, time_mark::enum_t& result)
            {
                // DEV_NOTE : the assumption here is that abbreviated time mark is the first
                // character of the AM/PM designator. If this invariant changes, we have to
                // change the code below.
                if (str.get_next()) {
                    if (str.get_char() == dtfi.am_designator[0]) {
                        result = omni::internal::date_time_format::time_mark::AM;
                        return true;
                    }
                    if (str.get_char() == dtfi.pm_designator[0]) {
                        result = omni::internal::date_time_format::time_mark::PM;
                        return true;
                    }
                }
                return false;
            }

            bool parse_fraction_exact(omni::internal::date_time_format::__dt_string& str, std::size_t max_len, double& result)
            {
                if (!str.get_next_digit()) {
                    --str.index;
                    return false;
                }
                result = static_cast<double>(str.get_digit());

                std::size_t digit_len = 1;
                for (; digit_len < max_len; ++digit_len) {
                    if (!str.get_next_digit()) {
                        --str.index;
                        break;
                    }
                    result = result * 10 + static_cast<double>(str.get_digit());
                }

                result = (result / std::pow(10, digit_len));
                return (digit_len == max_len);
            }

            bool parse_sign(omni::internal::date_time_format::__dt_string& str, bool& result)
            {
                if (!str.get_next()) {
                    // A sign symbol ('+' or '-') is expected. However, end of string is encountered.
                    return false;
                }
                char ch = str.get_char();
                if (ch == '+') {
                    result = true;
                    return true;
                } else if (ch == '-') {
                    result = false;
                    return true;
                }
                // A sign symbol ('+' or '-') is expected.
                return false;
            }

            bool parse_time_zone_offset(omni::internal::date_time_format::__dt_string& str, std::size_t len, omni::chrono::time_span& result)
            {
                bool is_positive = true;
                int64_t hour_offset;
                int64_t minute_offset = 0;

                switch (len) {
                    case 1:
                    case 2:
                        if (!omni::internal::date_time_format::date_time_parse::parse_sign(str, is_positive)) {
                            return false;
                        }
                        if (!omni::internal::date_time_format::parse_digits(str, static_cast<int64_t>(len), hour_offset)) {
                            return false;
                        }
                        break;
                    default:
                        if (!omni::internal::date_time_format::date_time_parse::parse_sign(str, is_positive)) {
                            return false;
                        }

                        // Parsing 1 digit will actually parse 1 or 2.
                        if (!omni::internal::date_time_format::parse_digits(str, 1, hour_offset)) {
                            return false;
                        }
                        // ':' is optional.
                        std::string col = ":";
                        if (str.match(col)) {
                            // Found ':'
                            if (!omni::internal::date_time_format::parse_digits(str, 2, minute_offset)) {
                                return false;
                            }
                        } else {
                            // Since we can not match ':', put the char back.
                            str.index--;
                            if (!omni::internal::date_time_format::parse_digits(str, 2, minute_offset)) {
                                return false;
                            }
                        }
                        break;
                }
                if (minute_offset < 0 || minute_offset >= 60) {
                    return false;
                }

                result = omni::chrono::time_span(hour_offset, minute_offset, 0);
                if (!is_positive) {
                    result = result.negate();
                }
                return true;
            }

            bool match_Word(omni::internal::date_time_format::__dt_string& str, const std::string& target)
            {
                std::size_t length = target.size();
                if (length > (str.value.size() - static_cast<std::size_t>(str.index))) {
                    return false;
                }

                if (omni::string::util::compare(str.value, static_cast<std::size_t>(str.index), length, target, 0, length, omni::string::compare_options::IGNORE_CASE) != 0) {
                    return false;
                }

                std::size_t next_char_index = static_cast<std::size_t>(str.index) + target.size();

                if (next_char_index < str.value.size()) {
                    char next_ch = str.value[next_char_index];
                    if (omni::char_util::is_letter(next_ch)) {
                        return false;
                    }
                }
                str.index = static_cast<int64_t>(next_char_index);
                if (str.index < str.len) {
                    str.current_char = str.value[static_cast<std::size_t>(str.index)];
                }

                return true;
            }

            bool get_time_zone_name(omni::internal::date_time_format::__dt_string& str)
            {
                return (omni::internal::date_time_format::date_time_parse::match_Word(str, OMNI_DATE_INTERNAL_GMT_NAME_FW) || omni::internal::date_time_format::date_time_parse::match_Word(str, OMNI_DATE_ZULU_NAME_FW));
            }

            bool try_parse_quote_string(const std::string format, std::size_t pos, std::stringstream& result, int64_t& return_value)
            {
                // DEV_NOTE : pos will be the index of the quote character in the 'format' string.
                std::size_t format_len = format.size();
                std::size_t begin_pos = pos;
                char quote_char = format[pos++]; // Get the character used to quote the following string.
                return_value = 0;

                bool found_quote = false;
                while (pos < format_len) {
                    char ch = format[pos++];
                    if (ch == quote_char) {
                        found_quote = true;
                        break;
                    } else if (ch == '\\') {
                        // The following are used to support escaped character.
                        // Escaped character is also supported in the quoted string.
                        // Therefore, someone can use a format like "'minute:' mm\"" to display:
                        // minute: 45"
                        // because the second double quote is escaped.
                        if (pos < format_len) {
                            result << format[pos++];
                            // result.Append(format[pos++]);
                        } else {
                            // This means that '\' is at the end of the formatting string.
                            return false;
                        }
                    } else {
                        result << ch;
                    }
                }

                if (!found_quote) {
                    // Here we can't find the matching quote.
                    return false;
                }

                // Return the character count including the begin/end quote characters and enclosed string.
                return_value = static_cast<int64_t>(pos - begin_pos);
                return true;
            }

            bool parse_by_format(omni::internal::date_time_format::__dt_string& str, omni::internal::date_time_format::__dt_string& format, omni::internal::date_time_format::date_time_parse::parsing_info& parseInfo, omni::internal::date_time_format::format_info& dtfi, omni::internal::date_time_format::parse_result& result)
            {
                int64_t token_len = 0;
                int64_t temp_year = 0;
                int64_t temp_month = 0;
                int64_t temp_day = 0;
                int64_t temp_dow = 0;
                int64_t temp_hour = 0;
                int64_t temp_minute = 0;
                int64_t temp_second = 0;
                double temp_fraction = 0;
                omni::internal::date_time_format::time_mark::enum_t tempTimeMark = omni::internal::date_time_format::time_mark::NOT_SET;

                char ch = format.get_char();

                switch (ch) {
                    case 'y': {
                        token_len = static_cast<int64_t>(format.get_repeat_count());
                        bool parseResult;
                        if (dtfi.has_force_two_digit_years) {
                            parseResult = omni::internal::date_time_format::parse_digits(str, 1, 4, temp_year);
                        } else {
                            if (token_len <= 2) {
                                parseInfo.use_two_digit_year = true;
                            }
                            parseResult = omni::internal::date_time_format::parse_digits(str, token_len, temp_year);
                        }
                        if (!parseResult && parseInfo.custom_number_parser) {
                            parseResult = false;
                        }
                        if (!parseResult) {
                            result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                            return false;
                        }
                        if (!omni::internal::date_time_format::date_time_parse::check_new_value(result.year, static_cast<int16_t>(temp_year), result)) {
                            return false;
                        }
                    } break;
                    case 'M': {
                        token_len = static_cast<int64_t>(format.get_repeat_count());
                        if (token_len <= 2) {
                            if (!omni::internal::date_time_format::parse_digits(str, token_len, temp_month)) {
                                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                                return false;
                            }
                        } else {
                            if (token_len == 3) {
                                if (!omni::internal::date_time_format::date_time_parse::match_abbreviated_month_name(str, dtfi, temp_month)) {
                                    result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                                    return false;
                                }
                            } else {
                                if (!omni::internal::date_time_format::date_time_parse::match_month_name(str, dtfi, temp_month)) {
                                    result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                                    return false;
                                }
                            }
                            result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::PARSED_MONTH_NAME);
                        }
                        if (!omni::internal::date_time_format::date_time_parse::check_new_value(result.month, static_cast<int16_t>(temp_month), result)) {
                            return false;
                        }
                    } break;
                    case 'd': {
                        // Day & Day of week
                        token_len = static_cast<int64_t>(format.get_repeat_count());
                        if (token_len <= 2) {
                            // "d" & "dd"
                            if (!omni::internal::date_time_format::parse_digits(str, token_len, temp_day)) {
                                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                                return false;
                            }
                            if (!omni::internal::date_time_format::date_time_parse::check_new_value(result.day, static_cast<int16_t>(temp_day), result)) {
                                return false;
                            }
                        } else {
                            if (token_len == 3) {
                                // "ddd"
                                if (!omni::internal::date_time_format::date_time_parse::match_abbreviated_day_name(str, dtfi, temp_dow)) {
                                    result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                                    return false;
                                }
                            } else {
                                // "dddd*"
                                if (!omni::internal::date_time_format::date_time_parse::match_day_name(str, dtfi, temp_dow)) {
                                    result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                                    return false;
                                }
                            }
                            if (!omni::internal::date_time_format::date_time_parse::check_new_value(parseInfo.day_of_week, static_cast<int16_t>(temp_dow), result)) {
                                return false;
                            }
                        }
                    } break;
                    case 'g': {
                        token_len = static_cast<int64_t>(format.get_repeat_count());
                        // Put the era value in result.era.
                        if (!omni::internal::date_time_format::date_time_parse::match_era_name(str, dtfi, result.era)) {
                            result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                            return false;
                        }
                    } break;
                    case 'h': {
                        parseInfo.use_hour_12 = true;
                        token_len = static_cast<int64_t>(format.get_repeat_count());
                        if (!omni::internal::date_time_format::parse_digits(str, (token_len < 2? 1 : 2), temp_hour)) {
                            result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                            return false;
                        }
                        if (!omni::internal::date_time_format::date_time_parse::check_new_value(result.hour, static_cast<int16_t>(temp_hour), result)) {
                            return false;
                        }
                    } break;
                    case 'H': {
                        token_len = static_cast<int64_t>(format.get_repeat_count());
                        if (!omni::internal::date_time_format::parse_digits(str, (token_len < 2? 1 : 2), temp_hour)) {
                            result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                            return false;
                        }
                        if (!omni::internal::date_time_format::date_time_parse::check_new_value(result.hour, static_cast<int16_t>(temp_hour), result)) {
                            return false;
                        }
                    } break;
                    case 'm': {
                        token_len = static_cast<int64_t>(format.get_repeat_count());
                        if (!omni::internal::date_time_format::parse_digits(str, (token_len < 2? 1 : 2), temp_minute)) {
                            result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                            return false;
                        }
                        if (!omni::internal::date_time_format::date_time_parse::check_new_value(result.minute, static_cast<int16_t>(temp_minute), result)) {
                            return false;
                        }
                    } break;
                    case 's': {
                        token_len = static_cast<int64_t>(format.get_repeat_count());
                        if (!omni::internal::date_time_format::parse_digits(str, (token_len < 2? 1 : 2), temp_second)) {
                            result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                            return false;
                        }
                        if (!omni::internal::date_time_format::date_time_parse::check_new_value(result.second, static_cast<int16_t>(temp_second), result)) {
                            return false;
                        }
                    } break;
                    case 'f':
                    case 'F': {
                        token_len = static_cast<int64_t>(format.get_repeat_count());
                        if (token_len <= OMNI_DATE_INTERNAL_MAX_SECONDS_FRACTION_DIGITS_FW) {
                            if (!omni::internal::date_time_format::date_time_parse::parse_fraction_exact(str, static_cast<std::size_t>(token_len), temp_fraction)) {
                                if (ch == 'f') {
                                    result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                                    return false;
                                }
                            }
                            if (result.fraction < 0) {
                                result.fraction = temp_fraction;
                            } else {
                                if (!omni::math::are_equal(temp_fraction, result.fraction)) {
                                    result.set_failure(omni::chrono::date_time_parse_failure::FORMAT_WITH_PARAMETER, "Format_RepeatDateTimePattern");
                                    return false;
                                }
                            }
                        } else {
                            result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                            return false;
                        }
                    } break;
                    case 't': {
                        // AM/PM designator
                        token_len = static_cast<int64_t>(format.get_repeat_count());
                        if (token_len == 1) {
                            if (!omni::internal::date_time_format::date_time_parse::match_abbreviated_time_mark(str, dtfi, tempTimeMark)) {
                                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                                return false;
                            }
                        } else {
                            if (!omni::internal::date_time_format::date_time_parse::match_time_mark(str, dtfi, tempTimeMark)) {
                                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                                return false;
                            }
                        }

                        if (parseInfo.time_mark == time_mark::NOT_SET) {
                            parseInfo.time_mark = tempTimeMark;
                        }
                        else {
                            if (parseInfo.time_mark != tempTimeMark) {
                                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT_WITH_PARAMETER, "Format_RepeatDateTimePattern");
                                return false;
                            }
                        }
                    } break;
                    case 'z': {
                        // timezone offset
                        token_len = static_cast<int64_t>(format.get_repeat_count());
                        {
                            omni::chrono::time_span tempTimeZoneOffset = omni::chrono::time_span::zero();
                            if (!omni::internal::date_time_format::date_time_parse::parse_time_zone_offset(str, static_cast<std::size_t>(token_len), tempTimeZoneOffset)) {
                                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                                return false;
                            }
                            if ((result.flags & omni::internal::date_time_format::parse_flags::TIMEZONE_USED) != 0 && tempTimeZoneOffset != result.time_zone_offset) {
                                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT_WITH_PARAMETER, "Format_RepeatDateTimePattern");
                                return false;
                            }
                            result.time_zone_offset = tempTimeZoneOffset;
                            result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::TIMEZONE_USED);
                        }
                    } break;
                    case 'Z': {
                        if ((result.flags & omni::internal::date_time_format::parse_flags::TIMEZONE_USED) != 0 && result.time_zone_offset != omni::chrono::time_span::zero()) {
                            result.set_failure(omni::chrono::date_time_parse_failure::FORMAT_WITH_PARAMETER, "Format_RepeatDateTimePattern");
                            return false;
                        }

                        result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::TIMEZONE_USED);
                        result.time_zone_offset = omni::chrono::time_span::zero();
                        result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::TIMEZONE_UTC);

                        // The updating of the indexes is to reflect that parse_exact MatchXXX methods assume that
                        // they need to increment the index and Parse GetXXX do not. Since we are calling a Parse
                        // method from inside parse_exact we need to adjust this. Long term, we should try to
                        // eliminate this discrepancy.
                        str.index++;
                        if (!omni::internal::date_time_format::date_time_parse::get_time_zone_name(str)) {
                            result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                            return false;
                        }
                        str.index--;
                    } break;
                    case 'K': {
                        // This should parse either as a blank, the 'Z' character or a local offset like "-07:00"
                        if (str.match('Z')) {
                            if ((result.flags & omni::internal::date_time_format::parse_flags::TIMEZONE_USED) != 0 && result.time_zone_offset != omni::chrono::time_span::zero()) {
                                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT_WITH_PARAMETER, "Format_RepeatDateTimePattern");
                                return false;
                            }

                            result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::TIMEZONE_USED);
                            result.time_zone_offset = omni::chrono::time_span::zero();
                            result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::TIMEZONE_UTC);
                        }
                        else if (str.match('+') || str.match('-')) {
                            --str.index; // Put the character back for the parser
                            omni::chrono::time_span tempTimeZoneOffset = omni::chrono::time_span::zero();
                            if (!omni::internal::date_time_format::date_time_parse::parse_time_zone_offset(str, 3, tempTimeZoneOffset)) {
                                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                                return false;
                            }
                            if ((result.flags & omni::internal::date_time_format::parse_flags::TIMEZONE_USED) != 0 && tempTimeZoneOffset != result.time_zone_offset) {
                                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT_WITH_PARAMETER, "Format_RepeatDateTimePattern");
                                return false;
                            }
                            result.time_zone_offset = tempTimeZoneOffset;
                            result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::TIMEZONE_USED);
                        }
                        // Otherwise it is unspecified and we consume no characters
                    } break;
                    case ':': {
                        // We match the separator in time pattern with the character in the time string if both equal to ':' or the date separator is matching the characters in the date string
                        // We have to exclude the case when the time separator is more than one character and starts with ':' something like "::" for instance.
                        if (((dtfi.time_separator.size() > 1 && dtfi.time_separator[0] == ':') || !str.match(':')) &&
                            !str.match(dtfi.time_separator)) {
                            // A time separator is expected.
                            result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                            return false;
                        }
                    } break;
                    case '/': {
                        // We match the separator in date pattern with the character in the date string if both equal to '/' or the date separator is matching the characters in the date string
                        // We have to exclude the case when the date separator is more than one character and starts with '/' something like "//" for instance.
                        if (((dtfi.date_separator.size() > 1 && dtfi.date_separator[0] == '/') || !str.match('/')) &&
                            !str.match(dtfi.date_separator))
                        {
                            // A date separator is expected.
                            result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                            return false;
                        }
                    } break;
                    case '\"':
                    case '\'': {
                        std::stringstream enquotedString;
                        // Use ParseQuoteString so that we can handle escape characters within the quoted string.
                        if (!omni::internal::date_time_format::date_time_parse::try_parse_quote_string(format.value, static_cast<std::size_t>(format.index), enquotedString, token_len)) {
                            result.set_failure(omni::chrono::date_time_parse_failure::FORMAT_WITH_PARAMETER, "Format_BadQuote");
                            return false;
                        }
                        format.index += token_len - 1;

                        // Some cultures uses space in the quoted string. E.g. Spanish has long date format as:
                        // "dddd, dd' de 'MMMM' de 'yyyy". When inner spaces flag is set, we should skip whitespaces if there is space
                        // in the quoted string.
                        std::string quotedStr = enquotedString.str();

                        for (std::size_t i = 0; i < quotedStr.size(); ++i) {
                            if (quotedStr[i] == ' ' && parseInfo.allow_inner_ws) {
                                str.skip_white_spaces();
                            } else if (!str.match(quotedStr[i])) {
                                // Can not find the matching quoted string.
                                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                                return false;
                            }
                        }

                        // The "r" and "u" formats incorrectly quoted 'GMT' and 'Z', respectively. We cannot
                        // correct this mistake for DateTime.parse_exact for compatibility reasons, but we can
                        // fix it for DateTimeOffset.parse_exact as DateTimeOffset has not been publicly released
                        // with this issue.
                        if ((result.flags & omni::internal::date_time_format::parse_flags::CAPTURE_OFFSET) != 0) {
                            if ((result.flags & omni::internal::date_time_format::parse_flags::RFC1123_PATTERN) != 0 && quotedStr == OMNI_DATE_INTERNAL_GMT_NAME_FW) {
                                result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::TIMEZONE_USED);
                                result.time_zone_offset = omni::chrono::time_span::zero();
                            }
                            else if ((result.flags & omni::internal::date_time_format::parse_flags::UTC_SORT_PATTERN) != 0 && quotedStr == OMNI_DATE_ZULU_NAME_FW) {
                                result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::TIMEZONE_USED);
                                result.time_zone_offset = omni::chrono::time_span::zero();
                            }
                        }

                    } break;
                    case '%': {
                        // Skip this so we can get to the next pattern character.
                        // Used in case like "%d", "%y"

                        // Make sure the next character is not a '%' again.
                        if (static_cast<std::size_t>(format.index) >= format.value.size() - 1 || format.value[static_cast<std::size_t>(format.index + 1)] == '%') {
                            result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadFormatSpecifier");
                            return false;
                        }
                    } break;
                    case '\\': {
                        // Escape character. For example, "\d".
                        // Get the next character in format, and see if we can
                        // find a match in str.
                        if (format.get_next()) {
                            if (!str.match(format.get_char())) {
                                // Can not find a match for the escaped character.
                                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                                return false;
                            }
                        } else {
                            result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadFormatSpecifier");
                            return false;
                        }
                    } break;
                    case '.': {
                        if (!str.match(ch)) {
                            if (format.get_next()) {
                                // If we encounter the pattern ".F", and the dot is not present, it is an optional
                                // second fraction and we can skip this format.
                                if (format.match('F')) {
                                    format.get_repeat_count();
                                    break;
                                }
                            }
                            result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                            return false;
                        }
                    } break;
                    default: {
                        if (ch == ' ') {
                            if (parseInfo.allow_inner_ws) {
                                // Skip whitespaces if AllowInnerWhite.
                                // Do nothing here.
                            } else {
                                if (!str.match(ch)) {
                                    // If the space does not match, and trailing space is allowed, we do
                                    // one more step to see if the next format character can lead to
                                    // successful parsing.
                                    // This is used to deal with special case that a empty string can match
                                    // a specific pattern.
                                    // The example here is af-ZA, which has a time format like "hh:mm:ss tt". However,
                                    // its AM symbol is "" (empty string). If allow_trailing_ws is used, and time is in
                                    // the AM, we will trim the whitespaces at the end, which will lead to a failure
                                    // when we are trying to match the space before "tt".
                                    if (parseInfo.allow_trailing_ws) {
                                        if (format.get_next()) {
                                            if (omni::internal::date_time_format::date_time_parse::parse_by_format(str, format, parseInfo, dtfi, result)) {
                                                return true;
                                            }
                                        }
                                    }
                                    result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                                    return false;
                                }
                                // Found a match.
                            }
                        } else {
                            std::string gmnm = OMNI_DATE_INTERNAL_GMT_NAME_FW;
                            if (format.match_specified_word(gmnm)) {
                                format.index += (gmnm.size() - 1);
                                // Found GMT string in format. This means the DateTime string
                                // is in GMT timezone.
                                result.flags = static_cast<parse_flags::enum_t>(result.flags | omni::internal::date_time_format::parse_flags::TIMEZONE_USED);
                                result.time_zone_offset = omni::chrono::time_span::zero();
                                if (!str.match(gmnm)) {
                                    result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                                    return false;
                                }
                            } else if (!str.match(ch)) {
                                // ch is expected.
                                result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                                return false;
                            }
                        }
                    } break;
                } // switch
                return true;
            }

            bool do_string_parse(const std::string& s, std::string format_param, const omni::chrono::date_time_styles& styles, omni::internal::date_time_format::format_info& dtfi, omni::internal::date_time_format::parse_result& result)
            {
                omni::internal::date_time_format::date_time_parse::parsing_info parseInfo;
                parseInfo.init();

                // parseInfo.calendar = dtfi.Calendar;
                parseInfo.allow_inner_ws = ((styles & omni::chrono::date_time_styles::ALLOW_INNER_WHITE) != 0);
                parseInfo.allow_trailing_ws = ((styles & omni::chrono::date_time_styles::ALLOW_TRAILING_WHITE) != 0);

                // We need the original values of the following two below.
                std::string originalFormat = format_param;

                if (format_param.size() == 1) {
                    if (((result.flags & omni::internal::date_time_format::parse_flags::CAPTURE_OFFSET) != 0) && format_param[0] == 'U') {
                        // The 'U' format is not allowed for DateTimeOffset
                        result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadFormatSpecifier");
                        return false;
                    }
                    format_param = omni::internal::date_time_format::date_time_parse::expand_predefined_format(format_param, dtfi, parseInfo, result);
                }

                bool is_time_only = false;

                // Reset these values to negative one so that we could throw exception
                // if we have parsed every item twice.
                result.hour = result.minute = result.second = -1;

                omni::internal::date_time_format::__dt_string format(format_param, dtfi, false);
                omni::internal::date_time_format::__dt_string str(s, dtfi, false);

                if (parseInfo.allow_trailing_ws) {
                    // Trim trailing spaces if AllowTrailingWhite.
                    format.trim_tail();
                    format.remove_trailing_in_quote_spaces();
                    str.trim_tail();
                }

                if ((styles & omni::chrono::date_time_styles::ALLOW_LEADING_WHITE) != 0) {
                    format.skip_white_spaces();
                    format.remove_leading_in_quote_spaces();
                    str.skip_white_spaces();
                }

                //
                // Scan every character in format and match the pattern in str.
                //
                while (format.get_next()) {
                    // We trim inner spaces here, so that we will not eat trailing spaces when
                    // AllowTrailingWhite is not used.
                    if (parseInfo.allow_inner_ws) {
                        str.skip_white_spaces();
                    }
                    if (!omni::internal::date_time_format::date_time_parse::parse_by_format(str, format, parseInfo, dtfi, result)) {
                        return false;
                    }
                }

                if (static_cast<std::size_t>(str.index) < str.value.size() - 1) {
                    // There are still remaining character in str.
                    result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                    return false;
                }

                if (parseInfo.use_two_digit_year && ((dtfi.fmt_flags & format_flags::USE_HEBREW_RULE) == 0)) {
                    // A two digit year value is expected. Check if the parsed year value is valid.
                    if (result.year >= 100) {
                        result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                        return false;
                    }
                    if ((result.year < 1) || (result.year > OMNI_DATE_MAX_YEAR)) {
                        result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                        return false;
                    }
                    result.year = static_cast<int16_t>(omni::chrono::date_time::to_four_digit_year(static_cast<uint16_t>(result.year)));
                }

                
                if (parseInfo.use_hour_12) {
                    if (parseInfo.time_mark == date_time_format::time_mark::NOT_SET) {
                        // hh is used, but no AM/PM designator is specified.
                        // Assume the time is AM.
                        // Don't throw exceptions in here because it is very confusing for the caller.
                        // I always got confused myself when I use "hh:mm:ss" to parse a time string,
                        // and parse_exact() throws on me (because I didn't use the 24-hour clock 'HH').
                        parseInfo.time_mark = date_time_format::time_mark::AM;
                    }
                    if (result.hour > 12) {
                        // AM/PM is used, but the value for HH is too big.
                        result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                        return false;
                    }
                    if (parseInfo.time_mark == date_time_format::time_mark::AM) {
                        if (result.hour == 12) {
                            result.hour = 0;
                        }
                    } else {
                        result.hour = (result.hour == 12) ? 12 : result.hour + 12;
                    }
                } else {
                    // Military (24-hour time) mode
                    //
                    // AM cannot be set with a 24-hour time like 17:15.
                    // PM cannot be set with a 24-hour time like 03:15.
                    if ((parseInfo.time_mark == date_time_format::time_mark::AM && result.hour >= 12) ||
                        (parseInfo.time_mark == date_time_format::time_mark::PM && result.hour < 12))
                    {
                        result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                        return false;
                    }
                }


                // Check if the parsed string only contains hour/minute/second values.
                is_time_only = (result.year == -1 && result.month == -1 && result.day == -1);
                if (!omni::internal::date_time_format::check_default_date_time(result, styles)) {
                    return false;
                }

                if (!omni::chrono::date_time::try_create(static_cast<uint16_t>(result.year), static_cast<uint16_t>(result.month), static_cast<uint16_t>(result.day), static_cast<uint16_t>(result.hour), static_cast<uint16_t>(result.minute), static_cast<uint16_t>(result.second), 0, result.parsed_date)) {
                    result.set_failure(omni::chrono::date_time_parse_failure::FORMAT_BAD_DATE_TIME_CALENDAR, "Format_BadDateTimeCalendar");
                    return false;
                }
                if (result.fraction > 0) {
                    result.parsed_date = result.parsed_date.add_ticks(static_cast<int64_t>(omni::math::round(result.fraction * OMNI_TICKS_PER_SECOND)));
                }

                // We have to check day of week before we adjust to the time zone.
                // It is because the value of day of week may change after adjusting
                // to the time zone.
                if (parseInfo.day_of_week != -1) {
                    // Check if day of week is correct.
                    if (parseInfo.day_of_week != static_cast<int64_t>(result.parsed_date.day_of_week())) {
                        result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDayOfWeek");
                        return false;
                    }
                }


                if (!omni::internal::date_time_format::determine_time_zone_adjustments(result, styles, is_time_only)) {
                    return false;
                }
                return true;
            }

            bool try_parse_exact(const std::string& s, const std::string& format, omni::internal::date_time_format::format_info& dtfi, const omni::chrono::date_time_styles& style, omni::internal::date_time_format::parse_result& result)
            {
                if (s.empty()) {
                    result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadDateTime");
                    return false;
                }
                if (format.empty()) {
                    result.set_failure(omni::chrono::date_time_parse_failure::FORMAT, "Format_BadFormatSpecifier");
                    return false;
                }
                return omni::internal::date_time_format::date_time_parse::do_string_parse(s, format, style, dtfi, result);
            }

            bool try_parse_exact(const std::string& s, const std::string& format, omni::internal::date_time_format::format_info& dtfi, const omni::chrono::date_time_styles& style, omni::chrono::date_time& result)
            {
                omni::internal::date_time_format::parse_result result_data; // The buffer to store the parsing result.
                if (omni::internal::date_time_format::date_time_parse::try_parse_exact(s, format, dtfi, style, result_data)) {
                    result = result_data.parsed_date;
                    return true;
                }
                result = omni::chrono::date_time::min_value();
                return false;
            }

            bool try_parse_exact(const std::string& s, const std::string& format, omni::internal::date_time_format::format_info& dtfi, const omni::chrono::date_time_styles& style, omni::chrono::date_time& result, omni::chrono::date_time_parse_failure& fail_reason)
            {
                omni::internal::date_time_format::parse_result result_data; // The buffer to store the parsing result.
                fail_reason = omni::chrono::date_time_parse_failure::NONE;
                if (omni::internal::date_time_format::date_time_parse::try_parse_exact(s, format, dtfi, style, result_data)) {
                    result = result_data.parsed_date;
                    return true;
                }
                fail_reason = result_data.failure;
                result = omni::chrono::date_time::min_value();
                return false;
            }
            
            omni::chrono::date_time parse_exact(const std::string& s, const std::string& format, omni::internal::date_time_format::format_info& dtfi, const omni::chrono::date_time_styles& style)
            {
                omni::internal::date_time_format::parse_result result; // The buffer to store the parsing result.
                if (omni::internal::date_time_format::date_time_parse::try_parse_exact(s, format, dtfi, style, result)) {
                    return result.parsed_date;
                }
                OMNI_ERR_RETV_FW("Invalid date time string detected", omni::exceptions::invalid_parse(), omni::chrono::date_time())
            }
        }
    }
} }