(C) Zeriph Enterprises
omni/io.hpp
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:
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.
*/
 #if !defined(OMNI_IO_HPP)
#define OMNI_IO_HPP 1

#include <omni/defs/global.hpp>
#include <omni/strings.hpp>
#include <omni/string/util.hpp>
#include <omni/types/fstream_t.hpp>
#include <omni/sequence.hpp>
#include <omni/stack_buffer.hpp>
#include <omni/defs/file_def.hpp>
#define OMNI_IO_FILE_RW_FW 1
#include <omni/xx/io/file_rw.hxx>

/*
    TODO: add this function ??

    maybe instead of std::string, return uint64_t that can then be used in a date_time class??

    std::string last_write_time(const std::string& file)
    {
        if (omni::io::file::exists(file)) {
            struct stat attr;
            char date[255] = {0};
            std::string tmp, utc;
            int iutc;
            memset(date, 0, sizeof(date));
            stat(file.c_str(), &attr);
            strftime(date, 255, "%z", localtime(&(attr.st_ctime)));
            tmp = std::string(date);
            memset(date, 0, sizeof(date));
            if (!omni::char_util::is_digit(tmp[0])) {
                utc = tmp.substr(0, 1);
                tmp = tmp.substr(1);
            }
            if (omni::string::is_numeric(tmp)) {
                iutc = omni::string::util::to_type<int>(tmp);
                iutc /= 100;
                if (iutc < 10) {
                    utc += "0" + omni::string::to_string(iutc);
                } else {
                    utc += omni::string::to_string(iutc);
                }
            }
            strftime(date, 255, "%Z", localtime(&(attr.st_ctime)));
            tmp = std::string(date);
            memset(date, 0, sizeof(date));
            utc = " (" + utc + " " + tmp + ")";
            strftime(date, 255, "%m/%d/%Y %H:%M:%S", localtime(&(attr.st_ctime)));
            return std::string(date) + utc;
        }
        return "00/00/0000 00:00:00 (+0 UTC)";
    }
*/
namespace omni {
    namespace io {
        namespace cfile {
            bool copy(const std::string& file, const std::string& new_name, const omni::io::options& io_ops);
            bool copy(const std::string& file, const std::string& new_name);
            bool create(const std::string& file, const omni::io::options& io_ops);
            bool create(const std::string& file);
            bool exists(const std::string& file);
            bool exist(const std::string& file);
            std::string get_contents(const std::string& file);
            uint64_t get_size(const std::string& file);
            bool move(const std::string& file, const std::string& new_name, const omni::io::options& io_ops);
            bool move(const std::string& file, const std::string& new_name);
            bool rename(const std::string& file, const std::string& new_name, const omni::io::options& io_ops);
            bool rename(const std::string& file, const std::string& new_name);
            uint64_t read(const std::string& file, std::string& buffer);
            // std::vector/deque/array/list/etc.
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read(const std::string& file, std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, std::ios_base::beg);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read(const char (&file)[SZ], std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, 0, 0, std::ios_base::beg);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read(const std::string& file, std_seq_t<T, std_allocator_t >& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, file_offset, offset_direction);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read(const char (&file)[SZ], std_seq_t<T, std_allocator_t >& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, 0, file_offset, offset_direction);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read(const std::string& file, std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, std_seq_t, T, std_allocator_t >(file, buffer, length, file_offset, offset_direction);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read(const char (&file)[SZ], std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, length, file_offset, offset_direction);
            }
            // char buf[]/wchar_t buf[]/uintX_t buf[]
            template < typename T, std::size_t SZ >
            uint64_t read(const std::string& file, T (&buffer)[SZ])
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(file, buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read(const char (&file)[FSZ], T (&buffer)[SZ])
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(std::string(file), buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < typename T, std::size_t SZ >
            uint64_t read(const std::string& file, T (&buffer)[SZ], std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(file, buffer, 0, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read(const char (&file)[FSZ], T (&buffer)[SZ], std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(std::string(file), buffer, 0, 0, file_offset, offset_direction);
            }
            template < typename T, std::size_t SZ >
            uint64_t read(const std::string& file, T (&buffer)[SZ], uint64_t length, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(file, buffer, length, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read(const char (&file)[FSZ], T (&buffer)[SZ], uint64_t length, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(std::string(file), buffer, length, 0, file_offset, offset_direction);
            }
            template < typename T, std::size_t SZ >
            uint64_t read(const std::string& file, T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(file, buffer, length, buffer_offset, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read(const char (&file)[FSZ], T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(std::string(file), buffer, length, buffer_offset, file_offset, offset_direction);
            }
            // omni::stack_buffer
            template < typename T, uint16_t SZ >
            uint64_t read(const std::string& file, omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(file, buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read(const char (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(std::string(file), buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < typename T, uint16_t SZ >
            uint64_t read(const std::string& file, omni::stack_buffer<T, SZ>& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(file, buffer, 0, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read(const char (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(std::string(file), buffer, 0, 0, file_offset, offset_direction);
            }
            template < typename T, uint16_t SZ >
            uint64_t read(const std::string& file, omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(file, buffer, length, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read(const char (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(std::string(file), buffer, length, 0, file_offset, offset_direction);
            }
            template < typename T, uint16_t SZ >
            uint64_t read(const std::string& file, omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(file, buffer, length, buffer_offset, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read(const char (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(std::string(file), buffer, length, buffer_offset, file_offset, offset_direction);
            }
            // read_element
            // std::vector/deque/array/list/etc.
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read_element(const std::string& file, std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, std::ios_base::beg);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read_element(const char (&file)[SZ], std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, 0, 0, std::ios_base::beg);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read_element(const std::string& file, std_seq_t<T, std_allocator_t >& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, file_offset, offset_direction);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read_element(const char (&file)[SZ], std_seq_t<T, std_allocator_t >& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, 0, file_offset, offset_direction);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read_element(const std::string& file, std_seq_t<T, std_allocator_t >& buffer, uint64_t elements, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, std_seq_t, T, std_allocator_t >(file, buffer, elements, file_offset, offset_direction);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read_element(const char (&file)[SZ], std_seq_t<T, std_allocator_t >& buffer, uint64_t elements, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, elements, file_offset, offset_direction);
            }
            // char buf[]/wchar_t buf[]/uintX_t buf[]
            template < typename T, std::size_t SZ >
            uint64_t read_element(const std::string& file, T (&buffer)[SZ])
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(file, buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read_element(const char (&file)[FSZ], T (&buffer)[SZ])
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(std::string(file), buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < typename T, std::size_t SZ >
            uint64_t read_element(const std::string& file, T (&buffer)[SZ], std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(file, buffer, 0, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read_element(const char (&file)[FSZ], T (&buffer)[SZ], std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(std::string(file), buffer, 0, 0, file_offset, offset_direction);
            }
            template < typename T, std::size_t SZ >
            uint64_t read_element(const std::string& file, T (&buffer)[SZ], uint64_t elements, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(file, buffer, elements, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read_element(const char (&file)[FSZ], T (&buffer)[SZ], uint64_t elements, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(std::string(file), buffer, elements, 0, file_offset, offset_direction);
            }
            template < typename T, std::size_t SZ >
            uint64_t read_element(const std::string& file, T (&buffer)[SZ], uint64_t elements, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(file, buffer, elements, buffer_offset, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read_element(const char (&file)[FSZ], T (&buffer)[SZ], uint64_t elements, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(std::string(file), buffer, elements, buffer_offset, file_offset, offset_direction);
            }
            // omni::stack_buffer
            template < typename T, uint16_t SZ >
            uint64_t read_element(const std::string& file, omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(file, buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read_element(const char (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(std::string(file), buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < typename T, uint16_t SZ >
            uint64_t read_element(const std::string& file, omni::stack_buffer<T, SZ>& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(file, buffer, 0, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read_element(const char (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(std::string(file), buffer, 0, 0, file_offset, offset_direction);
            }
            template < typename T, uint16_t SZ >
            uint64_t read_element(const std::string& file, omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(file, buffer, elements, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read_element(const char (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(std::string(file), buffer, elements, 0, file_offset, offset_direction);
            }
            template < typename T, uint16_t SZ >
            uint64_t read_element(const std::string& file, omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(file, buffer, elements, buffer_offset, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read_element(const char (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(std::string(file), buffer, elements, buffer_offset, file_offset, offset_direction);
            }
            template < typename T >
            uint64_t unsafe_read_element(const std::string& file, T* buffer, uint64_t elements)
            {
                return omni::io::file_internal::unsafe_rd_el< std::string, std::ifstream, T >(file, buffer, elements);
            }
            uint64_t unsafe_read(const std::string& file, char* buffer, uint64_t length);
            uint64_t unsafe_read(const std::string& file, wchar_t* buffer, uint64_t length);
            uint64_t unsafe_read(const std::string& file, uint8_t* buffer, uint64_t length);
            uint64_t unsafe_read(const std::string& file, int8_t* buffer, uint64_t length);
            bool remove(const std::string& file);
            #if defined(OMNI_NON_PORTABLE)
                bool set_size(const std::string& file, uint64_t size);
            #endif
            uint64_t write(const std::string& file, const std::string& buffer, bool append);
            uint64_t write(const std::string& file, const std::string& buffer);
            // std::vector/deque/array/list/etc.
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const std::string& file, const std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, false, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const char (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, 0, 0, false, false);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const std::string& file, const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(file, buffer, length, buffer_offset, false, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const char (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, length, buffer_offset, false, false);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const std::string& file, const std_seq_t<T, std_allocator_t >& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, append, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const char (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, 0, 0, append, false);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const std::string& file, const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(file, buffer, length, buffer_offset, append, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const char (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, length, buffer_offset, append, false);
            }
            // char buf[]/wchar_t buf[]/uintX_t buf[]
            template < typename T, std::size_t SZ >
            uint64_t write(const std::string& file, const T (&buffer)[SZ])
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, 0, 0, false, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write(const char (&file)[FSZ], const T (&buffer)[SZ])
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, 0, 0, false, false);
            }
            template < typename T, std::size_t SZ >
            uint64_t write(const std::string& file, const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, length, buffer_offset, false, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write(const char (&file)[FSZ], const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, length, buffer_offset, false, false);
            }
            template < typename T, std::size_t SZ >
            uint64_t write(const std::string& file, const T (&buffer)[SZ], bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, 0, 0, append, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write(const char (&file)[FSZ], const T (&buffer)[SZ], bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, 0, 0, append, false);
            }
            template < typename T, std::size_t SZ >
            uint64_t write(const std::string& file, const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, length, buffer_offset, append, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write(const char (&file)[FSZ], const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, length, buffer_offset, append, false);
            }
            // omni::stack_buffer
            template < typename T, uint16_t SZ >
            uint64_t write(const std::string& file, const omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, 0, 0, false, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write(const char (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, 0, 0, false, false);
            }
            template < typename T, uint16_t SZ >
            uint64_t write(const std::string& file, const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, length, buffer_offset, false, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write(const char (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, length, buffer_offset, false, false);
            }
            template < typename T, uint16_t SZ >
            uint64_t write(const std::string& file, const omni::stack_buffer<T, SZ>& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, 0, 0, append, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write(const char (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, 0, 0, append, false);
            }
            template < typename T, uint16_t SZ >
            uint64_t write(const std::string& file, const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, length, buffer_offset, append, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write(const char (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, length, buffer_offset, append, false);
            }
            // write_element
            // std::vector/deque/array/list/etc.
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const std::string& file, const std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, false, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const char (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, 0, 0, false, false);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const std::string& file, const std_seq_t<T, std_allocator_t >& buffer, uint64_t elements, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(file, buffer, elements, buffer_offset, false, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const char (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, uint64_t elements, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, elements, buffer_offset, false, false);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const std::string& file, const std_seq_t<T, std_allocator_t >& buffer, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, append, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const char (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, 0, 0, append, false);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const std::string& file, const std_seq_t<T, std_allocator_t >& buffer, uint64_t elements, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(file, buffer, elements, buffer_offset, append, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const char (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, uint64_t elements, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, elements, buffer_offset, append, false);
            }
            // char buf[]/wchar_t buf[]/uintX_t buf[]
            template < typename T, std::size_t SZ >
            uint64_t write_element(const std::string& file, const T (&buffer)[SZ])
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(file, buffer, 0, 0, false, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_element(const char (&file)[FSZ], const T (&buffer)[SZ])
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, 0, 0, false, false);
            }
            template < typename T, std::size_t SZ >
            uint64_t write_element(const std::string& file, const T (&buffer)[SZ], uint64_t elements, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(file, buffer, elements, buffer_offset, false, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_element(const char (&file)[FSZ], const T (&buffer)[SZ], uint64_t elements, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, elements, buffer_offset, false, false);
            }
            template < typename T, std::size_t SZ >
            uint64_t write_element(const std::string& file, const T (&buffer)[SZ], bool append)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(file, buffer, 0, 0, append, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_element(const char (&file)[FSZ], const T (&buffer)[SZ], bool append)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, 0, 0, append, false);
            }
            template < typename T, std::size_t SZ >
            uint64_t write_element(const std::string& file, const T (&buffer)[SZ], uint64_t elements, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(file, buffer, elements, buffer_offset, append, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_element(const char (&file)[FSZ], const T (&buffer)[SZ], uint64_t elements, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, elements, buffer_offset, append, false);
            }
            // omni::stack_buffer
            template < typename T, uint16_t SZ >
            uint64_t write_element(const std::string& file, const omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(file, buffer, 0, 0, false, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_element(const char (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, 0, 0, false, false);
            }
            template < typename T, uint16_t SZ >
            uint64_t write_element(const std::string& file, const omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(file, buffer, elements, buffer_offset, false, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_element(const char (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, elements, buffer_offset, false, false);
            }
            template < typename T, uint16_t SZ >
            uint64_t write_element(const std::string& file, const omni::stack_buffer<T, SZ>& buffer, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(file, buffer, 0, 0, append, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_element(const char (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, 0, 0, append, false);
            }
            template < typename T, uint16_t SZ >
            uint64_t write_element(const std::string& file, const omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(file, buffer, elements, buffer_offset, append, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_element(const char (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, elements, buffer_offset, append, false);
            }

            uint64_t write_line(const std::string& file, const std::string& buffer, bool append);
            uint64_t write_line(const std::string& file, const std::string& buffer);
            // std::vector/deque/array/list/etc.
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const std::string& file, const std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, false, true);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const char (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, 0, 0, false, true);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const std::string& file, const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(file, buffer, length, buffer_offset, false, true);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const char (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, length, buffer_offset, false, true);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const std::string& file, const std_seq_t<T, std_allocator_t >& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, append, true);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const char (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, 0, 0, append, true);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const std::string& file, const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(file, buffer, length, buffer_offset, append, true);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const char (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, length, buffer_offset, append, true);
            }
            // char buf[]/wchar_t buf[]/uintX_t buf[]
            template < typename T, std::size_t SZ >
            uint64_t write_line(const std::string& file, const T (&buffer)[SZ])
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, 0, 0, false, true);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_line(const char (&file)[FSZ], const T (&buffer)[SZ])
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, 0, 0, false, true);
            }
            template < typename T, std::size_t SZ >
            uint64_t write_line(const std::string& file, const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, length, buffer_offset, false, true);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_line(const char (&file)[FSZ], const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, length, buffer_offset, false, true);
            }
            template < typename T, std::size_t SZ >
            uint64_t write_line(const std::string& file, const T (&buffer)[SZ], bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, 0, 0, append, true);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_line(const char (&file)[FSZ], const T (&buffer)[SZ], bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, 0, 0, append, true);
            }
            template < typename T, std::size_t SZ >
            uint64_t write_line(const std::string& file, const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, length, buffer_offset, append, true);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_line(const char (&file)[FSZ], const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, length, buffer_offset, append, true);
            }
            // omni::stack_buffer
            template < typename T, uint16_t SZ >
            uint64_t write_line(const std::string& file, const omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, 0, 0, false, true);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_line(const char (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, 0, 0, false, true);
            }
            template < typename T, uint16_t SZ >
            uint64_t write_line(const std::string& file, const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, length, buffer_offset, false, true);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_line(const char (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, length, buffer_offset, false, true);
            }
            template < typename T, uint16_t SZ >
            uint64_t write_line(const std::string& file, const omni::stack_buffer<T, SZ>& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, 0, 0, append, true);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_line(const char (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, 0, 0, append, true);
            }
            template < typename T, uint16_t SZ >
            uint64_t write_line(const std::string& file, const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, length, buffer_offset, append, true);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_line(const char (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, length, buffer_offset, append, true);
            }

            template < typename T >
            uint64_t unsafe_write_element(const std::string& file, const T* buffer, uint64_t elements, bool append)
            {
                return omni::io::file_internal::unsafe_write_el_fw< std::string, std::ofstream, T >(file, buffer, elements, append);
            }
            template < typename T >
            uint64_t unsafe_write_element(const std::string& file, const T* buffer, uint64_t elements)
            {
                return omni::io::file_internal::unsafe_write_el_fw< std::string, std::ofstream, T >(file, buffer, elements, false);
            }
            uint64_t unsafe_write(const std::string& file, const char* buffer, uint64_t length, bool append);
            uint64_t unsafe_write(const std::string& file, const wchar_t* buffer, uint64_t length, bool append);
            uint64_t unsafe_write(const std::string& file, const uint8_t* buffer, uint64_t length, bool append);
            uint64_t unsafe_write(const std::string& file, const int8_t* buffer, uint64_t length, bool append);
            uint64_t unsafe_write(const std::string& file, const char* buffer, uint64_t length);
            uint64_t unsafe_write(const std::string& file, const wchar_t* buffer, uint64_t length);
            uint64_t unsafe_write(const std::string& file, const uint8_t* buffer, uint64_t length);
            uint64_t unsafe_write(const std::string& file, const int8_t* buffer, uint64_t length);
            uint64_t unsafe_write_line(const std::string& file, const char* buffer, uint64_t length, bool append);
            uint64_t unsafe_write_line(const std::string& file, const wchar_t* buffer, uint64_t length, bool append);
            uint64_t unsafe_write_line(const std::string& file, const uint8_t* buffer, uint64_t length, bool append);
            uint64_t unsafe_write_line(const std::string& file, const int8_t* buffer, uint64_t length, bool append);
            uint64_t unsafe_write_line(const std::string& file, const char* buffer, uint64_t length);
            uint64_t unsafe_write_line(const std::string& file, const wchar_t* buffer, uint64_t length);
            uint64_t unsafe_write_line(const std::string& file, const uint8_t* buffer, uint64_t length);
            uint64_t unsafe_write_line(const std::string& file, const int8_t* buffer, uint64_t length);
        }
        namespace wfile {
            bool copy(const std::wstring& file, const std::wstring& new_name, const omni::io::options& io_ops);
            bool copy(const std::wstring& file, const std::wstring& new_name);
            bool create(const std::wstring& file, const omni::io::options& io_ops);
            bool create(const std::wstring& file);
            bool exists(const std::wstring& file);
            bool exist(const std::wstring& file);
            std::wstring get_contents(const std::wstring& file);
            uint64_t get_size(const std::wstring& file);
            bool move(const std::wstring& file, const std::wstring& new_name, const omni::io::options& io_ops);
            bool move(const std::wstring& file, const std::wstring& new_name);
            bool rename(const std::wstring& file, const std::wstring& new_name, const omni::io::options& io_ops);
            bool rename(const std::wstring& file, const std::wstring& new_name);
            uint64_t read(const std::wstring& file, std::wstring& buffer);
            // std::vector/deque/array/list/etc.
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read(const std::wstring& file, std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, std::ios_base::beg);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read(const wchar_t (&file)[SZ], std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, 0, 0, std::ios_base::beg);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read(const std::wstring& file, std_seq_t<T, std_allocator_t >& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, file_offset, offset_direction);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read(const wchar_t (&file)[SZ], std_seq_t<T, std_allocator_t >& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, 0, file_offset, offset_direction);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read(const std::wstring& file, std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, std_seq_t, T, std_allocator_t >(file, buffer, length, file_offset, offset_direction);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read(const wchar_t (&file)[SZ], std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, length, file_offset, offset_direction);
            }
            // char buf[]/wchar_t buf[]/uintX_t buf[]
            template < typename T, std::size_t SZ >
            uint64_t read(const std::wstring& file, T (&buffer)[SZ])
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(file, buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read(const wchar_t (&file)[FSZ], T (&buffer)[SZ])
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < typename T, std::size_t SZ >
            uint64_t read(const std::wstring& file, T (&buffer)[SZ], std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(file, buffer, 0, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read(const wchar_t (&file)[FSZ], T (&buffer)[SZ], std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, 0, 0, file_offset, offset_direction);
            }
            template < typename T, std::size_t SZ >
            uint64_t read(const std::wstring& file, T (&buffer)[SZ], uint64_t length, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(file, buffer, length, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read(const wchar_t (&file)[FSZ], T (&buffer)[SZ], uint64_t length, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, length, 0, file_offset, offset_direction);
            }
            template < typename T, std::size_t SZ >
            uint64_t read(const std::wstring& file, T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(file, buffer, length, buffer_offset, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read(const wchar_t (&file)[FSZ], T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, length, buffer_offset, file_offset, offset_direction);
            }
            // omni::stack_buffer
            template < typename T, uint16_t SZ >
            uint64_t read(const std::wstring& file, omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(file, buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read(const wchar_t (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < typename T, uint16_t SZ >
            uint64_t read(const std::wstring& file, omni::stack_buffer<T, SZ>& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(file, buffer, 0, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read(const wchar_t (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, 0, 0, file_offset, offset_direction);
            }
            template < typename T, uint16_t SZ >
            uint64_t read(const std::wstring& file, omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(file, buffer, length, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read(const wchar_t (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, length, 0, file_offset, offset_direction);
            }
            template < typename T, uint16_t SZ >
            uint64_t read(const std::wstring& file, omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(file, buffer, length, buffer_offset, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read(const wchar_t (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, length, buffer_offset, file_offset, offset_direction);
            }
            // read_element
            // std::vector/deque/array/list/etc.
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read_element(const std::wstring& file, std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, std::ios_base::beg);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read_element(const wchar_t (&file)[SZ], std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, 0, 0, std::ios_base::beg);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read_element(const std::wstring& file, std_seq_t<T, std_allocator_t >& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, file_offset, offset_direction);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read_element(const wchar_t (&file)[SZ], std_seq_t<T, std_allocator_t >& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, 0, file_offset, offset_direction);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read_element(const std::wstring& file, std_seq_t<T, std_allocator_t >& buffer, uint64_t elements, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, std_seq_t, T, std_allocator_t >(file, buffer, elements, file_offset, offset_direction);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read_element(const wchar_t (&file)[SZ], std_seq_t<T, std_allocator_t >& buffer, uint64_t elements, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, elements, file_offset, offset_direction);
            }
            // char buf[]/wchar_t buf[]/uintX_t buf[]
            template < typename T, std::size_t SZ >
            uint64_t read_element(const std::wstring& file, T (&buffer)[SZ])
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(file, buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read_element(const wchar_t (&file)[FSZ], T (&buffer)[SZ])
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < typename T, std::size_t SZ >
            uint64_t read_element(const std::wstring& file, T (&buffer)[SZ], std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(file, buffer, 0, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read_element(const wchar_t (&file)[FSZ], T (&buffer)[SZ], std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, 0, 0, file_offset, offset_direction);
            }
            template < typename T, std::size_t SZ >
            uint64_t read_element(const std::wstring& file, T (&buffer)[SZ], uint64_t elements, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(file, buffer, elements, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read_element(const wchar_t (&file)[FSZ], T (&buffer)[SZ], uint64_t elements, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, elements, 0, file_offset, offset_direction);
            }
            template < typename T, std::size_t SZ >
            uint64_t read_element(const std::wstring& file, T (&buffer)[SZ], uint64_t elements, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(file, buffer, elements, buffer_offset, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read_element(const wchar_t (&file)[FSZ], T (&buffer)[SZ], uint64_t elements, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, elements, buffer_offset, file_offset, offset_direction);
            }
            // omni::stack_buffer
            template < typename T, uint16_t SZ >
            uint64_t read_element(const std::wstring& file, omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(file, buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read_element(const wchar_t (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < typename T, uint16_t SZ >
            uint64_t read_element(const std::wstring& file, omni::stack_buffer<T, SZ>& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(file, buffer, 0, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read_element(const wchar_t (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, 0, 0, file_offset, offset_direction);
            }
            template < typename T, uint16_t SZ >
            uint64_t read_element(const std::wstring& file, omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(file, buffer, elements, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read_element(const wchar_t (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, elements, 0, file_offset, offset_direction);
            }
            template < typename T, uint16_t SZ >
            uint64_t read_element(const std::wstring& file, omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(file, buffer, elements, buffer_offset, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read_element(const wchar_t (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, elements, buffer_offset, file_offset, offset_direction);
            }
            template < typename T >
            uint64_t unsafe_read_element(const std::wstring& file, T* buffer, uint64_t elements)
            {
                return omni::io::file_internal::unsafe_rd_el< std::wstring, std::wifstream, T >(file, buffer, elements);
            }
            uint64_t unsafe_read(const std::wstring& file, char* buffer, uint64_t length);
            uint64_t unsafe_read(const std::wstring& file, wchar_t* buffer, uint64_t length);
            uint64_t unsafe_read(const std::wstring& file, uint8_t* buffer, uint64_t length);
            uint64_t unsafe_read(const std::wstring& file, int8_t* buffer, uint64_t length);
            bool remove(const std::wstring& file);
            #if defined(OMNI_NON_PORTABLE)
                bool set_size(const std::wstring& file, uint64_t size);
            #endif
            uint64_t write(const std::wstring& file, const std::wstring& buffer, bool append);
            uint64_t write(const std::wstring& file, const std::wstring& buffer);
            // std::vector/deque/array/list/etc.
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const std::wstring& file, const std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, false, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const wchar_t (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, 0, 0, false, false);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const std::wstring& file, const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(file, buffer, length, buffer_offset, false, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const wchar_t (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, length, buffer_offset, false, false);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const std::wstring& file, const std_seq_t<T, std_allocator_t >& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, append, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const wchar_t (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, 0, 0, append, false);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const std::wstring& file, const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(file, buffer, length, buffer_offset, append, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const wchar_t (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, length, buffer_offset, append, false);
            }
            // char buf[]/wchar_t buf[]/uintX_t buf[]
            template < typename T, std::size_t SZ >
            uint64_t write(const std::wstring& file, const T (&buffer)[SZ])
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, 0, 0, false, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write(const wchar_t (&file)[FSZ], const T (&buffer)[SZ])
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, 0, 0, false, false);
            }
            template < typename T, std::size_t SZ >
            uint64_t write(const std::wstring& file, const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, length, buffer_offset, false, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write(const wchar_t (&file)[FSZ], const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, length, buffer_offset, false, false);
            }
            template < typename T, std::size_t SZ >
            uint64_t write(const std::wstring& file, const T (&buffer)[SZ], bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, 0, 0, append, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write(const wchar_t (&file)[FSZ], const T (&buffer)[SZ], bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, 0, 0, append, false);
            }
            template < typename T, std::size_t SZ >
            uint64_t write(const std::wstring& file, const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, length, buffer_offset, append, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write(const wchar_t (&file)[FSZ], const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, length, buffer_offset, append, false);
            }
            // omni::stack_buffer
            template < typename T, uint16_t SZ >
            uint64_t write(const std::wstring& file, const omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, 0, 0, false, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write(const wchar_t (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, 0, 0, false, false);
            }            
            template < typename T, uint16_t SZ >
            uint64_t write(const std::wstring& file, const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, length, buffer_offset, false, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write(const wchar_t (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, length, buffer_offset, false, false);
            }
            template < typename T, uint16_t SZ >
            uint64_t write(const std::wstring& file, const omni::stack_buffer<T, SZ>& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, 0, 0, append, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write(const wchar_t (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, 0, 0, append, false);
            }
            template < typename T, uint16_t SZ >
            uint64_t write(const std::wstring& file, const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, length, buffer_offset, append, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write(const wchar_t (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, length, buffer_offset, append, false);
            }
            // write_element
            // std::vector/deque/array/list/etc.
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const std::wstring& file, const std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, false, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const wchar_t (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, 0, 0, false, false);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const std::wstring& file, const std_seq_t<T, std_allocator_t >& buffer, uint64_t elements, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(file, buffer, elements, buffer_offset, false, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const wchar_t (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, uint64_t elements, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, elements, buffer_offset, false, false);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const std::wstring& file, const std_seq_t<T, std_allocator_t >& buffer, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, append, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const wchar_t (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, 0, 0, append, false);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const std::wstring& file, const std_seq_t<T, std_allocator_t >& buffer, uint64_t elements, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(file, buffer, elements, buffer_offset, append, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const wchar_t (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, uint64_t elements, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, elements, buffer_offset, append, false);
            }
            // char buf[]/wchar_t buf[]/uintX_t buf[]
            template < typename T, std::size_t SZ >
            uint64_t write_element(const std::wstring& file, const T (&buffer)[SZ])
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, 0, 0, false, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_element(const wchar_t (&file)[FSZ], const T (&buffer)[SZ])
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, 0, 0, false, false);
            }
            template < typename T, std::size_t SZ >
            uint64_t write_element(const std::wstring& file, const T (&buffer)[SZ], uint64_t elements, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, elements, buffer_offset, false, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_element(const wchar_t (&file)[FSZ], const T (&buffer)[SZ], uint64_t elements, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, elements, buffer_offset, false, false);
            }
            template < typename T, std::size_t SZ >
            uint64_t write_element(const std::wstring& file, const T (&buffer)[SZ], bool append)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, 0, 0, append, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_element(const wchar_t (&file)[FSZ], const T (&buffer)[SZ], bool append)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, 0, 0, append, false);
            }
            template < typename T, std::size_t SZ >
            uint64_t write_element(const std::wstring& file, const T (&buffer)[SZ], uint64_t elements, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, elements, buffer_offset, append, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_element(const wchar_t (&file)[FSZ], const T (&buffer)[SZ], uint64_t elements, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, elements, buffer_offset, append, false);
            }
            // omni::stack_buffer
            template < typename T, uint16_t SZ >
            uint64_t write_element(const std::wstring& file, const omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, 0, 0, false, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_element(const wchar_t (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, 0, 0, false, false);
            }
            template < typename T, uint16_t SZ >
            uint64_t write_element(const std::wstring& file, const omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, elements, buffer_offset, false, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_element(const wchar_t (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, elements, buffer_offset, false, false);
            }
            template < typename T, uint16_t SZ >
            uint64_t write_element(const std::wstring& file, const omni::stack_buffer<T, SZ>& buffer, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, 0, 0, append, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_element(const wchar_t (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, 0, 0, append, false);
            }
            template < typename T, uint16_t SZ >
            uint64_t write_element(const std::wstring& file, const omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, elements, buffer_offset, append, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_element(const wchar_t (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, elements, buffer_offset, append, false);
            }

            uint64_t write_line(const std::wstring& file, const std::wstring& buffer, bool append);
            uint64_t write_line(const std::wstring& file, const std::wstring& buffer);
            // std::vector/deque/array/list/etc.
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const std::wstring& file, const std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, false, true);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const wchar_t (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, 0, 0, false, true);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const std::wstring& file, const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(file, buffer, length, buffer_offset, false, true);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const wchar_t (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, length, buffer_offset, false, true);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const std::wstring& file, const std_seq_t<T, std_allocator_t >& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, append, true);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const wchar_t (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, 0, 0, append, true);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const std::wstring& file, const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(file, buffer, length, buffer_offset, append, true);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const wchar_t (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, length, buffer_offset, append, true);
            }
            // char buf[]/wchar_t buf[]/uintX_t buf[]
            template < typename T, std::size_t SZ >
            uint64_t write_line(const std::wstring& file, const T (&buffer)[SZ])
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, 0, 0, false, true);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_line(const wchar_t (&file)[FSZ], const T (&buffer)[SZ])
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, 0, 0, false, true);
            }
            template < typename T, std::size_t SZ >
            uint64_t write_line(const std::wstring& file, const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, length, buffer_offset, false, true);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_line(const wchar_t (&file)[FSZ], const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, length, buffer_offset, false, true);
            }
            template < typename T, std::size_t SZ >
            uint64_t write_line(const std::wstring& file, const T (&buffer)[SZ], bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, 0, 0, append, true);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_line(const wchar_t (&file)[FSZ], const T (&buffer)[SZ], bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, 0, 0, append, true);
            }
            template < typename T, std::size_t SZ >
            uint64_t write_line(const std::wstring& file, const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, length, buffer_offset, append, true);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_line(const wchar_t (&file)[FSZ], const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, length, buffer_offset, append, true);
            }
            // omni::stack_buffer
            template < typename T, uint16_t SZ >
            uint64_t write_line(const std::wstring& file, const omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, 0, 0, false, true);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_line(const wchar_t (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, 0, 0, false, true);
            }
            template < typename T, uint16_t SZ >
            uint64_t write_line(const std::wstring& file, const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, length, buffer_offset, false, true);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_line(const wchar_t (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, length, buffer_offset, false, true);
            }
            template < typename T, uint16_t SZ >
            uint64_t write_line(const std::wstring& file, const omni::stack_buffer<T, SZ>& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, 0, 0, append, true);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_line(const wchar_t (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, 0, 0, append, true);
            }
            template < typename T, uint16_t SZ >
            uint64_t write_line(const std::wstring& file, const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, length, buffer_offset, append, true);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_line(const wchar_t (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, length, buffer_offset, append, true);
            }
            template < typename T >
            uint64_t unsafe_write_element(const std::wstring& file, const T* buffer, uint64_t elements, bool append)
            {
                return omni::io::file_internal::unsafe_write_el_fw< std::wstring, std::wofstream, T >(file, buffer, elements, append);
            }
            template < typename T >
            uint64_t unsafe_write_element(const std::wstring& file, const T* buffer, uint64_t elements)
            {
                return omni::io::file_internal::unsafe_write_el_fw< std::wstring, std::wofstream, T >(file, buffer, elements, false);
            }
            uint64_t unsafe_write(const std::wstring& file, const char* buffer, uint64_t length, bool append);
            uint64_t unsafe_write(const std::wstring& file, const wchar_t* buffer, uint64_t length, bool append);
            uint64_t unsafe_write(const std::wstring& file, const uint8_t* buffer, uint64_t length, bool append);
            uint64_t unsafe_write(const std::wstring& file, const int8_t* buffer, uint64_t length, bool append);
            uint64_t unsafe_write(const std::wstring& file, const char* buffer, uint64_t length);
            uint64_t unsafe_write(const std::wstring& file, const wchar_t* buffer, uint64_t length);
            uint64_t unsafe_write(const std::wstring& file, const uint8_t* buffer, uint64_t length);
            uint64_t unsafe_write(const std::wstring& file, const int8_t* buffer, uint64_t length);
            uint64_t unsafe_write_line(const std::wstring& file, const char* buffer, uint64_t length, bool append);
            uint64_t unsafe_write_line(const std::wstring& file, const wchar_t* buffer, uint64_t length, bool append);
            uint64_t unsafe_write_line(const std::wstring& file, const uint8_t* buffer, uint64_t length, bool append);
            uint64_t unsafe_write_line(const std::wstring& file, const int8_t* buffer, uint64_t length, bool append);
            uint64_t unsafe_write_line(const std::wstring& file, const char* buffer, uint64_t length);
            uint64_t unsafe_write_line(const std::wstring& file, const wchar_t* buffer, uint64_t length);
            uint64_t unsafe_write_line(const std::wstring& file, const uint8_t* buffer, uint64_t length);
            uint64_t unsafe_write_line(const std::wstring& file, const int8_t* buffer, uint64_t length);
        }
        namespace file {
            // std::string
            inline bool copy(const std::string& file, const std::string& new_name, const omni::io::options& io_ops) { return omni::io::cfile::copy(file, new_name, io_ops); }
            inline bool copy(const std::string& file, const std::string& new_name) { return omni::io::cfile::copy(file, new_name); }
            inline bool create(const std::string& file, const omni::io::options& io_ops) { return omni::io::cfile::create(file, io_ops); }
            inline bool create(const std::string& file) { return omni::io::cfile::create(file); }
            inline bool exists(const std::string& file) { return omni::io::cfile::exists(file); }
            inline bool exist(const std::string& file) { return omni::io::cfile::exist(file); }
            inline std::string get_contents(const std::string& file) { return omni::io::cfile::get_contents(file); }
            inline uint64_t get_size(const std::string& file) { return omni::io::cfile::get_size(file); }
            inline bool move(const std::string& file, const std::string& new_name, const omni::io::options& io_ops) { return omni::io::cfile::move(file, new_name, io_ops); }
            inline bool move(const std::string& file, const std::string& new_name) { return omni::io::cfile::move(file, new_name); }
            inline bool rename(const std::string& file, const std::string& new_name, const omni::io::options& io_ops) { return omni::io::cfile::rename(file, new_name, io_ops); }
            inline bool rename(const std::string& file, const std::string& new_name) { return omni::io::cfile::rename(file, new_name); }
            inline uint64_t read(const std::string& file, std::string& buffer) { return omni::io::cfile::read(file, buffer); }
            // std::vector/deque/array/list/etc.
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read(const std::string& file, std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, std::ios_base::beg);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read(const char (&file)[SZ], std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, 0, 0, std::ios_base::beg);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read(const std::string& file, std_seq_t<T, std_allocator_t >& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, file_offset, offset_direction);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read(const char (&file)[SZ], std_seq_t<T, std_allocator_t >& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, 0, file_offset, offset_direction);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read(const std::string& file, std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, std_seq_t, T, std_allocator_t >(file, buffer, length, file_offset, offset_direction);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read(const char (&file)[SZ], std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, length, file_offset, offset_direction);
            }
            // char buf[]/wchar_t buf[]/uintX_t buf[]
            template < typename T, std::size_t SZ >
            uint64_t read(const std::string& file, T (&buffer)[SZ])
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(file, buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read(const char (&file)[FSZ], T (&buffer)[SZ])
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(std::string(file), buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < typename T, std::size_t SZ >
            uint64_t read(const std::string& file, T (&buffer)[SZ], std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(file, buffer, 0, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read(const char (&file)[FSZ], T (&buffer)[SZ], std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(std::string(file), buffer, 0, 0, file_offset, offset_direction);
            }
            template < typename T, std::size_t SZ >
            uint64_t read(const std::string& file, T (&buffer)[SZ], uint64_t length, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(file, buffer, length, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read(const char (&file)[FSZ], T (&buffer)[SZ], uint64_t length, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(std::string(file), buffer, length, 0, file_offset, offset_direction);
            }
            template < typename T, std::size_t SZ >
            uint64_t read(const std::string& file, T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(file, buffer, length, buffer_offset, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read(const char (&file)[FSZ], T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(std::string(file), buffer, length, buffer_offset, file_offset, offset_direction);
            }
            // omni::stack_buffer
            template < typename T, uint16_t SZ >
            uint64_t read(const std::string& file, omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(file, buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read(const char (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(std::string(file), buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < typename T, uint16_t SZ >
            uint64_t read(const std::string& file, omni::stack_buffer<T, SZ>& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(file, buffer, 0, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read(const char (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(std::string(file), buffer, 0, 0, file_offset, offset_direction);
            }
            template < typename T, uint16_t SZ >
            uint64_t read(const std::string& file, omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(file, buffer, length, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read(const char (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(std::string(file), buffer, length, 0, file_offset, offset_direction);
            }
            template < typename T, uint16_t SZ >
            uint64_t read(const std::string& file, omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(file, buffer, length, buffer_offset, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read(const char (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::string, std::ifstream, T, SZ >(std::string(file), buffer, length, buffer_offset, file_offset, offset_direction);
            }

            // read_element
            // std::vector/deque/array/list/etc.
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read_element(const std::string& file, std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, std::ios_base::beg);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read_element(const char (&file)[SZ], std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, 0, 0, std::ios_base::beg);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read_element(const std::string& file, std_seq_t<T, std_allocator_t >& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, file_offset, offset_direction);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read_element(const char (&file)[SZ], std_seq_t<T, std_allocator_t >& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, 0, file_offset, offset_direction);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read_element(const std::string& file, std_seq_t<T, std_allocator_t >& buffer, uint64_t elements, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, std_seq_t, T, std_allocator_t >(file, buffer, elements, file_offset, offset_direction);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read_element(const char (&file)[SZ], std_seq_t<T, std_allocator_t >& buffer, uint64_t elements, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, elements, file_offset, offset_direction);
            }
            // char buf[]/wchar_t buf[]/uintX_t buf[]
            template < typename T, std::size_t SZ >
            uint64_t read_element(const std::string& file, T (&buffer)[SZ])
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(file, buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read_element(const char (&file)[FSZ], T (&buffer)[SZ])
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(std::string(file), buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < typename T, std::size_t SZ >
            uint64_t read_element(const std::string& file, T (&buffer)[SZ], std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(file, buffer, 0, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read_element(const char (&file)[FSZ], T (&buffer)[SZ], std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(std::string(file), buffer, 0, 0, file_offset, offset_direction);
            }
            template < typename T, std::size_t SZ >
            uint64_t read_element(const std::string& file, T (&buffer)[SZ], uint64_t elements, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(file, buffer, elements, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read_element(const char (&file)[FSZ], T (&buffer)[SZ], uint64_t elements, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(std::string(file), buffer, elements, 0, file_offset, offset_direction);
            }
            template < typename T, std::size_t SZ >
            uint64_t read_element(const std::string& file, T (&buffer)[SZ], uint64_t elements, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(file, buffer, elements, buffer_offset, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read_element(const char (&file)[FSZ], T (&buffer)[SZ], uint64_t elements, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(std::string(file), buffer, elements, buffer_offset, file_offset, offset_direction);
            }
            // omni::stack_buffer
            template < typename T, uint16_t SZ >
            uint64_t read_element(const std::string& file, omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(file, buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read_element(const char (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(std::string(file), buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < typename T, uint16_t SZ >
            uint64_t read_element(const std::string& file, omni::stack_buffer<T, SZ>& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(file, buffer, 0, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read_element(const char (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(std::string(file), buffer, 0, 0, file_offset, offset_direction);
            }
            template < typename T, uint16_t SZ >
            uint64_t read_element(const std::string& file, omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(file, buffer, elements, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read_element(const char (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(std::string(file), buffer, elements, 0, file_offset, offset_direction);
            }
            template < typename T, uint16_t SZ >
            uint64_t read_element(const std::string& file, omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(file, buffer, elements, buffer_offset, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read_element(const char (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::string, std::ifstream, T, SZ >(std::string(file), buffer, elements, buffer_offset, file_offset, offset_direction);
            }
            template < typename T >
            uint64_t unsafe_read_element(const std::string& file, T* buffer, uint64_t elements)
            {
                return omni::io::file_internal::unsafe_rd_el< std::string, std::ifstream, T >(file, buffer, elements);
            }
            inline uint64_t unsafe_read(const std::string& file, char* buffer, uint64_t length) { return omni::io::cfile::unsafe_read(file, buffer, length); }
            inline uint64_t unsafe_read(const std::string& file, wchar_t* buffer, uint64_t length) { return omni::io::cfile::unsafe_read(file, buffer, length); }
            inline uint64_t unsafe_read(const std::string& file, uint8_t* buffer, uint64_t length) { return omni::io::cfile::unsafe_read(file, buffer, length); }
            inline uint64_t unsafe_read(const std::string& file, int8_t* buffer, uint64_t length) { return omni::io::cfile::unsafe_read(file, buffer, length); }
            inline bool remove(const std::string& file) { return omni::io::cfile::remove(file); }
            #if defined(OMNI_NON_PORTABLE)
                inline bool set_size(const std::string& file, uint64_t size) { return omni::io::cfile::set_size(file, size); }
            #endif
            inline uint64_t write(const std::string& file, const std::string& buffer, bool append) { return omni::io::cfile::write(file, buffer, append); }
            inline uint64_t write(const std::string& file, const std::string& buffer) { return omni::io::cfile::write(file, buffer); }
            // std::vector/deque/array/list/etc.
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const std::string& file, const std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, false, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const char (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, 0, 0, false, false);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const std::string& file, const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(file, buffer, length, buffer_offset, false, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const char (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, length, buffer_offset, false, false);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const std::string& file, const std_seq_t<T, std_allocator_t >& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, append, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const char (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, 0, 0, append, false);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const std::string& file, const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(file, buffer, length, buffer_offset, append, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const char (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, length, buffer_offset, append, false);
            }
            // char buf[]/wchar_t buf[]/uintX_t buf[]
            template < typename T, std::size_t SZ >
            uint64_t write(const std::string& file, const T (&buffer)[SZ])
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, 0, 0, false, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write(const char (&file)[FSZ], const T (&buffer)[SZ])
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, 0, 0, false, false);
            }
            template < typename T, std::size_t SZ >
            uint64_t write(const std::string& file, const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, length, buffer_offset, false, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write(const char (&file)[FSZ], const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, length, buffer_offset, false, false);
            }
            template < typename T, std::size_t SZ >
            uint64_t write(const std::string& file, const T (&buffer)[SZ], bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, 0, 0, append, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write(const char (&file)[FSZ], const T (&buffer)[SZ], bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, 0, 0, append, false);
            }
            template < typename T, std::size_t SZ >
            uint64_t write(const std::string& file, const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, length, buffer_offset, append, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write(const char (&file)[FSZ], const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, length, buffer_offset, append, false);
            }
            // omni::stack_buffer
            template < typename T, uint16_t SZ >
            uint64_t write(const std::string& file, const omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, 0, 0, false, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write(const char (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, 0, 0, false, false);
            }
            template < typename T, uint16_t SZ >
            uint64_t write(const std::string& file, const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, length, buffer_offset, false, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write(const char (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, length, buffer_offset, false, false);
            }
            template < typename T, uint16_t SZ >
            uint64_t write(const std::string& file, const omni::stack_buffer<T, SZ>& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, 0, 0, append, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write(const char (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, 0, 0, append, false);
            }
            template < typename T, uint16_t SZ >
            uint64_t write(const std::string& file, const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, length, buffer_offset, append, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write(const char (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, length, buffer_offset, append, false);
            }
            // write_elements
            // std::vector/deque/array/list/etc.
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const std::string& file, const std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, false, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const char (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, 0, 0, false, false);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const std::string& file, const std_seq_t<T, std_allocator_t >& buffer, uint64_t elements, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(file, buffer, elements, buffer_offset, false, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const char (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, uint64_t elements, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, elements, buffer_offset, false, false);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const std::string& file, const std_seq_t<T, std_allocator_t >& buffer, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, append, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const char (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, 0, 0, append, false);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const std::string& file, const std_seq_t<T, std_allocator_t >& buffer, uint64_t elements, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(file, buffer, elements, buffer_offset, append, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const char (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, uint64_t elements, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, elements, buffer_offset, append, false);
            }
            // char buf[]/wchar_t buf[]/uintX_t buf[]
            template < typename T, std::size_t SZ >
            uint64_t write_element(const std::string& file, const T (&buffer)[SZ])
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(file, buffer, 0, 0, false, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_element(const char (&file)[FSZ], const T (&buffer)[SZ])
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, 0, 0, false, false);
            }
            template < typename T, std::size_t SZ >
            uint64_t write_element(const std::string& file, const T (&buffer)[SZ], uint64_t elements, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(file, buffer, elements, buffer_offset, false, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_element(const char (&file)[FSZ], const T (&buffer)[SZ], uint64_t elements, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, elements, buffer_offset, false, false);
            }
            template < typename T, std::size_t SZ >
            uint64_t write_element(const std::string& file, const T (&buffer)[SZ], bool append)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(file, buffer, 0, 0, append, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_element(const char (&file)[FSZ], const T (&buffer)[SZ], bool append)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, 0, 0, append, false);
            }
            template < typename T, std::size_t SZ >
            uint64_t write_element(const std::string& file, const T (&buffer)[SZ], uint64_t elements, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(file, buffer, elements, buffer_offset, append, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_element(const char (&file)[FSZ], const T (&buffer)[SZ], uint64_t elements, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, elements, buffer_offset, append, false);
            }
            // omni::stack_buffer
            template < typename T, uint16_t SZ >
            uint64_t write_element(const std::string& file, const omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(file, buffer, 0, 0, false, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_element(const char (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, 0, 0, false, false);
            }
            template < typename T, uint16_t SZ >
            uint64_t write_element(const std::string& file, const omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(file, buffer, elements, buffer_offset, false, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_element(const char (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, elements, buffer_offset, false, false);
            }
            template < typename T, uint16_t SZ >
            uint64_t write_element(const std::string& file, const omni::stack_buffer<T, SZ>& buffer, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(file, buffer, 0, 0, append, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_element(const char (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, 0, 0, append, false);
            }
            template < typename T, uint16_t SZ >
            uint64_t write_element(const std::string& file, const omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(file, buffer, elements, buffer_offset, append, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_element(const char (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, elements, buffer_offset, append, false);
            }

            inline uint64_t write_line(const std::string& file, const std::string& buffer, bool append) { return omni::io::cfile::write_line(file, buffer, append); }
            inline uint64_t write_line(const std::string& file, const std::string& buffer) { return omni::io::cfile::write_line(file, buffer); }
            // std::vector/deque/array/list/etc.
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const std::string& file, const std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, false, true);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const char (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, 0, 0, false, true);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const std::string& file, const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(file, buffer, length, buffer_offset, false, true);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const char (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, length, buffer_offset, false, true);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const std::string& file, const std_seq_t<T, std_allocator_t >& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, append, true);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const char (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, 0, 0, append, true);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const std::string& file, const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(file, buffer, length, buffer_offset, append, true);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const char (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, std_seq_t, T, std_allocator_t >(std::string(file), buffer, length, buffer_offset, append, true);
            }
            // char buf[]/wchar_t buf[]/uintX_t buf[]
            template < typename T, std::size_t SZ >
            uint64_t write_line(const std::string& file, const T (&buffer)[SZ])
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, 0, 0, false, true);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_line(const char (&file)[FSZ], const T (&buffer)[SZ])
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, 0, 0, false, true);
            }
            template < typename T, std::size_t SZ >
            uint64_t write_line(const std::string& file, const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, length, buffer_offset, false, true);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_line(const char (&file)[FSZ], const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, length, buffer_offset, false, true);
            }
            template < typename T, std::size_t SZ >
            uint64_t write_line(const std::string& file, const T (&buffer)[SZ], bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, 0, 0, append, true);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_line(const char (&file)[FSZ], const T (&buffer)[SZ], bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, 0, 0, append, true);
            }
            template < typename T, std::size_t SZ >
            uint64_t write_line(const std::string& file, const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, length, buffer_offset, append, true);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_line(const char (&file)[FSZ], const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, length, buffer_offset, append, true);
            }
            // omni::stack_buffer
            template < typename T, uint16_t SZ >
            uint64_t write_line(const std::string& file, const omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, 0, 0, false, true);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_line(const char (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, 0, 0, false, true);
            }
            template < typename T, uint16_t SZ >
            uint64_t write_line(const std::string& file, const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, length, buffer_offset, false, true);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_line(const char (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, length, buffer_offset, false, true);
            }
            template < typename T, uint16_t SZ >
            uint64_t write_line(const std::string& file, const omni::stack_buffer<T, SZ>& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, 0, 0, append, true);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_line(const char (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, 0, 0, append, true);
            }
            template < typename T, uint16_t SZ >
            uint64_t write_line(const std::string& file, const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(file, buffer, length, buffer_offset, append, true);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_line(const char (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::string, std::ofstream, T, SZ >(std::string(file), buffer, length, buffer_offset, append, true);
            }
            template < typename T >
            uint64_t unsafe_write_element(const std::string& file, const T* buffer, uint64_t elements, bool append)
            {
                return omni::io::file_internal::unsafe_write_el_fw< std::string, std::ofstream, T >(file, buffer, elements, append);
            }
            template < typename T >
            uint64_t unsafe_write_element(const std::string& file, const T* buffer, uint64_t elements)
            {
                return omni::io::file_internal::unsafe_write_el_fw< std::string, std::ofstream, T >(file, buffer, elements, false);
            }
            inline uint64_t unsafe_write(const std::string& file, const char* buffer, uint64_t length, bool append) { return omni::io::cfile::unsafe_write(file, buffer, length, append); }
            inline uint64_t unsafe_write(const std::string& file, const wchar_t* buffer, uint64_t length, bool append) { return omni::io::cfile::unsafe_write(file, buffer, length, append); }
            inline uint64_t unsafe_write(const std::string& file, const uint8_t* buffer, uint64_t length, bool append) { return omni::io::cfile::unsafe_write(file, buffer, length, append); }
            inline uint64_t unsafe_write(const std::string& file, const int8_t* buffer, uint64_t length, bool append) { return omni::io::cfile::unsafe_write(file, buffer, length, append); }
            inline uint64_t unsafe_write(const std::string& file, const char* buffer, uint64_t length) { return omni::io::cfile::unsafe_write(file, buffer, length); }
            inline uint64_t unsafe_write(const std::string& file, const wchar_t* buffer, uint64_t length) { return omni::io::cfile::unsafe_write(file, buffer, length); }
            inline uint64_t unsafe_write(const std::string& file, const uint8_t* buffer, uint64_t length) { return omni::io::cfile::unsafe_write(file, buffer, length); }
            inline uint64_t unsafe_write(const std::string& file, const int8_t* buffer, uint64_t length) { return omni::io::cfile::unsafe_write(file, buffer, length); }
            inline uint64_t unsafe_write_line(const std::string& file, const char* buffer, uint64_t length, bool append) { return omni::io::cfile::unsafe_write_line(file, buffer, length, append); }
            inline uint64_t unsafe_write_line(const std::string& file, const wchar_t* buffer, uint64_t length, bool append) { return omni::io::cfile::unsafe_write_line(file, buffer, length, append); }
            inline uint64_t unsafe_write_line(const std::string& file, const uint8_t* buffer, uint64_t length, bool append) { return omni::io::cfile::unsafe_write_line(file, buffer, length, append); }
            inline uint64_t unsafe_write_line(const std::string& file, const int8_t* buffer, uint64_t length, bool append) { return omni::io::cfile::unsafe_write_line(file, buffer, length, append); }
            inline uint64_t unsafe_write_line(const std::string& file, const char* buffer, uint64_t length) { return omni::io::cfile::unsafe_write_line(file, buffer, length); }
            inline uint64_t unsafe_write_line(const std::string& file, const wchar_t* buffer, uint64_t length) { return omni::io::cfile::unsafe_write_line(file, buffer, length); }
            inline uint64_t unsafe_write_line(const std::string& file, const uint8_t* buffer, uint64_t length) { return omni::io::cfile::unsafe_write_line(file, buffer, length); }
            inline uint64_t unsafe_write_line(const std::string& file, const int8_t* buffer, uint64_t length) { return omni::io::cfile::unsafe_write_line(file, buffer, length); }
            
            // std::wstring

            inline bool copy(const std::wstring& file, const std::wstring& new_name, const omni::io::options& io_ops) { return omni::io::wfile::copy(file, new_name, io_ops); }
            inline bool copy(const std::wstring& file, const std::wstring& new_name) { return omni::io::wfile::copy(file, new_name); }
            inline bool create(const std::wstring& file, const omni::io::options& io_ops) { return omni::io::wfile::create(file, io_ops); }
            inline bool create(const std::wstring& file) { return omni::io::wfile::create(file); }
            inline bool exists(const std::wstring& file) { return omni::io::wfile::exists(file); }
            inline bool exist(const std::wstring& file) { return omni::io::wfile::exist(file); }
            inline std::wstring get_contents(const std::wstring& file) { return omni::io::wfile::get_contents(file); }
            inline uint64_t get_size(const std::wstring& file) { return omni::io::wfile::get_size(file); }
            inline bool move(const std::wstring& file, const std::wstring& new_name, const omni::io::options& io_ops) { return omni::io::wfile::move(file, new_name, io_ops); }
            inline bool move(const std::wstring& file, const std::wstring& new_name) { return omni::io::wfile::move(file, new_name); }
            inline bool rename(const std::wstring& file, const std::wstring& new_name, const omni::io::options& io_ops) { return omni::io::wfile::rename(file, new_name, io_ops); }
            inline bool rename(const std::wstring& file, const std::wstring& new_name) { return omni::io::wfile::rename(file, new_name); }
            inline uint64_t read(const std::wstring& file, std::wstring& buffer) { return omni::io::wfile::read(file, buffer); }
            // std::vector/deque/array/list/etc.
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read(const std::wstring& file, std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, std::ios_base::beg);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read(const wchar_t (&file)[SZ], std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, 0, 0, std::ios_base::beg);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read(const std::wstring& file, std_seq_t<T, std_allocator_t >& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, file_offset, offset_direction);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read(const wchar_t (&file)[SZ], std_seq_t<T, std_allocator_t >& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, 0, file_offset, offset_direction);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read(const std::wstring& file, std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, std_seq_t, T, std_allocator_t >(file, buffer, length, file_offset, offset_direction);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read(const wchar_t (&file)[SZ], std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, length, file_offset, offset_direction);
            }
            // char buf[]/wchar_t buf[]/uintX_t buf[]
            template < typename T, std::size_t SZ >
            uint64_t read(const std::wstring& file, T (&buffer)[SZ])
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(file, buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read(const wchar_t (&file)[FSZ], T (&buffer)[SZ])
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < typename T, std::size_t SZ >
            uint64_t read(const std::wstring& file, T (&buffer)[SZ], std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(file, buffer, 0, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read(const wchar_t (&file)[FSZ], T (&buffer)[SZ], std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, 0, 0, file_offset, offset_direction);
            }
            template < typename T, std::size_t SZ >
            uint64_t read(const std::wstring& file, T (&buffer)[SZ], uint64_t length, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(file, buffer, length, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read(const wchar_t (&file)[FSZ], T (&buffer)[SZ], uint64_t length, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, length, 0, file_offset, offset_direction);
            }
            template < typename T, std::size_t SZ >
            uint64_t read(const std::wstring& file, T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(file, buffer, length, buffer_offset, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read(const wchar_t (&file)[FSZ], T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, length, buffer_offset, file_offset, offset_direction);
            }
            // omni::stack_buffer
            template < typename T, uint16_t SZ >
            uint64_t read(const std::wstring& file, omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(file, buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read(const wchar_t (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < typename T, uint16_t SZ >
            uint64_t read(const std::wstring& file, omni::stack_buffer<T, SZ>& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(file, buffer, 0, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read(const wchar_t (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, 0, 0, file_offset, offset_direction);
            }
            template < typename T, uint16_t SZ >
            uint64_t read(const std::wstring& file, omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(file, buffer, length, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read(const wchar_t (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, length, 0, file_offset, offset_direction);
            }
            template < typename T, uint16_t SZ >
            uint64_t read(const std::wstring& file, omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(file, buffer, length, buffer_offset, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read(const wchar_t (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, length, buffer_offset, file_offset, offset_direction);
            }
            // read_element
            // std::vector/deque/array/list/etc.
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read_element(const std::wstring& file, std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, std::ios_base::beg);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read_element(const wchar_t (&file)[SZ], std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, 0, 0, std::ios_base::beg);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read_element(const std::wstring& file, std_seq_t<T, std_allocator_t >& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, file_offset, offset_direction);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read_element(const wchar_t (&file)[SZ], std_seq_t<T, std_allocator_t >& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, 0, file_offset, offset_direction);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read_element(const std::wstring& file, std_seq_t<T, std_allocator_t >& buffer, uint64_t elements, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, std_seq_t, T, std_allocator_t >(file, buffer, elements, file_offset, offset_direction);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t read_element(const wchar_t (&file)[SZ], std_seq_t<T, std_allocator_t >& buffer, uint64_t elements, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, elements, file_offset, offset_direction);
            }
            // char buf[]/wchar_t buf[]/uintX_t buf[]
            template < typename T, std::size_t SZ >
            uint64_t read_element(const std::wstring& file, T (&buffer)[SZ])
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(file, buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read_element(const wchar_t (&file)[FSZ], T (&buffer)[SZ])
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < typename T, std::size_t SZ >
            uint64_t read_element(const std::wstring& file, T (&buffer)[SZ], std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(file, buffer, 0, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read_element(const wchar_t (&file)[FSZ], T (&buffer)[SZ], std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, 0, 0, file_offset, offset_direction);
            }
            template < typename T, std::size_t SZ >
            uint64_t read_element(const std::wstring& file, T (&buffer)[SZ], uint64_t elements, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(file, buffer, elements, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read_element(const wchar_t (&file)[FSZ], T (&buffer)[SZ], uint64_t elements, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, elements, 0, file_offset, offset_direction);
            }
            template < typename T, std::size_t SZ >
            uint64_t read_element(const std::wstring& file, T (&buffer)[SZ], uint64_t elements, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(file, buffer, elements, buffer_offset, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t read_element(const wchar_t (&file)[FSZ], T (&buffer)[SZ], uint64_t elements, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, elements, buffer_offset, file_offset, offset_direction);
            }
            // omni::stack_buffer
            template < typename T, uint16_t SZ >
            uint64_t read_element(const std::wstring& file, omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(file, buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read_element(const wchar_t (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, 0, 0, 0, std::ios_base::beg);
            }
            template < typename T, uint16_t SZ >
            uint64_t read_element(const std::wstring& file, omni::stack_buffer<T, SZ>& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(file, buffer, 0, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read_element(const wchar_t (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, 0, 0, file_offset, offset_direction);
            }
            template < typename T, uint16_t SZ >
            uint64_t read_element(const std::wstring& file, omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(file, buffer, elements, 0, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read_element(const wchar_t (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, elements, 0, file_offset, offset_direction);
            }
            template < typename T, uint16_t SZ >
            uint64_t read_element(const std::wstring& file, omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(file, buffer, elements, buffer_offset, file_offset, offset_direction);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t read_element(const wchar_t (&file)[FSZ], omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::size_t buffer_offset, std::streamoff file_offset, std::ios_base::seekdir offset_direction)
            {
                return omni::io::file_internal::rd_el< std::wstring, std::wifstream, T, SZ >(std::wstring(file), buffer, elements, buffer_offset, file_offset, offset_direction);
            }
            template < typename T >
            uint64_t unsafe_read_element(const std::wstring& file, T* buffer, uint64_t elements)
            {
                return omni::io::file_internal::unsafe_rd_el< std::wstring, std::wifstream, T >(file, buffer, elements);
            }
            inline uint64_t unsafe_read(const std::wstring& file, char* buffer, uint64_t length) { return omni::io::wfile::unsafe_read(file, buffer, length); }
            inline uint64_t unsafe_read(const std::wstring& file, wchar_t* buffer, uint64_t length) { return omni::io::wfile::unsafe_read(file, buffer, length); }
            inline uint64_t unsafe_read(const std::wstring& file, uint8_t* buffer, uint64_t length) { return omni::io::wfile::unsafe_read(file, buffer, length); }
            inline uint64_t unsafe_read(const std::wstring& file, int8_t* buffer, uint64_t length) { return omni::io::wfile::unsafe_read(file, buffer, length); }
            inline bool remove(const std::wstring& file) { return omni::io::wfile::remove(file); }
            #if defined(OMNI_NON_PORTABLE)
                inline bool set_size(const std::wstring& file, uint64_t size) { return omni::io::wfile::set_size(file, size); }
            #endif
            inline uint64_t write(const std::wstring& file, const std::wstring& buffer, bool append) { return omni::io::wfile::write(file, buffer, append); }
            inline uint64_t write(const std::wstring& file, const std::wstring& buffer) { return omni::io::wfile::write(file, buffer); }
            // std::vector/deque/array/list/etc.
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const std::wstring& file, const std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, false, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const wchar_t (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, 0, 0, false, false);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const std::wstring& file, const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(file, buffer, length, buffer_offset, false, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const wchar_t (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, length, buffer_offset, false, false);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const std::wstring& file, const std_seq_t<T, std_allocator_t >& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, append, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const wchar_t (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, 0, 0, append, false);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const std::wstring& file, const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(file, buffer, length, buffer_offset, append, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write(const wchar_t (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, length, buffer_offset, append, false);
            }
            // char buf[]/wchar_t buf[]/uintX_t buf[]
            template < typename T, std::size_t SZ >
            uint64_t write(const std::wstring& file, const T (&buffer)[SZ])
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, 0, 0, false, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write(const wchar_t (&file)[FSZ], const T (&buffer)[SZ])
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, 0, 0, false, false);
            }
            template < typename T, std::size_t SZ >
            uint64_t write(const std::wstring& file, const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, length, buffer_offset, false, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write(const wchar_t (&file)[FSZ], const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, length, buffer_offset, false, false);
            }
            template < typename T, std::size_t SZ >
            uint64_t write(const std::wstring& file, const T (&buffer)[SZ], bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, 0, 0, append, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write(const wchar_t (&file)[FSZ], const T (&buffer)[SZ], bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, 0, 0, append, false);
            }
            template < typename T, std::size_t SZ >
            uint64_t write(const std::wstring& file, const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, length, buffer_offset, append, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write(const wchar_t (&file)[FSZ], const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, length, buffer_offset, append, false);
            }
            // omni::stack_buffer
            template < typename T, uint16_t SZ >
            uint64_t write(const std::wstring& file, const omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, 0, 0, false, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write(const wchar_t (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, 0, 0, false, false);
            }            
            template < typename T, uint16_t SZ >
            uint64_t write(const std::wstring& file, const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, length, buffer_offset, false, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write(const wchar_t (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, length, buffer_offset, false, false);
            }
            template < typename T, uint16_t SZ >
            uint64_t write(const std::wstring& file, const omni::stack_buffer<T, SZ>& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, 0, 0, append, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write(const wchar_t (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, 0, 0, append, false);
            }
            template < typename T, uint16_t SZ >
            uint64_t write(const std::wstring& file, const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, length, buffer_offset, append, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write(const wchar_t (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, length, buffer_offset, append, false);
            }
            // write_element
            // std::vector/deque/array/list/etc.
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const std::wstring& file, const std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, false, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const wchar_t (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, 0, 0, false, false);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const std::wstring& file, const std_seq_t<T, std_allocator_t >& buffer, uint64_t elements, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(file, buffer, elements, buffer_offset, false, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const wchar_t (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, uint64_t elements, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, elements, buffer_offset, false, false);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const std::wstring& file, const std_seq_t<T, std_allocator_t >& buffer, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, append, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const wchar_t (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, 0, 0, append, false);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const std::wstring& file, const std_seq_t<T, std_allocator_t >& buffer, uint64_t elements, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(file, buffer, elements, buffer_offset, append, false);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_element(const wchar_t (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, uint64_t elements, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, elements, buffer_offset, append, false);
            }
            // char buf[]/wchar_t buf[]/uintX_t buf[]
            template < typename T, std::size_t SZ >
            uint64_t write_element(const std::wstring& file, const T (&buffer)[SZ])
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, 0, 0, false, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_element(const wchar_t (&file)[FSZ], const T (&buffer)[SZ])
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, 0, 0, false, false);
            }
            template < typename T, std::size_t SZ >
            uint64_t write_element(const std::wstring& file, const T (&buffer)[SZ], uint64_t elements, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, elements, buffer_offset, false, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_element(const wchar_t (&file)[FSZ], const T (&buffer)[SZ], uint64_t elements, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, elements, buffer_offset, false, false);
            }
            template < typename T, std::size_t SZ >
            uint64_t write_element(const std::wstring& file, const T (&buffer)[SZ], bool append)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, 0, 0, append, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_element(const wchar_t (&file)[FSZ], const T (&buffer)[SZ], bool append)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, 0, 0, append, false);
            }
            template < typename T, std::size_t SZ >
            uint64_t write_element(const std::wstring& file, const T (&buffer)[SZ], uint64_t elements, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, elements, buffer_offset, append, false);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_element(const wchar_t (&file)[FSZ], const T (&buffer)[SZ], uint64_t elements, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, elements, buffer_offset, append, false);
            }
            // omni::stack_buffer
            template < typename T, uint16_t SZ >
            uint64_t write_element(const std::wstring& file, const omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, 0, 0, false, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_element(const wchar_t (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, 0, 0, false, false);
            }
            template < typename T, uint16_t SZ >
            uint64_t write_element(const std::wstring& file, const omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, elements, buffer_offset, false, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_element(const wchar_t (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, elements, buffer_offset, false, false);
            }
            template < typename T, uint16_t SZ >
            uint64_t write_element(const std::wstring& file, const omni::stack_buffer<T, SZ>& buffer, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, 0, 0, append, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_element(const wchar_t (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, 0, 0, append, false);
            }
            template < typename T, uint16_t SZ >
            uint64_t write_element(const std::wstring& file, const omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, elements, buffer_offset, append, false);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_element(const wchar_t (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, uint64_t elements, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_el_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, elements, buffer_offset, append, false);
            }

            inline uint64_t write_line(const std::wstring& file, const std::wstring& buffer, bool append) { return omni::io::wfile::write_line(file, buffer, append); }
            inline uint64_t write_line(const std::wstring& file, const std::wstring& buffer) { return omni::io::wfile::write_line(file, buffer); }
            // std::vector/deque/array/list/etc.
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const std::wstring& file, const std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, false, true);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const wchar_t (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, 0, 0, false, true);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const std::wstring& file, const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(file, buffer, length, buffer_offset, false, true);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const wchar_t (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, length, buffer_offset, false, true);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const std::wstring& file, const std_seq_t<T, std_allocator_t >& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(file, buffer, 0, 0, append, true);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const wchar_t (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, 0, 0, append, true);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const std::wstring& file, const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(file, buffer, length, buffer_offset, append, true);
            }
            template < std::size_t SZ, template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t write_line(const wchar_t (&file)[SZ], const std_seq_t<T, std_allocator_t >& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, std_seq_t, T, std_allocator_t >(std::wstring(file), buffer, length, buffer_offset, append, true);
            }
            // char buf[]/wchar_t buf[]/uintX_t buf[]
            template < typename T, std::size_t SZ >
            uint64_t write_line(const std::wstring& file, const T (&buffer)[SZ])
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, 0, 0, false, true);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_line(const wchar_t (&file)[FSZ], const T (&buffer)[SZ])
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, 0, 0, false, true);
            }
            template < typename T, std::size_t SZ >
            uint64_t write_line(const std::wstring& file, const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, length, buffer_offset, false, true);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_line(const wchar_t (&file)[FSZ], const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, length, buffer_offset, false, true);
            }
            template < typename T, std::size_t SZ >
            uint64_t write_line(const std::wstring& file, const T (&buffer)[SZ], bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, 0, 0, append, true);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_line(const wchar_t (&file)[FSZ], const T (&buffer)[SZ], bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, 0, 0, append, true);
            }
            template < typename T, std::size_t SZ >
            uint64_t write_line(const std::wstring& file, const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, length, buffer_offset, append, true);
            }
            template < std::size_t FSZ, typename T, std::size_t SZ >
            uint64_t write_line(const wchar_t (&file)[FSZ], const T (&buffer)[SZ], uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, length, buffer_offset, append, true);
            }
            // omni::stack_buffer
            template < typename T, uint16_t SZ >
            uint64_t write_line(const std::wstring& file, const omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, 0, 0, false, true);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_line(const wchar_t (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, 0, 0, false, true);
            }
            template < typename T, uint16_t SZ >
            uint64_t write_line(const std::wstring& file, const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, length, buffer_offset, false, true);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_line(const wchar_t (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, length, buffer_offset, false, true);
            }
            template < typename T, uint16_t SZ >
            uint64_t write_line(const std::wstring& file, const omni::stack_buffer<T, SZ>& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, 0, 0, append, true);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_line(const wchar_t (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, 0, 0, append, true);
            }
            template < typename T, uint16_t SZ >
            uint64_t write_line(const std::wstring& file, const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(file, buffer, length, buffer_offset, append, true);
            }
            template < std::size_t FSZ, typename T, uint16_t SZ >
            uint64_t write_line(const wchar_t (&file)[FSZ], const omni::stack_buffer<T, SZ>& buffer, uint64_t length, std::size_t buffer_offset, bool append)
            {
                return omni::io::file_internal::write_buf_fw< std::wstring, std::wofstream, T, SZ >(std::wstring(file), buffer, length, buffer_offset, append, true);
            }
            template < typename T >
            uint64_t unsafe_write_element(const std::wstring& file, const T* buffer, uint64_t elements, bool append)
            {
                return omni::io::file_internal::unsafe_write_el_fw< std::wstring, std::wofstream, T >(file, buffer, elements, append);
            }
            template < typename T >
            uint64_t unsafe_write_element(const std::wstring& file, const T* buffer, uint64_t elements)
            {
                return omni::io::file_internal::unsafe_write_el_fw< std::wstring, std::wofstream, T >(file, buffer, elements, false);
            }
            inline uint64_t unsafe_write(const std::wstring& file, const char* buffer, uint64_t length, bool append) { return omni::io::wfile::unsafe_write(file, buffer, length, append); }
            inline uint64_t unsafe_write(const std::wstring& file, const wchar_t* buffer, uint64_t length, bool append) { return omni::io::wfile::unsafe_write(file, buffer, length, append); }
            inline uint64_t unsafe_write(const std::wstring& file, const uint8_t* buffer, uint64_t length, bool append) { return omni::io::wfile::unsafe_write(file, buffer, length, append); }
            inline uint64_t unsafe_write(const std::wstring& file, const int8_t* buffer, uint64_t length, bool append) { return omni::io::wfile::unsafe_write(file, buffer, length, append); }
            inline uint64_t unsafe_write(const std::wstring& file, const char* buffer, uint64_t length) { return omni::io::wfile::unsafe_write(file, buffer, length); }
            inline uint64_t unsafe_write(const std::wstring& file, const wchar_t* buffer, uint64_t length) { return omni::io::wfile::unsafe_write(file, buffer, length); }
            inline uint64_t unsafe_write(const std::wstring& file, const uint8_t* buffer, uint64_t length) { return omni::io::wfile::unsafe_write(file, buffer, length); }
            inline uint64_t unsafe_write(const std::wstring& file, const int8_t* buffer, uint64_t length) { return omni::io::wfile::unsafe_write(file, buffer, length); }
            inline uint64_t unsafe_write_line(const std::wstring& file, const char* buffer, uint64_t length, bool append) { return omni::io::wfile::unsafe_write_line(file, buffer, length, append); }
            inline uint64_t unsafe_write_line(const std::wstring& file, const wchar_t* buffer, uint64_t length, bool append) { return omni::io::wfile::unsafe_write_line(file, buffer, length, append); }
            inline uint64_t unsafe_write_line(const std::wstring& file, const uint8_t* buffer, uint64_t length, bool append) { return omni::io::wfile::unsafe_write_line(file, buffer, length, append); }
            inline uint64_t unsafe_write_line(const std::wstring& file, const int8_t* buffer, uint64_t length, bool append) { return omni::io::wfile::unsafe_write_line(file, buffer, length, append); }
            inline uint64_t unsafe_write_line(const std::wstring& file, const char* buffer, uint64_t length) { return omni::io::wfile::unsafe_write_line(file, buffer, length); }
            inline uint64_t unsafe_write_line(const std::wstring& file, const wchar_t* buffer, uint64_t length) { return omni::io::wfile::unsafe_write_line(file, buffer, length); }
            inline uint64_t unsafe_write_line(const std::wstring& file, const uint8_t* buffer, uint64_t length) { return omni::io::wfile::unsafe_write_line(file, buffer, length); }
            inline uint64_t unsafe_write_line(const std::wstring& file, const int8_t* buffer, uint64_t length) { return omni::io::wfile::unsafe_write_line(file, buffer, length); }
        }

        namespace cdirectory {
            bool can_access(const std::string& folder);
            bool copy(const std::string& folder, const std::string& new_name, bool recursive, const omni::io::options& io_ops);
            bool copy(const std::string& folder, const std::string& new_name, bool recursive);
            bool copy(const std::string& folder, const std::string& new_name);
            bool create(const std::string& folder, const omni::io::options& io_ops);
            bool create(const std::string& folder);
            bool exists(const std::string& folder);
            bool exist(const std::string& folder);
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t get_directories(const std::string& folder, std_seq_t< T, std_allocator_t >& out)
            {
                return omni::io::dir_internal::get_directories< std::string, std_seq_t, T, std_allocator_t >(folder, out);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t get_all_directories(const std::string& folder, std_seq_t< T, std_allocator_t >& out)
            {
                return omni::io::dir_internal::get_all_directories< std::string, std_seq_t, T, std_allocator_t >(folder, out);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t get_files(const std::string& folder, std_seq_t< T, std_allocator_t >& out)
            {
                return omni::io::dir_internal::get_files< std::string, std_seq_t, T, std_allocator_t >(folder, out);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t get_all_files(const std::string& folder, std_seq_t< T, std_allocator_t >& out)
            {
                return omni::io::dir_internal::get_all_files< std::string, std_seq_t, T, std_allocator_t >(folder, out);
            }
            bool move(const std::string& folder, const std::string& new_name, const omni::io::options& io_ops);
            bool move(const std::string& folder, const std::string& new_name);
            bool rename(const std::string& folder, const std::string& new_name, const omni::io::options& io_ops);
            bool rename(const std::string& folder, const std::string& new_name);
            bool remove(const std::string& folder, bool recursive);
            bool remove(const std::string& folder);
        }
        namespace wdirectory {
            bool can_access(const std::wstring& folder);
            bool copy(const std::wstring& folder, const std::wstring& new_name, bool recursive, const omni::io::options& io_ops);
            bool copy(const std::wstring& folder, const std::wstring& new_name, bool recursive);
            bool copy(const std::wstring& folder, const std::wstring& new_name);
            bool create(const std::wstring& folder, const omni::io::options& io_ops);
            bool create(const std::wstring& folder);
            bool exists(const std::wstring& folder);
            bool exist(const std::wstring& folder);
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t get_directories(const std::wstring& folder, std_seq_t< T, std_allocator_t >& out)
            {
                return omni::io::dir_internal::get_directories< std::wstring, std_seq_t, T, std_allocator_t >(folder, out);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t get_all_directories(const std::wstring& folder, std_seq_t< T, std_allocator_t >& out)
            {
                return omni::io::dir_internal::get_all_directories< std::wstring, std_seq_t, T, std_allocator_t >(folder, out);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t get_files(const std::wstring& folder, std_seq_t< T, std_allocator_t >& out)
            {
                return omni::io::dir_internal::get_files< std::wstring, std_seq_t, T, std_allocator_t >(folder, out);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t get_all_files(const std::wstring& folder, std_seq_t< T, std_allocator_t >& out)
            {
                return omni::io::dir_internal::get_all_files< std::wstring, std_seq_t, T, std_allocator_t >(folder, out);
            }
            bool move(const std::wstring& folder, const std::wstring& new_name, const omni::io::options& io_ops);
            bool move(const std::wstring& folder, const std::wstring& new_name);
            bool rename(const std::wstring& folder, const std::wstring& new_name, const omni::io::options& io_ops);
            bool rename(const std::wstring& folder, const std::wstring& new_name);
            bool remove(const std::wstring& folder, bool recursive);
            bool remove(const std::wstring& folder);
        }
        namespace directory {
            // std::string
            inline bool can_access(const std::string& folder) { return omni::io::cdirectory::can_access(folder); }
            inline bool copy(const std::string& folder, const std::string& new_name, bool recursive, const omni::io::options& io_ops) { return omni::io::cdirectory::copy(folder, new_name, recursive, io_ops); }
            inline bool copy(const std::string& folder, const std::string& new_name, bool recursive) { return omni::io::cdirectory::copy(folder, new_name, recursive); }
            inline bool copy(const std::string& folder, const std::string& new_name) { return omni::io::cdirectory::copy(folder, new_name); }
            inline bool create(const std::string& folder, const omni::io::options& io_ops) { return omni::io::cdirectory::create(folder, io_ops); }
            inline bool create(const std::string& folder) { return omni::io::cdirectory::create(folder); }
            inline bool exists(const std::string& folder) { return omni::io::cdirectory::exists(folder); }
            inline bool exist(const std::string& folder) { return omni::io::cdirectory::exist(folder); }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t get_directories(const std::string& folder, std_seq_t< T, std_allocator_t >& out)
            {
                return omni::io::dir_internal::get_directories< std::string, std_seq_t, T, std_allocator_t >(folder, out);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t get_all_directories(const std::string& folder, std_seq_t< T, std_allocator_t >& out)
            {
                return omni::io::dir_internal::get_all_directories< std::string, std_seq_t, T, std_allocator_t >(folder, out);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t get_files(const std::string& folder, std_seq_t< T, std_allocator_t >& out)
            {
                return omni::io::dir_internal::get_files< std::string, std_seq_t, T, std_allocator_t >(folder, out);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t get_all_files(const std::string& folder, std_seq_t< T, std_allocator_t >& out)
            {
                return omni::io::dir_internal::get_all_files< std::string, std_seq_t, T, std_allocator_t >(folder, out);
            }
            inline bool move(const std::string& folder, const std::string& new_name, const omni::io::options& io_ops) { return omni::io::cdirectory::move(folder, new_name, io_ops); }
            inline bool move(const std::string& folder, const std::string& new_name) { return omni::io::cdirectory::move(folder, new_name); }
            inline bool rename(const std::string& folder, const std::string& new_name, const omni::io::options& io_ops) { return omni::io::cdirectory::rename(folder, new_name, io_ops); }
            inline bool rename(const std::string& folder, const std::string& new_name) { return omni::io::cdirectory::rename(folder, new_name); }
            inline bool remove(const std::string& folder, bool recursive) { return omni::io::cdirectory::remove(folder, recursive); }
            inline bool remove(const std::string& folder) { return omni::io::cdirectory::remove(folder); }
            // std::wstring
            inline bool can_access(const std::wstring& folder) { return omni::io::wdirectory::can_access(folder); }
            inline bool copy(const std::wstring& folder, const std::wstring& new_name, bool recursive, const omni::io::options& io_ops) { return omni::io::wdirectory::copy(folder, new_name, recursive, io_ops); }
            inline bool copy(const std::wstring& folder, const std::wstring& new_name, bool recursive) { return omni::io::wdirectory::copy(folder, new_name, recursive); }
            inline bool copy(const std::wstring& folder, const std::wstring& new_name) { return omni::io::wdirectory::copy(folder, new_name); }
            inline bool create(const std::wstring& folder, const omni::io::options& io_ops) { return omni::io::wdirectory::create(folder, io_ops); }
            inline bool create(const std::wstring& folder) { return omni::io::wdirectory::create(folder); }
            inline bool exists(const std::wstring& folder) { return omni::io::wdirectory::exists(folder); }
            inline bool exist(const std::wstring& folder) { return omni::io::wdirectory::exist(folder); }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t get_directories(const std::wstring& folder, std_seq_t< T, std_allocator_t >& out)
            {
                return omni::io::dir_internal::get_directories< std::wstring, std_seq_t, T, std_allocator_t >(folder, out);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t get_all_directories(const std::wstring& folder, std_seq_t< T, std_allocator_t >& out)
            {
                return omni::io::dir_internal::get_all_directories< std::wstring, std_seq_t, T, std_allocator_t >(folder, out);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t get_files(const std::wstring& folder, std_seq_t< T, std_allocator_t >& out)
            {
                return omni::io::dir_internal::get_files< std::wstring, std_seq_t, T, std_allocator_t >(folder, out);
            }
            template < template < class, class > class std_seq_t, class T, class std_allocator_t >
            uint64_t get_all_files(const std::wstring& folder, std_seq_t< T, std_allocator_t >& out)
            {
                return omni::io::dir_internal::get_all_files< std::wstring, std_seq_t, T, std_allocator_t >(folder, out);
            }
            inline bool move(const std::wstring& folder, const std::wstring& new_name, const omni::io::options& io_ops) { return omni::io::wdirectory::move(folder, new_name, io_ops); }
            inline bool move(const std::wstring& folder, const std::wstring& new_name) { return omni::io::wdirectory::move(folder, new_name); }
            inline bool rename(const std::wstring& folder, const std::wstring& new_name, const omni::io::options& io_ops) { return omni::io::wdirectory::rename(folder, new_name, io_ops); }
            inline bool rename(const std::wstring& folder, const std::wstring& new_name) { return omni::io::wdirectory::rename(folder, new_name); }
            inline bool remove(const std::wstring& folder, bool recursive) { return omni::io::wdirectory::remove(folder, recursive); }
            inline bool remove(const std::wstring& folder) { return omni::io::wdirectory::remove(folder); }
        }

        namespace cpath {
            std::string change_extension(const std::string& path, const std::string& extension);
            std::string combine(const omni::sequence::std_string_t& paths, const std::string& seperator);
            inline std::string combine(const omni::sequence::std_string_t& paths) { return omni::io::cpath::combine(paths, std::string(OMNI_PATH_SEPARATOR)); }
            std::string combine(const std::string& path1, const std::string& path2);
            template < std::size_t SZ >
            inline std::string combine(const std::string& path1, const char (&data)[SZ]) { return omni::io::cpath::combine(path1, std::string(data)); }
            std::string get_extension(const std::string& path);
            std::string get_name(const std::string& path);
            std::string get_name_without_extension(const std::string& path);
            std::string get_parent_name(const std::string& path);
            std::string generate(const std::string& path);
            std::string generate(const std::string& path, const std::string& file);
            std::string generate(const std::string& path, const std::string& file, const std::string& ext);
            omni::seq::char_t get_invalid_file_chars();
            omni::seq::char_t get_invalid_path_chars();
            bool has_extension(const std::string& path);
            bool is_path_absolute(const std::string& path);
            std::string trim_trailing_slash(const std::string& path);
        }
        namespace wpath {
            std::wstring change_extension(const std::wstring& path, const std::wstring& extension);
            std::wstring combine(const omni::sequence::std_wstring_t& paths, const std::wstring& seperator);
            inline std::wstring combine(const omni::sequence::std_wstring_t& paths) { return omni::io::wpath::combine(paths, std::wstring(OMNI_WPATH_SEPARATOR)); }
            std::wstring combine(const std::wstring& path1, const std::wstring& path2);
            template < std::size_t SZ >
            inline std::wstring combine(const std::wstring& path1, const wchar_t (&data)[SZ]) { return omni::io::wpath::combine(path1, std::wstring(data)); }
            std::wstring get_extension(const std::wstring& path);
            std::wstring get_name(const std::wstring& path);
            std::wstring get_name_without_extension(const std::wstring& path);
            std::wstring get_parent_name(const std::wstring& path);
            std::wstring generate(const std::wstring& path);
            std::wstring generate(const std::wstring& path, const std::wstring& file);
            std::wstring generate(const std::wstring& path, const std::wstring& file, const std::wstring& ext);
            omni::seq::wide_char_t get_invalid_file_chars();
            omni::seq::wide_char_t get_invalid_path_chars();
            bool has_extension(const std::wstring& path);
            bool is_path_absolute(const std::wstring& path);
            std::wstring trim_trailing_slash(const std::wstring& path);
        }
        namespace path {
            // std::string
            inline std::string change_extension(const std::string& path, const std::string& extension) { return omni::io::cpath::change_extension(path, extension); }
            inline std::string combine(const omni::sequence::std_string_t& paths, const std::string& seperator) { return omni::io::cpath::combine(paths, seperator); }
            inline std::string combine(const omni::sequence::std_string_t& paths) { return omni::io::cpath::combine(paths, std::string(OMNI_PATH_SEPARATOR)); }
            inline std::string combine(const std::string& path1, const std::string& path2) { return omni::io::cpath::combine(path1, path2); }
            template < std::size_t SZ >
            inline std::string combine(const std::string& path1, const char (&data)[SZ]) { return omni::io::cpath::combine(path1, std::string(data)); }
            inline std::string get_extension(const std::string& path) { return omni::io::cpath::get_extension(path); }
            inline std::string get_name(const std::string& path) { return omni::io::cpath::get_name(path); }
            inline std::string get_name_without_extension(const std::string& path) { return omni::io::cpath::get_name_without_extension(path); }
            inline std::string get_parent_name(const std::string& path) { return omni::io::cpath::get_parent_name(path); }
            inline std::string generate(const std::string& path) { return omni::io::cpath::generate(path); }
            inline std::string generate(const std::string& path, const std::string& file) { return omni::io::cpath::generate(path, file); }
            inline std::string generate(const std::string& path, const std::string& file, const std::string& ext) { return omni::io::cpath::generate(path, file, ext); }
            inline omni::seq::char_t get_invalid_file_chars() { return omni::io::cpath::get_invalid_file_chars(); }
            inline omni::seq::char_t get_invalid_path_chars() { return omni::io::cpath::get_invalid_path_chars(); }
            inline bool has_extension(const std::string& path) { return omni::io::cpath::has_extension(path); }
            inline bool is_path_absolute(const std::string& path) { return omni::io::cpath::is_path_absolute(path); }
            inline std::string trim_trailing_slash(const std::string& path) { return omni::io::cpath::trim_trailing_slash(path); }
            // std::wstring
            inline std::wstring change_extension(const std::wstring& path, const std::wstring& extension) { return omni::io::wpath::change_extension(path, extension); }
            inline std::wstring combine(const omni::sequence::std_wstring_t& paths, const std::wstring& seperator) { return omni::io::wpath::combine(paths, seperator); }
            inline std::wstring combine(const omni::sequence::std_wstring_t& paths) { return omni::io::wpath::combine(paths, std::wstring(OMNI_WPATH_SEPARATOR)); }
            inline std::wstring combine(const std::wstring& path1, const std::wstring& path2) { return omni::io::wpath::combine(path1, path2); }
            template < std::size_t SZ >
            inline std::wstring combine(const std::wstring& path1, const wchar_t (&data)[SZ]) { return omni::io::wpath::combine(path1, std::wstring(data)); }
            inline std::wstring get_extension(const std::wstring& path) { return omni::io::wpath::get_extension(path); }
            inline std::wstring get_name(const std::wstring& path) { return omni::io::wpath::get_name(path); }
            inline std::wstring get_name_without_extension(const std::wstring& path) { return omni::io::wpath::get_name_without_extension(path); }
            inline std::wstring get_parent_name(const std::wstring& path) { return omni::io::wpath::get_parent_name(path); }
            inline std::wstring generate(const std::wstring& path) { return omni::io::wpath::generate(path); }
            inline std::wstring generate(const std::wstring& path, const std::wstring& file) { return omni::io::wpath::generate(path, file); }
            inline std::wstring generate(const std::wstring& path, const std::wstring& file, const std::wstring& ext) { return omni::io::wpath::generate(path, file, ext); }
            inline omni::seq::wide_char_t get_invalid_file_wchars() { return omni::io::wpath::get_invalid_file_chars(); }
            inline omni::seq::wide_char_t get_invalid_path_wchars() { return omni::io::wpath::get_invalid_path_chars(); }
            inline bool has_extension(const std::wstring& path) { return omni::io::wpath::has_extension(path); }
            inline bool is_path_absolute(const std::wstring& path) { return omni::io::wpath::is_path_absolute(path); }
            inline std::wstring trim_trailing_slash(const std::wstring& path) { return omni::io::wpath::trim_trailing_slash(path); }
        }
    }
}

#define OMNI_IO_PATH_COMBINE_FW 1
#include <omni/xx/io/path_combine.hxx>
#undef OMNI_IO_PATH_COMBINE_FW

#endif // OMNI_IO_HPP