UniSharping (version 1.5): supported C# classes and its members

C# class or memberJava analogPython analog
delegate Action<T>Action (our service class) 
   void call(T)   {!}.call({0}) 
class AppDomainignored in Javaignored in Python
   AppDomain static CurrentDomain   Ignored in Java   Ignored in Python
   string BaseDirectory { get; }   get: (new java.io.File("")).getAbsolutePath()   get: os.path.dirname(os.path.realpath(__file__))
class ApplicationException : Exceptionjava.lang.ExceptionException
class ArgumentException : Exceptionjava.lang.IllegalArgumentExceptionException
class ArgumentNullException : Exceptionjava.lang.IllegalArgumentExceptionException
class ArgumentOutOfRangeException : Exceptionjava.lang.IndexOutOfBoundsExceptionException
static class Array  
   void Clear(?)   Generate code by inner hardcode procedure 
   void Copy(?)   model by operator 'for' in code 
   void Copy(?)   model by operator 'for' in code 
   int IndexOf(byte[], byte, *)   Utils.indexOfBytes({0}, {1}, {2=0}) 
   int IndexOf(char[], char, *)   Utils.indexOfChars({0}, {1}, {2=0}) 
   int IndexOf(int[], int, *)   Utils.indexOfInts({0}, {1}, {2=0}) 
   void Resize(ref ?)   Arrays.copyOf 
class ArrayList : List [object]java.util.ArrayList 
class Assemblyignored in Javaignored in Python
   object GetManifestResourceInfo(string)   Generate code by inner hardcode procedure   Generate code by inner hardcode procedure
   string[] GetManifestResourceNames()   Generate code by inner hardcode procedure   Generate code by inner hardcode procedure
   Stream GetManifestResourceStream(string)   Generate code by inner hardcode procedure   Generate code by inner hardcode procedure
   Type[] GetTypes()   Generate code by inner hardcode procedure 
   static Assembly GetCallingAssembly()   Ignored in Java   Ignored in Python
   static Assembly GetEntryAssembly()   Ignored in Java   Ignored in Python
   static Assembly GetExecutingAssembly()   Ignored in Java   Ignored in Python
static class Assertorg.junit.Assert (import unittest)
   void AreEqual(object, object, string)   org.junit.Assert.assertEquals({2}, {0}, {1})   self.assertEquals({0}, {1}, {2})
   void AreEqual(object, object)   org.junit.Assert.assertEquals({0}, {1})   self.assertEquals({0}, {1})
   void AreNotEqual(object, object)   org.junit.Assert.assertNotEquals({0}, {1})   self.assertNotEquals({0}, {1})
   void AreNotEqual(object, object, string)   org.junit.Assert.assertNotEquals({2}, {0}, {1})   self.assertNotEquals({0}, {1}, {2})
   void AreNotSame(object, object)   org.junit.Assert.assertNotSame({0}, {1})   self.assertNotIs({0}, {1})
   void AreNotSame(object, object, string)   org.junit.Assert.assertNotSame({2}, {0}, {1})   self.assertNotIs({0}, {1}, {2})
   void AreSame(object, object, string)   org.junit.Assert.assertSame({2}, {0}, {1})   self.assertIs({0}, {1}, {2})
   void AreSame(object, object)   org.junit.Assert.assertSame({0}, {1})   self.assertIs({0}, {1})
   void Fail(string)   org.junit.Assert.fail({0})   self.assertTrue(False, {0})
   void Fail()   org.junit.Assert.fail()   self.assertTrue(False)
   void IsFalse(bool)   org.junit.Assert.assertFalse({0})   self.assertFalse({0})
   void IsFalse(bool, string)   org.junit.Assert.assertFalse({1}, {0})   self.assertFalse({0}, {1})
   void IsNotNull(object)   org.junit.Assert.assertNotNull({0})   self.assertIsNotNone({0})
   void IsNotNull(object, string)   org.junit.Assert.assertNotNull({1}, {0})   self.assertIsNotNone({0})
   void IsNull(object)   org.junit.Assert.assertNull({0})   self.assertIsNone({0})
   void IsNull(object, string)   org.junit.Assert.assertNull({1}, {0})   self.assertIsNone({0}, {1})
   void IsTrue(bool, string)   org.junit.Assert.assertTrue({1}, {0})   self.assertTrue({0}, {1})
   void IsTrue(bool)   org.junit.Assert.assertTrue({0})   self.assertTrue({0})
class Attributeignored in Javaignored in Python
static class BitConverter  
   byte[] GetBytes(long)   java.nio.ByteBuffer.allocate(8).order(java.nio.ByteOrder.LITTLE_ENDIAN).putLong({0}).array()   ({0}).to_bytes(8, byteorder="little")
   byte[] GetBytes(uint)   java.nio.ByteBuffer.allocate(4).order(java.nio.ByteOrder.LITTLE_ENDIAN).putInt({0}).array()   ({0}).to_bytes(4, byteorder="little")
   byte[] GetBytes(ulong)   java.nio.ByteBuffer.allocate(8).order(java.nio.ByteOrder.LITTLE_ENDIAN).putLong({0}).array()   ({0}).to_bytes(8, byteorder="little")
   byte[] GetBytes(double)   java.nio.ByteBuffer.allocate(8).order(java.nio.ByteOrder.LITTLE_ENDIAN).putDouble({0}).array()   bytearray(struct.pack("d", {0})) (import struct)
   byte[] GetBytes(float)   java.nio.ByteBuffer.allocate(4).order(java.nio.ByteOrder.LITTLE_ENDIAN).putFloat({0}).array()   bytearray(struct.pack("f", {0})) (import struct)
   byte[] GetBytes(int)   java.nio.ByteBuffer.allocate(4).order(java.nio.ByteOrder.LITTLE_ENDIAN).putInt({0}).array()   ({0}).to_bytes(4, byteorder="little")
   byte[] GetBytes(byte)   java.nio.ByteBuffer.allocate(1).put({0}).array()   ({0}).to_bytes(1, byteorder="little")
   byte[] GetBytes(bool)   java.nio.ByteBuffer.allocate(1).put((byte)({0} ? 1 : 0)).array()   int({0}).to_bytes(1, byteorder="little")
   byte[] GetBytes(char)   java.nio.ByteBuffer.allocate(2).order(java.nio.ByteOrder.LITTLE_ENDIAN).putChar({0}).array()   ({0}).to_bytes(2, byteorder="little")
   byte[] GetBytes(ushort)   java.nio.ByteBuffer.allocate(2).order(java.nio.ByteOrder.LITTLE_ENDIAN).putShort({0}).array()   ({0}).to_bytes(2, byteorder="little")
   byte[] GetBytes(short)   java.nio.ByteBuffer.allocate(2).order(java.nio.ByteOrder.LITTLE_ENDIAN).putShort({0}).array()   ({0}).to_bytes(2, byteorder="little")
   bool ToBoolean(byte[], int)   ({0})[{1}] == (byte)1   ({0})[{1}] == 1
   bool ToByte(byte[], int)   ({0})[{1}]   int.from_bytes({0}[{1}:{1}+1], byteorder="little")
   char ToChar(byte[], int)   java.nio.ByteBuffer.wrap({0}, {1}, 2).order(java.nio.ByteOrder.LITTLE_ENDIAN).getChar()   int.from_bytes({0}[{1}:{1}+2], byteorder="little")
   float ToDouble(byte[], int)   java.nio.ByteBuffer.wrap({0}, {1}, 8).order(java.nio.ByteOrder.LITTLE_ENDIAN).getDouble()   struct.unpack('d', {0}[{1}:{1}+8])[0] (import struct)
   short ToInt16(byte[], int)   java.nio.ByteBuffer.wrap({0}, {1}, 2).order(java.nio.ByteOrder.LITTLE_ENDIAN).getShort()   int.from_bytes({0}[{1}:{1}+2], byteorder="little")
   int ToInt32(byte[], int)   java.nio.ByteBuffer.wrap({0}, {1}, 4).order(java.nio.ByteOrder.LITTLE_ENDIAN).getInt()   int.from_bytes({0}[{1}:{1}+2], byteorder="little")
   long ToInt64(byte[], int)   java.nio.ByteBuffer.wrap({0}, {1}, 8).order(java.nio.ByteOrder.LITTLE_ENDIAN).getLong()   int.from_bytes({0}[{1}:{1}+8], byteorder="little")
   float ToSingle(byte[], int)   java.nio.ByteBuffer.wrap({0}, {1}, 4).order(java.nio.ByteOrder.LITTLE_ENDIAN).getFloat()   struct.unpack('f', {0}[{1}:{1}+4])[0] (import struct)
   ushort ToUInt16(byte[], int)   java.nio.ByteBuffer.wrap({0}, {1}, 2).order(java.nio.ByteOrder.LITTLE_ENDIAN).getShort()   int.from_bytes({0}[{1}:{1}+2], byteorder="little")
   uint ToUInt32(byte[], int)   java.nio.ByteBuffer.wrap({0}, {1}, 4).order(java.nio.ByteOrder.LITTLE_ENDIAN).getInt()   int.from_bytes({0}[{1}:{1}+2], byteorder="little")
   ulong ToUInt64(byte[], int)   java.nio.ByteBuffer.wrap({0}, {1}, 8).order(java.nio.ByteOrder.LITTLE_ENDIAN).getLong()   int.from_bytes({0}[{1}:{1}+8], byteorder="little")
class boolboolean / java.lang.Booleanbool
static class Buffer  
   void BlockCopy(byte[], int, byte[], int, int)   model by operator 'for' in code 
   int ByteLength(byte[])   {0}.size() 
class bytebyte / java.lang.Byteint
   string ToString(string)   model by String.format(format, val), format must be string lexem   model by 'format', format must be string lexem
   static byte Parse(string)   Utils.parseByte({0})   int({0})
   static bool TryParse(string, out byte)   Utils.parseByte({0}, {1})   Utils.tryParseInt({0}, {1})
class CancelEventArgsCancelEventArgs (our service class)CancelEventArgs (our service class)
   bool Cancel   {!}.cancel   {!}.cancel
    .ctor()   .ctor()   .ctor()
delegate CancelEventHandlerCancelEventHandler (our service class)EventHandler (our service class)
   void call(object, CancelEventArgs)   {!}.call({0}, {1})   {!}.call({0}, {1})
class charchar / java.lang.Characterstr
   static int GetNumericValue(char)   Character.getNumericValue({0}) 
   static bool IsDigit(char)   Character.isDigit({0})   str.isdigit({0})
   static bool IsLetter(char)   Character.isLetter({0})   str.isalpha({0})
   static bool IsLetterOrDigit(char)   Character.isLetterOrDigit({0})   str.isalnum({0})
   static bool IsLower(char)   Character.isLowerCase({0})   str.islower({0})
   static bool IsUpper(char)   Character.isUpperCase({0})   str.isupper({0})
   static bool IsWhiteSpace(char)   Utils.isWhitespace({0})   Utils.isWhitespace({0})
   static char ToLower(char)   Character.toLowerCase({0})   str.lower({0})
   static char ToUpper(char)   Character.toUpperCase({0})   str.upper({0})
class Collection<T> : IList [T]java.util.ArrayList<T>list<T>
    .ctor(IEnumerable<T>)   modeled by ArrayList   modeled by bytearray or list (depends on type)
    .ctor()   .ctor()   modeled by bytearray or list (depends on type)
enum CompressionModebooleanstr
    static Compress   true   'w'
    static Decompress   false   'r'
static class ConsoleSystem.out 
   object ReadKey()   System.in.read()   sys.stdin.read(1) (import sys)
   string ReadLine()   Utils.consoleReadLine()   sys.stdin.readline() (import sys)
   void Write(string, *)   Model constant format string by operators   Model constant format string by operators
   void Write(?)   System.out.print({0})   print({0}, end="", flush=True)
   void Write()   System.out.print()   print("", end="", flush=True)
   void WriteLine()   System.out.println()   print("")
   void WriteLine(?)   System.out.println({0})   print({0}, flush=True)
   void WriteLine(string, *)   Model constant format string by operators   Model constant format string by operators
class ConstructorInfojava.lang.reflect.Constructor 
   object Invoke(object[])   {!}.newInstance({0}) 
static class Convert  (import base64)
   byte[] FromBase64String(string)   java.util.Base64.getDecoder().decode(({0}).replace("\r", "").replace("\n", ""))   base64.decodestring(({0}).encode('utf-8', 'ignore'))
   string ToBase64String(byte[])   new String(java.util.Base64.getEncoder().encode({0}))   base64.encodestring({0}).decode('utf-8', 'ignore')
   long ToDouble(?)   Generate code by inner hardcode procedure 
   short ToInt16(?)   Generate code by inner hardcode procedure 
   int ToInt32(?)   Generate code by inner hardcode procedure 
   long ToInt64(?)   Generate code by inner hardcode procedure 
   long ToSingle(?)   Generate code by inner hardcode procedure 
   ushort ToUInt16(?)   Generate code by inner hardcode procedure 
   uint ToUInt32(?)   Generate code by inner hardcode procedure 
   long ToUInt64(?)   Generate code by inner hardcode procedure 
struct DateTimejava.time.LocalDateTimedatetime.datetime (import datetime)
   DateTime static MaxValue   java.time.LocalDateTime.MAX   datetime.datetime.max
   DateTime static MinValue   java.time.LocalDateTime.MIN   datetime.datetime.min
   DateTime Date { get; }   get: java.time.LocalDateTime.of({!}.toLocalDate(), java.time.LocalTime.of(0, 0))   get: Utils.getDate({!})
   int Day { get; }   get: {!}.getDayOfMonth()   get: {!}.day
   DayOfWeek DayOfWeek { get; }   get: {!}.getDayOfWeek()   get: {!}.weekday()
   int DayOfYear { get; }   get: {!}.getDayOfYear()   get: {!}.timetuple().tm_yday
   int Hour { get; }   get: {!}.getHour()   get: {!}.hour
   int Millisecond { get; }   get: ({!}.getNano() / 1000000)   get: ({!}.microsecond / 1000)
   int Minute { get; }   get: {!}.getMinute()   get: {!}.minute
   int Month { get; }   get: {!}.getMonthValue()   get: {!}.month
   int Second { get; }   get: {!}.getSecond()   get: {!}.second
   int Year { get; }   get: {!}.getYear()   get: {!}.year
   DateTime static Now { get; }   get: java.time.LocalDateTime.now()   get: datetime.datetime.now()
   DateTime static Today { get; }   get: java.time.LocalDateTime.of(java.time.LocalDate.now(), java.time.LocalTime.of(0, 0))   get: Utils.getDate(datetime.datetime.today())
    .ctor(*)   java.time.LocalDateTime.of({0=1}, {1=1}, {2=1}, {3=0}, {4=0}, {5=0})   datetime.datetime({0=1}, {1=1}, {2=1}, {3=0}, {4=0}, {5=0})
   DateTime AddDays(int)   {!}.plusDays({0})   ({!} + datetime.timedelta(days={0}))
   DateTime AddHours(int)   {!}.plusHours({0})   ({!} + datetime.timedelta(hours={0}))
   DateTime AddMinutes(int)   {!}.plusMinutes({0})   ({!} + datetime.timedelta(minutes={0}))
   DateTime AddMonths(int)   {!}.plusMonths({0})   ({!} + datetime.timedelta(days={0}*30))
   DateTime AddSeconds(int)   {!}.plusSeconds({0})   ({!} + datetime.timedelta(seconds={0}))
   DateTime AddYears(int)   {!}.plusYears({0})   ({!} + datetime.timedelta(days={0}*365))
   string ToShortDateString()   {!}.toLocalDate().toString()   Utils.getDateShortString({!})
   string ToShortTimeString()   {!}.toLocalTime().toString()   Utils.getTimeShortString({!})
   static int DaysInMonth(int, int)   Utils.daysInMonth({0}, {1})   Utils.lastDayOfMonth({0}, {1})
   static DateTime FromFileTime(long)   Utils.getDateTimeFromFileTime({0}) 
   static DateTime FromFileTimeUtc(long)   Utils.getDateTimeFromFileTime({0}) 
   static DateTime Parse(string)   java.time.LocalDateTime.parse({0}) 
   static bool TryParse(string, ref DateTime)   Utils.parseDateTime({0}, {1}) 
enum DayOfWeekjava.time.DayOfWeekint
    static Friday   java.time.DayOfWeek.FRIDAY   4
    static Monday   java.time.DayOfWeek.MONDAY   0
    static Saturday   java.time.DayOfWeek.SATURDAY   5
    static Sunday   java.time.DayOfWeek.SUNDAY   6
    static Thursday   java.time.DayOfWeek.THURSDAY   3
    static Tuesday   java.time.DayOfWeek.TUESDAY   1
    static Wednesday   java.time.DayOfWeek.WEDNESDAY   2
class DeflateStream : StreamDeflateStream (our service class) 
    .ctor(Stream, CompressionMode, *)   new DeflateStream({0}, {1}) DeflateStream works not equals in .NET and Java, better use GZipStream! 
class Dictionary<K, V> : IDictionaryjava.util.HashMap<K, V>dict<K, V>
    .ctor(IDictionary<K, V>)   .ctor({0})   .ctor({0})
    .ctor(int)   new java.util.HashMap()   dict()
    .ctor()   .ctor()   .ctor()
static class Directory  
   object CreateDirectory(string)   (new java.io.File({0})).mkdir()   pathlib.Path({0}).mkdir(exist_ok=True) (import pathlib)
   void Delete(string, *)   Utils.deleteDirectory(new java.io.File({0}))   shutil.rmtree({0}, ignore_errors=True) (import shutil)
   bool Exists(string)   ((new java.io.File({0})).exists() && (new java.io.File({0})).isDirectory())   pathlib.Path({0}).is_dir() (import pathlib)
   string GetCurrentDirectory()   (new java.io.File("")).getAbsolutePath()   os.getcwd() (import os)
   string[] GetDirectories(string, string)   Utils.getDirectoryItems({0}, {1}, true)   [os.path.abspath(x) for x in os.listdir(os.path.join({0}, {1})) if os.path.isdir(os.path.join({0}, f))] (import os)
   string[] GetDirectories(string)   Utils.getDirectoryItems({0}, null, true)   [os.path.abspath(x) for x in os.listdir({0}) if os.path.isdir(os.path.join({0}, f))] (import os)
   string[] GetFiles(string, string)   Utils.getDirectoryItems({0}, {1}, false)   [os.path.abspath(x) for x in os.listdir(os.path.join({0}, {1})) if os.path.isfile(os.path.join({0}, f))] (import os)
   string[] GetFiles(string)   Utils.getDirectoryItems({0}, null, false)   [os.path.abspath(x) for x in os.listdir({0}) if os.path.isfile(os.path.join({0}, f))] (import os)
   void SetCurrentDirectory(string)   Utils.setCurrentDirectory({0})   os.chdir({0}) (import os)
class DirectoryInfojava.io.Filepathlib.Path (import pathlib)
   DateTime CreationTime { get; }   get: Utils.getFileCreationTime({!})   get: Utils.getDateTimeFromCtime(os.path.getmtime({!}.absolute())) (import os)
   bool Exists { get; }   get: {!}.exists()   get: {!}.is_dir()
   string FullName { get; }   get: {!}.getAbsolutePath()   get: {!}.absolute()
   DateTime LastWriteTime { get; }   get: Utils.getFileModifiedTime({!})   get: Utils.getDateTimeFromCtime(os.path.getctime({!}.absolute())) (import os)
   string Name { get; }   get: {!}.getPath()   get: {!}.name
    .ctor(string)   .ctor({0})   .ctor({0})
   void Create()   {!}.mkdir()   pathlib.Path({!}.absolute()).mkdir(exist_ok=True)
   void Delete(*)   {!}.delete({0})   shutil.rmtree(pathlib.Path(dname).absolute(), ignore_errors=True) (import shutil)
class doubledouble / java.lang.Doublefloat
   double static MaxValue   Double.MAX_VALUE 
   double static MinValue   -Double.MAX_VALUE 
   double static NaN   Double.NaN   math.nan (import math)
   double static NegativeInfinity   Double.NEGATIVE_INFINITY   -math.inf (import math)
   double static PositiveInfinity   Double.POSITIVE_INFINITY   math.inf (import math)
   string ToString(NumberFormatInfo)   {0}.format({!}) 
   string ToString(string)   model by String.format(format, val), format must be string lexem   model by 'format', format must be string lexem
   static bool IsInfinity(double)   Double.isInfinite({0})   math.isinf({0}) (import math)
   static bool IsNaN(double)   Double.isNaN({0})   math.isnan({0}) (import math)
   static bool IsNegativeInfinity(double)   ({0} == Double.NEGATIVE_INFINITY)   ({0} == -float('inf'))
   static bool IsPositiveInfinity(double)   ({0} == Double.POSITIVE_INFINITY)   ({0} == float('inf'))
   static double Parse(string)   Utils.parseDouble({0}, null)   float({0})
   static double Parse(string, ?)   Utils.parseDouble({0}, {2}) 
   static bool TryParse(string, out double)   Utils.parseDouble({0}, null, {1})   Utils.tryParseFloat({0}, {1})
   static bool TryParse(string, ?)   Utils.parseDouble({0}, {2}, {3}) 
class Encodingjava.nio.charset.Charsetstr
   Encoding static ASCII { get; }   get: java.nio.charset.Charset.forName("ASCII")   get: error ASCII not supported in python
   Encoding static BigEndianUnicode { get; }   get: java.nio.charset.Charset.forName("UTF-16BE")   get: error this encoding not supported in python
   Encoding static Unicode { get; }   get: java.nio.charset.Charset.forName("UTF-16LE")   get: error this encoding not supported in python
   Encoding static UTF8 { get; }   get: java.nio.charset.Charset.forName("UTF-8")   get: "UTF-8"
   byte[] GetBytes(string)   Utils.encodeCharset({!}, {0})   modeled by 'encode', support only utf-8
   char[] GetChars(byte[], *)   Utils.decodeCharsetArr({!}, {0}, {1=0}, {2=-1})   modeled by 'decode', support only utf-8
   byte[] GetPreamble()   Utils.preambleCharset({!})   Utils.preambleCharset({!})
   string GetString(byte[], *)   Utils.decodeCharset({!}, {0}, {1=0}, {2=-1})   modeled by 'decode', support only utf-8
   static Encoding GetEncoding(string)   Utils.getCharsetByName({0}) 
   static Encoding GetEncoding(int)   Utils.getCharsetByName("windows-" + {0}) 
class EndOfStreamException : Exceptionjava.io.EOFExceptionException
static class Enum  
   object[] GetValues(?)   static method 'getValues' in generated wrapper class for enum 
   bool IsDefined(?)   static method 'isDefined' in generated wrapper class for enum 
   object Parse(?)   static method 'of' in generated wrapper class for enum   model by Unit.valToEnum(...)
   object ToObject(?)   static method 'of' in generated wrapper class for enum   enum(v)
class Environmentignored in Java 
   string static MachineName   Utils.getMachineName() 
   string static UserName   System.getProperty("user.name") 
class EventArgsjava.lang.Object 
   EventArgs static Empty   Utils.EMPTYEVENTARGS 
delegate EventHandler<T>EventHandler (our service class)EventHandler (our service class)
   void call(object, T)   {!}.call({0}, {1})   {!}.call({0}, {1})
class Exceptionjava.lang.ExceptionException
   string Message { get; }   get: {!}.getMessage()   get: {!}.__str__()
    .ctor(string, Exception)   .ctor({0}, {1})   Utils.newException({0}, {1})
    .ctor(string)   .ctor({0})   Utils.newException({0}, None)
    .ctor()   .ctor()   .ctor()
static class File  (import pathlib)
   void Copy(string, string, *)   Utils.copyFile({0}, {1})   shutil.copy({0}, {1}) (import shutil)
   FileStream Create(string)   modeled by constructor of our service FileStream   modeled by open({0}, mode="...")
   void Delete(string)   (new java.io.File({0})).delete()   pathlib.Path({0}).unlink()
   bool Exists(string)   ((new java.io.File({0})).exists() && (new java.io.File({0})).isFile())   pathlib.Path({0}).is_file()
   DateTime GetCreationTime(string)   Utils.getFileCreationTime(new java.io.File({0}))   Utils.getDateTimeFromCtime(os.path.getctime({0})) (import os)
   DateTime GetCreationTimeUtc(string)   Utils.getFileCreationTime(new java.io.File({0})) 
   DateTime GetLastWriteTime(string)   Utils.getFileModifiedTime(new java.io.File({0}))   Utils.getDateTimeFromCtime(os.path.getmtime({0})) (import os)
   DateTime GetLastWriteTimeUtc(string)   Utils.getFileModifiedTime(new java.io.File({0})) 
   void Move(string, string)   Utils.moveFile({0}, {1})   shutil.move({0}, {1}) (import shutil)
   FileStream Open(string, *)   modeled by constructor of our service FileStream   modeled by open({0}, mode="...")
   byte[] ReadAllBytes(string)   Utils.readAllBytes({0})   pathlib.Path({0}).read_bytes()
   string ReadAllText(string, *)   Utils.readAllText({0}, null)   Utils.fileReadAllText({0})
   void WriteAllBytes(string, byte[])   Utils.writeAllBytes({0}, {1})   pathlib.Path({0}).write_bytes({1})
   void WriteAllText(string, string, *)   Utils.writeAllText({0}, {1}, null)   Utils.fileWriteAllText({0}, {1})
enum FileAccessjava.lang.Stringstr
    static Read   "r"   'r'
    static ReadWrite   "rw"   'rw'
    static Write   "w"   'w'
class FileInfojava.io.Filepathlib.Path (import pathlib)
   DateTime CreationTime { get; }   get: Utils.getFileCreationTime({!})   get: Utils.getDateTimeFromCtime(os.path.getmtime({!}.absolute())) (import os)
   string DirectoryName { get; }   get: {!}.getAbsoluteFile().getParent()   get: {!}.parent.absolute()
   bool Exists { get; }   get: {!}.exists()   get: {!}.is_file()
   string FullName { get; }   get: {!}.getAbsolutePath()   get: {!}.absolute()
   DateTime LastWriteTime { get; }   get: Utils.getFileModifiedTime({!})   get: Utils.getDateTimeFromCtime(os.path.getctime({!}.absolute())) (import os)
   long Length { get; }   get: {!}.length()   get: {!}.stat().st_size
   string Name { get; }   get: {!}.getPath()   get: {!}.name
    .ctor(string)   .ctor({0})   .ctor({0})
   void Delete()   {!}.delete()   {!}.unlink()
enum FileModejava.lang.Stringstr
    static Append   "APPEND"   'append'
    static Create   "CREATE"   'create'
    static CreateNew   "CREATENEW"   'createnew'
    static Open   "OPEN"   'open'
    static OpenOrCreate   "OPENORCREATE"   'openorcreate'
    static Truncate   "TRUNCATE"   'truncate'
class FileNotFoundException : Exceptionjava.io.FileNotFoundExceptionFileNotFoundError
enum FileSharejava.lang.Stringstr
    static Delete   "DELETE"   'delete'
    static Inheritable   "INHERIT"   'inherit'
    static None   ""   ''
    static Read   "READ"   'read'
    static ReadWrite   "READWRITE"   'readwrite'
    static Write   "WRITE"   'write'
class FileStream : StreamFileStream (our service class)io.FileIO (import io)
   string Name { get; }   get: {!}.getName()   get: {!}.name
    .ctor(string, *)   modeled by constructor of our service FileStream   modeled by open({0}, mode="...")
class floatfloat / java.lang.Floatfloat
   string ToString(NumberFormatInfo)   {0}.format({!}) 
   string ToString(string)   model by String.format(format, val), format must be string lexem   model by 'format', format must be string lexem
   static bool IsInfinity(float)   Float.isInfinite({0})   math.isinf({0}) (import math)
   static bool IsNaN(float)   Float.isNaN({0})   math.isnan({0}) (import math)
   static float Parse(string)   Utils.parseFloat({0}, null)   float({0})
   static float Parse(string, ?)   Utils.parseFloat({0}, {2}) 
   static bool TryParse(string, out float)   Utils.parseFloat({0}, null, {1})   Utils.tryParseFloat({0}, {1})
   static bool TryParse(string, ?)   Utils.parseFloat({0}, {2}, {3}) 
class FormatException : Exceptionjava.lang.NumberFormatExceptionException
delegate Func<T, R>Func (our service class) 
   R call(T)   {!}.call({0}) 
class GCjava.lang.System (import gc)
   static void Collect()   System.gc()   gc.collect()
   static long GetTotalMemory(bool)   Utils.getTotalMemory({0}) 
   static void SuppressFinalize(*)   Ignored in Java   Ignored in Python
class GroupRegexGroupWrapper (our service class) 
   int Index   {!}.index 
   int Length   {!}.length 
   string Value   {!}.value 
struct Guidjava.util.UUIDuuid.UUID (import uuid)
   Guid static Empty { get; }   get: Utils.EMPTYUUID   get: Utils.EMPTYUUID
    .ctor(string)   java.util.UUID.fromString({0})   .ctor({0})
    .ctor(byte[])   Utils.getUUIDFromBytes({0})   uuid.UUID(bytes={0})
    .ctor()   new java.util.UUID(0, 0)   {!}.uuid.UUID('{00000000-0000-0000-0000-000000000000}')()
   bool Equals(object)   {!}.equals({0})   ({!} == {0})
   byte[] ToByteArray()   Utils.getBytesFromUUID({!})   {!}.bytes
   static Guid NewGuid()   java.util.UUID.randomUUID()   uuid.uuid4()
class GZipStream : StreamGZipStream (our service class)gzip.GzipFile (import gzip)
    .ctor(Stream, CompressionMode, *)   new GZipStream({0}, {1})   gzip.GzipFile(fileobj={0}, mode={1})
class HashTable<K, V> : Dictionaryjava.util.HashMap<K, V>dict<K, V>
class HttpUtility  
   static string UrlDecode(string, Encoding)   java.net.URLDecoder.decode({0}, ({1}).name()) 
   static string UrlEncode(string, Encoding)   java.net.URLEncoder.encode({0}, ({1}).name()) 
interface ICloneablejava.lang.Cloneable 
   object Close()   {!}.clone() 
interface ICollection<T> : IEnumerable [T]java.util.Collection<T>list<T>
   int Count { get; }   get: {!}.size()   get: len({!})
   void Add(T)   {!}.add({0})   {!}.append({0})
   void Clear()   {!}.clear()   {!}.clear()
   bool Contains(T)   {!}.contains({0})   {0} in {!}
   void Remove(T)   {!}.remove({0})   {!}.remove({0})
interface IComparable<T>java.lang.Comparable<T> 
   int CompareTo(T)   {!}.compareTo({0})   {!}.compareTo({0})
interface IComparer<T>java.util.Comparator<T> 
   int Compare(T, T)   {!}.compare({0}, {1})   {!}.compare({0}, {1})
interface IDictionary<K, V> : ICollection [KeyValuePair]java.util.Map<K, V>dict<K, V>
   int Count { get; }   get: {!}.size()   get: len({!})
   ICollection<T> Keys { get; }   get: {!}.keySet()   get: {!}.keys()
   ICollection<T> Values { get; }   get: {!}.values()   get: {!}.values()
   V this[K] { get; set; }   get: {!}.get({0})
   set: {!}.put({0}, {1})
   get: {!}[{0}]
   set: {!}[{0}] = {1}
   void Add(K, V)   {!}.put({0}, {1})   {!}[{0}] = {1}
   void Clear()   {!}.clear()   {!}.clear()
   bool ContainsKey(K)   {!}.containsKey({0})   {0} in {!}
   bool ContainsValue(V)   {!}.containsValue({0})   {0} in {!}.values()
   IEnumerator<T> GetEnumerator()   {!}.entrySet()   iter({!})
   void Remove(K)   {!}.remove({0})   del {!}[{0}]
   bool TryGetValue(K, out V)   Utils.tryGetValue({!}, {0}, {1})   Utils.tryGetValue({!}, {0}, {1})
interface IDisposablejava.lang.AutoCloseable 
   void Dispose()   {!}.close()   {!}.close()
interface IEnumerable<T> [T]java.lang.Iterable<T> 
   bool All(Predicate<T>)   Utils.allIterable({!}, {0}) 
   bool All()   Utils.allIterable({!}, null) 
   bool Any(Predicate<T>)   Utils.anyIterable({!}, {0}) 
   bool Any()   Utils.anyIterable({!}, null) 
   IEnumerable<T> Concat(IEnumerable<T>)   Utils.concatIterable({!}, {0}) 
   int Count(Predicate<T>)   Utils.countIterable({!}, {0}) 
   int Count()   Utils.countIterable({!}, null) 
   T ElementAt(int)   Utils.elementAtIterable({!}, {0}, null) 
   T ElementAtOrDefault(int)   Utils.elementAtOrDefaultIterable({!}, {0}, default(T)) 
   T First()   Utils.firstIterable({!}, null) 
   T FirstOrDefault(Predicate<T>)   Utils.firstOrDefaultIterable({!}, default(T), {0}) 
   T FirstOrDefault()   Utils.firstOrDefaultIterable({!}, default(T), null) 
   IEnumerator<T> GetEnumerator()   {!}.iterator()   {!}.__iter__()
   T Last()   Utils.lastIterable({!}, null) 
   T LastOrDefault(Predicate<T>)   Utils.lastOrDefaultIterable({!}, default(T), {0}) 
   T LastOrDefault()   Utils.lastOrDefaultIterable({!}, default(T), null) 
   IEnumerable<T> Reverse()   Utils.reverseIterable({!}, null) 
   IEnumerable<T> Select<R>(Func<T, R>)   Utils.selectIterable({!}, {0}) 
   List<T> ToList()   Utils.toArrayList({!}) 
   IEnumerable<T> Where(Predicate<T>)   Utils.whereIterable({!}, {0}) 
interface IEnumerator<T>java.util.Iterator<T> 
   T Current { get; }   get: {!}.next()   get: next({!})
   bool MoveNext()   {!}.hasNext()   {!}.move_next()
   void Reset()  
interface IList<T> : ICollection [T]java.util.List<T>list<T>
   T this[int] { get; set; }   get: {!}.get({0})
   set: Utils.putArrayValue({!}, {0}, {1})
   get: {!}[{0}]
   set: {!}[{0}] = {1}
   int IndexOf(T)   {!}.indexOf({0})   Utils.indexOfList({!}, {0}, 0)
   int IndexOf(T, int)   Utils.indexOf({!}, {0}, {1})   Utils.indexOfList({!}, {0}, {1})
   void Insert(int, T)   {!}.add({0}, {1})   {!}.insert({0}, {1})
   int LastIndexOf(T, int)   Utils.lastIndexOf({!}, {0}, {1})   Utils.lastIndexOfList({!}, {0}, {1})
   int LastIndexOf(T)   {!}.lastIndexOf({0})   Utils.lastIndexOfList({!}, {0}, 0)
   void RemoveAt(int)   {!}.remove({0})   del {!}[{0}]
class IndexOutOfRangeException : Exceptionjava.lang.IndexOutOfBoundsExceptionException
class intint / java.lang.Integerint
   int static MaxValue   Integer.MAX_VALUE 
   int static MinValue   Integer.MIN_VALUE 
   string ToString(NumberFormatInfo)   {0}.format({!}) 
   string ToString(string)   model by String.format(format, val), format must be string lexem   model by 'format', format must be string lexem
   static int Parse(string, NumberStyles, *)   Utils.parseInteger({0}, {1}, {2=null}) 
   static int Parse(string)   Utils.parseInteger({0}, 0, null)   int({0})
   static bool TryParse(string, NumberStyles, NumberFormatInfo, out int)   Utils.parseInteger({0}, {1}, {2}, {3}) 
   static bool TryParse(string, out int)   Utils.parseInteger({0}, 0, null, {1})   Utils.tryParseInt({0}, {1})
class InvalidOperationException : Exceptionjava.lang.UnsupportedOperationExceptionException
class IOException : Exceptionjava.io.IOExceptionException
interface KeyValuePair<K, V>java.util.Map.Entry<K, V>tuple<K, V>
   K Key { get; }   get: {!}.getKey()   get: {!}[0]
   V Value { get; }   get: {!}.getValue()   get: {!}[1]
    .ctor(K, V)   .ctor({0}, {1})   .ctor({0}, {1})
class List<T> : IList [T]java.util.ArrayList<T>list<T>
   int Capacity { get; set; }   get: Utils.getCapacity({!})
   set: {!}.ensureCapacity({0})
 
    .ctor(int)   .ctor({0})   modeled by bytearray or list (depends on type)
    .ctor(IEnumerable<T>)   modeled by ArrayList   modeled by bytearray or list (depends on type)
    .ctor()   .ctor()   modeled by bytearray or list (depends on type)
   void AddRange(IEnumerable<T>)   Utils.addToArrayList({!}, {0})   {!}.extend({0})
   bool Exists(Predicate<T>)   Utils.existsList({!}, {0}) 
   T Find(Predicate<T>)   Utils.findList({!}, {0}) 
   List<T> FindAll(Predicate<T>)   Utils.findAllList({!}, {0}) 
   int FindIndex(int, int, Predicate<T>)   Utils.findIndexList({!}, {2}, {0}, {1}) 
   int FindIndex(Predicate<T>)   Utils.findIndexList({!}, {0}, 0, 0) 
   int FindIndex(int, Predicate<T>)   Utils.findIndexList({!}, {1}, {0}, 0) 
   T FindLast(Predicate<T>)   Utils.findLastList({!}, {0}) 
   int FindLastIndex(Predicate<T>)   Utils.findLastIndexList({!}, {0}, 0, 0) 
   int FindLastIndex(int, Predicate<T>)   Utils.findLastIndexList({!}, {1}, {0}, 0) 
   int FindLastIndex(int, int, Predicate<T>)   Utils.findLastIndexList({!}, {2}, {0}, {1}) 
   void ForEach(Action<T>)   Utils.forEachList({!}, {0}) 
   void InsertRange(int, IEnumerable<T>)   Utils.insertToArrayList({!}, {1}, {0})   {!}[{0}:{0}] = {1}
   void RemoveRange(int, int)   for(int jjj = {0} + {1} - 1, mmm = {0}; jjj >= mmm; jjj--) {!}.remove(jjj)   del {!}[{0}:{0}+{1}]
   void Reverse()   java.util.Collections.reverse({!})   {!}.reverse()
   void Sort()   java.util.Collections.sort({!})   modeled by sort()
   void Sort(IComparer<T>)   {!}.sort({0})   modeled by sort()
   T[] ToArray()   modeled by toArray   modeled by toArray
   bool TrueForAll(Predicate<T>)   Utils.trueForAllList({!}, {0}) 
class longlong / java.lang.Longint
   long static MaxValue   Long.MAX_VALUE 
   long static MinValue   Long.MIN_VALUE 
   string ToString(NumberFormatInfo)   {0}.format({!}) 
   string ToString(string)   model by String.format(format, val), format must be string lexem   model by 'format', format must be string lexem
   static long Parse(string, NumberStyles, *)   Utils.parseLong({0}, {1}, {2=null}) 
   static long Parse(string)   Utils.parseLong({0}, 0, null)   int({0})
   static bool TryParse(string, NumberStyles, NumberFormatInfo, out long)   Utils.parseLong({0}, {1}, {2}, {3}) 
   static bool TryParse(string, out long)   Utils.parseLong({0}, 0, null, {1})   Utils.tryParseInt({0}, {1})
class MatchRegexMatchWrapper (our service class) 
   int Index   {!}.index 
   int Length   {!}.length 
   bool Success   {!}.success 
   string Value   {!}.value 
   List<T> Groups { get; }   get: {!}.groups 
   Match NextMatch()   {!}.nextMatch() 
class MatchCollection  
static class Mathjava.lang.Mathmath (import math)
   double E   Math.E   math.e
   double PI   Math.PI   math.pi
   long Abs(long)   Math.abs({0})   math.fabs({0})
   float Abs(float)   Math.abs({0})   math.fabs({0})
   double Abs(double)   Math.abs({0})   math.fabs({0})
   int Abs(int)   Math.abs({0})   math.fabs({0})
   double Acos(double)   Math.acos({0})   math.acos({0})
   double Asin(double)   Math.asin({0})   math.asin({0})
   double Atan(double)   Math.atan({0})   math.atan({0})
   double Atan2(double)   Math.atan2({0}) 
   double Ceiling(double)   Math.ceil({0})   math.ceil({0})
   double Cos(double)   Math.cos({0})   math.cos({0})
   double Cosh(double)   Math.cosh({0})   math.cosh({0})
   double Exp(double)   Math.exp({0})   math.exp({0})
   double Floor(double)   Math.floor({0})   math.floor({0})
   double Log(double, double)   (Math.log({0})/Math.log({1}))   math.log({0}, {1})
   double Log(double)   Math.log({0})   math.log({0})
   double Log10(double)   Math.log10({0})   math.log10({0})
   float Max(float, float)   Math.max({0}, {1})   min({0}, {1})
   int Max(int, int)   Math.max({0}, {1})   max({0}, {1})
   long Max(long, long)   Math.max({0}, {1})   max({0}, {1})
   double Max(double, double)   Math.max({0}, {1})   max({0}, {1})
   long Min(long, long)   Math.min({0}, {1})   min({0}, {1})
   float Min(float, float)   Math.min({0}, {1})   min({0}, {1})
   double Min(double, double)   Math.min({0}, {1})   min({0}, {1})
   int Min(int, int)   Math.min({0}, {1})   min({0}, {1})
   double Pow(double, double)   Math.pow({0}, {1})   math.pow({0}, {1})
   double Round(double)   Math.round({0}) 
   double Round(double, int)   Utils.mathRound({0}, {1})   round({0}, {1})
   int Sign(double)   ((int)Math.signum({0})) 
   double Sin(double)   Math.sin({0})   math.sin({0})
   double Sinh(double)   Math.sinh({0})   math.sinh({0})
   double Sqrt(double)   Math.sqrt({0})   math.sqrt({0})
   double Tan(double)   Math.tan({0})   math.tan({0})
   double Tanh(double)   Math.tanh({0})   math.tanh({0})
   double Truncate(double)   Utils.mathTruncate({0})   math.trunc({0})
class MemoryStream : StreamMemoryStream (our service class)io.BytesIO (import io)
    .ctor(byte[], bool)   .ctor({0}, {1})   .ctor({0}, {1})
    .ctor(byte[], int, int, *)   new MemoryStream({0}, {1}, {2}) 
    .ctor(int)   .ctor({0})   .ctor({0})
    .ctor()   .ctor()   .ctor()
    .ctor(byte[])   .ctor({0})   .ctor({0})
   byte[] ToArray()   {!}.toByteArray()   {!}.getvalue()
   void WriteTo(Stream)   {!}.writeTo({0})   shutil.copyfileobj({!}, {0}) (import shutil)
enum NormalizationFormjava.text.Normalizer.Formstr
    static FormC   java.text.Normalizer.Form.NFC   'NFC'
    static FormD   java.text.Normalizer.Form.NFD   'NFD'
    static FormKC   java.text.Normalizer.Form.NFKC   'NFKC'
    static FormKD   java.text.Normalizer.Form.NFKD   'NFKD'
class NotImplementedException : Exceptionjava.lang.UnsupportedOperationExceptionNotImplementedError
class NotSupportedException : Exceptionjava.lang.UnsupportedOperationExceptionException
class NullReferenceException : Exceptionjava.lang.NullPointerExceptionException
class NumberFormatInfojava.text.DecimalFormat 
   string NegativeSign { get; set; }   get: {!}.getNegativePrefix()
   set: {!}.setNegativePrefix({0})
 
   string NumberDecimalSeparator { get; set; }   get: String.valueOf({!}.getDecimalFormatSymbols().getDecimalSeparator())
   set: Utils.setDecimalSeparator({!}, {0})
 
   string PositiveSign { get; set; }   get: {!}.getPositivePrefix()
   set: {!}.setPositivePrefix({0})
 
    .ctor()   .ctor() 
enum NumberStylesint 
    static AllowHexSpecifier   512 
    static Any   511 
    static HexNumber   515 
class objectjava.lang.Objectobject
   bool Equals(object)   {!}.equals({0})   {!}.equals({0})
   int GetHashCode()   {!}.hashCode()   {!}.__hash__()
   Type GetType()   {!}.getClass()   type({!})
   object MemberwiseClone()   generate method in class   generate method in class
   string ToString()   {!}.toString()   Generate code by inner hardcode procedure
   static bool ReferenceEquals(object, object)   Utils.referenceEquals({0}, {1}) 
class ObjectDisposedException : Exceptionjava.lang.ExceptionException
class OutOfMemoryException : Exceptionjava.lang.OutOfMemoryErrorMemoryError
class OverflowException : Exceptionjava.lang.StackOverflowErrorOverflowError
static class Path  (import pathlib)
   string ChangeExtension(string, string)   Utils.changeFileExt({0}, {1})   pathlib.PurePath({0}).with_suffix({1})
   string Combine(string, string)   (new java.io.File({0}, (new java.io.File({1})).getPath())).getPath()   pathlib.PurePath({0}).joinpath({1})
   string GetDirectoryName(string)   (new java.io.File({0})).getAbsoluteFile().getParent()   pathlib.PurePath({0}).parent.absolute()
   string GetExtension(string)   Utils.getFileExt({0})   pathlib.PurePath({0}).suffix
   string GetFileName(string)   (new java.io.File({0})).getName()   pathlib.PurePath({0}).name
   string GetFileNameWithoutExtension(string)   Utils.getFileWithoutExt({0})   Utils.getFilenameWithoutExt({0})
   string GetFullPath(string)   Utils.getFullPath({0})   pathlib.PurePath({0}).absolute()
   string GetPathRoot(string)   Utils.getRootPath({0})   pathlib.PurePath({0}).root
   string GetTempFileName()   Utils.getTempFileName() 
   string GetTempPath()   (new java.io.File(System.getProperty(\"java.io.tmpdir\"))).getName() 
   bool IsPathRooted(string)   Utils.isPathRooted({0})   pathlib.PurePath({0}).is_absolute()
class PathTooLongException : Exceptionjava.lang.ExceptionException
delegate Predicate<T>Predicate (our service class) 
   bool call(T)   call 
class ProgressChangedEventArgsProgressEventArgs (our service class)ProgressEventArgs (our service class)
   int ProgressPercentage { get; }   get: {!}.getProgressPercentage()   get: {!}.progressPercentage
   object UserState { get; }   get: {!}.getUserState()   get: {!}.userState
    .ctor(int, object)   .ctor({0}, {1})   .ctor({0}, {1})
delegate ProgressChangedEventHandlerProgressEventHandler (our service class)EventHandler (our service class)
   void call(object, ProgressChangedEventArgs)   {!}.call({0}, {1})   {!}.call({0}, {1})
class PropertyChangedEventArgsPropertyChangedEventArgs (our service class)PropertyChangedEventArgs (our service class)
   int PropertyName { get; }   get: {!}.getPropertyName()   get: {!}.propertyName
    .ctor(string)   .ctor({0})   .ctor({0})
delegate PropertyChangedEventHandlerPropertyChangedEventHandler (our service class)EventHandler (our service class)
   void call(object, PropertyChangedEventArgs)   {!}.call({0}, {1})   {!}.call({0}, {1})
struct Randomjava.util.Random 
    .ctor(long)   .ctor({0}) 
    .ctor()   .ctor() 
   int Next()   {!}.nextInt() 
   int Next(int)   {!}.nextInt({0}) 
   void NextBytes(byte[])   {!}.nextBytes({0}) 
   double NextDouble()   {!}.nextDouble() 
class Regexjava.util.regex.Pattern 
    .ctor(string, *)   Generate code by inner hardcode procedure 
   Match Match(string, *)   Utils.createMatchRegex({!}, {0}, {1=0}) 
   List<T> Matches(string, *)   Utils.matchesRegex({!}, {0}, {1=0}) 
   string[] Split(string, int)   {!}.split({0}, {1}) 
   string[] Split(string)   {!}.split({0}) 
   static string[] Split(string, string, *)   Generate code by inner hardcode procedure 
enum RegexOptionsjava.util.regex.Pattern 
    static ECMAScript   Ignored in Java 
    static IgnoreCase   java.util.regex.Pattern.CASE_INSENSITIVE | java.util.regex.Pattern.UNICODE_CASE 
    static Multiline   java.util.regex.Pattern.MULTILINE 
    static Singleline   java.util.regex.Pattern.DOTALL 
class sbytebyte / java.lang.Byteint
   string ToString(string)   model by String.format(format, val), format must be string lexem   model by 'format', format must be string lexem
   static sbyte Parse(string)   Utils.parseByte({0})   int({0})
   static bool TryParse(string, out sbyte)   Utils.parseByte({0}, {1})   Utils.tryParseInt({0}, {1})
class SecurityException : Exceptionjava.lang.SecurityExceptionException
enum SeekOriginintio (import io)
    static Begin   0   io.SEEK_SET
    static Current   1   io.SEEK_CUR
    static End   2   io.SEEK_END
class shortshort / java.lang.Shortint
   short static MaxValue   32767   32767
   string ToString(NumberFormatInfo)   {0}.format({!}) 
   string ToString(string)   model by String.format(format, val), format must be string lexem   model by 'format', format must be string lexem
   static short Parse(string, NumberStyles, *)   Utils.parseShort({0}, {1}, {2=null}) 
   static short Parse(string)   Utils.parseShort({0}, 0, null)   int({0})
   static bool TryParse(string, NumberStyles, NumberFormatInfo, out short)   Utils.parseShort({0}, {1}, {2}, {3}) 
   static bool TryParse(string, out short)   Utils.parseShort({0}, 0, null, {1})   Utils.tryParseInt({0}, {1})
class SortedDictionary<K, V> : Dictionaryjava.util.HashMap<K, V>dict<K, V>
class Stack<T> : ICollection [T]java.util.Stack<T> 
   T Peek()   {!}.peek() 
   T Pop()   {!}.pop() 
   void Push(T)   {!}.push({0}) 
class StackOverflowException : Exceptionjava.lang.StackOverflowErrorStackOverflowError
class StopwatchStopwatch (our service class)Stopwatch (our service class)
   TimeSpan Elapsed { get; }   get: {!}.getElapsed()   get: {!}.elapsed
   long ElapsedMilliseconds { get; }   get: {!}.getElapsedMilliseconds()   get: {!}.elapsedMilliseconds
   bool IsRunning { get; }   get: {!}.isRunning()   get: {!}.isrunning
    .ctor()   .ctor()   .ctor()
   void Reset()   {!}.reset()   {!}.reset()
   void Start()   {!}.start()   {!}.start()
   void Stop()   {!}.stop()   {!}.stop()
   static Stopwatch StartNew()   Utils.startNewStopwatch()   Stopwatch()
class StreamStream (our service class)io.IOBase (import io)
   bool CanRead { get; }   get: {!}.canRead()   get: {!}.readable
   bool CanSeek { get; }   get: {!}.canSeek()   get: {!}.seekable
   bool CanWrite { get; }   get: {!}.canWrite()   get: {!}.writable
   long Length { get; }   get: {!}.length()   get: Utils.getLengthIO({!})
   long Position { get; set; }   get: {!}.getPosition()
   set: {!}.setPosition({0})
   get: {!}.tell()
   set: {!}.seek({0}, io.SEEK_SET)
   void Close()   {!}.close()   {!}.close()
   void Dispose()   {!}.close()   {!}.close()
   void Flush()   {!}.flush()   {!}.flush()
   int Read(byte[], int, int)   {!}.read({0}, {1}, {2})   Utils.readIO({!}, {0}, {1}, {2})
   int ReadByte()   {!}.read()   Utils.readByteIO({!})
   long Seek(long, SeekOrigin)   {!}.seek({0}, {1})   {!}.seek({0}, {1})
   void SetLength(long)   {!}.setLength({0})   {!}.truncate({0})
   int Write(byte[], int, int)   {!}.write({0}, {1}, {2})   Utils.writeIO({!}, {0}, {1}, {2})
   void WriteByte(byte)   {!}.write({0})   Utils.writeByteIO({!}, {0})
class StreamReader : TextReaderjava.io.BufferedReader 
   Stream BaseStream { get; }   get: BaseStream of StreamReader not supported in Java java.io.BufferedReader 
    .ctor(string, ?)   new java.io.BufferedReader(new java.io.InputStreamReader(new java.io.FileInputStream({0}), {1})) 
    .ctor(string)   new java.io.BufferedReader(new java.io.InputStreamReader(new java.io.FileInputStream({0}))) 
class string [char]java.lang.Stringstr
   string static Empty   ""   ""
   int Length { get; }   get: {!}.length()   get: len({!})
   char this[int] { get; }   get: {!}.charAt({0})   get: {!}[{0}]
    .ctor(char, int)   Utils.createString({0}, {1}) 
    .ctor(char[], int, int)   .ctor({0}, {1}, {2})   .ctor({0}, {1}, {2})
    .ctor()   .ctor()   .ctor()
    .ctor(char[])   .ctor({0})   .ctor({0})
   int CompareTo(string)   {!}.compareTo({0}) 
   bool Contains(string)   ({!}.indexOf({0}) >= 0)   {0} in {!}
   bool EndsWith(string)   {!}.endsWith({0})   {!}.endswith({0})
   bool EndsWith(string, StringComparison)   Utils.endsWithString({!}, {0}, {1})   Utils.endsWithString({!}, {0}, {1})
   string Format(string, *)   Model constant format string by operators   Model constant format string by operators
   IEnumerator<T> GetEnumerator()   {!}.toCharArray() 
   int IndexOf(string)   {!}.indexOf({0})   {!}.find({0})
   int IndexOf(char)   {!}.indexOf({0})   {!}.find({0})
   int IndexOf(string, int)   {!}.indexOf({0}, {1})   Utils.indexOfList({!}, {0}, {1})
   int IndexOf(char, int)   {!}.indexOf({0}, {1})   Utils.indexOfList({!}, {0}, {1})
   int IndexOfAny(char[], *)   Utils.indexOfAny({!}, {0}, {1=0}, {2=0}) 
   int LastIndexOf(char, int)   {!}.lastIndexOf({0}, {1})   Utils.lastIndexOfList({!}, {0}, {1})
   int LastIndexOf(string, int)   {!}.lastIndexOf({0}, {1})   Utils.lastIndexOfList({!}, {0}, {1})
   int LastIndexOf(char)   {!}.lastIndexOf({0})   {!}.rfind({0})
   int LastIndexOf(string)   {!}.lastIndexOf({0})   {!}.rfind({0})
   string Normalize(NormalizationForm)   java.text.Normalizer.normalize({!}, {0})   unicodedata.normalize({0}, {!}) (import unicodedata)
   string Normalize()   java.text.Normalizer.normalize({!}, java.text.Normalizer.Form.NFC)   unicodedata.normalize('NFC', {!}) (import unicodedata)
   string Remove(int, int)   Utils.removeString({!}, {0=0}, {1=0}) 
   string Replace(string, string)   {!}.replace({0}, {1})   {!}.replace({0}, {1})
   string Replace(char, char)   {!}.replace({0}, {1})   {!}.replace({0}, {1})
   string[] Split(char, char, char)   Utils.split({!}, String.valueOf({0}) + String.valueOf({1}) + String.valueOf({2}), false)   Utils.splitString({!}, {0} + {1} + {2}, False)
   string[] Split(char)   Utils.split({!}, String.valueOf({0}), false)   Utils.splitString({!}, {0}, False)
   string[] Split(char, char)   Utils.split({!}, String.valueOf({0}) + String.valueOf({1}), false)   Utils.splitString({!}, {0} + {1}, False)
   string[] Split(string, *)   Utils.split({!}, {0}, {1=false})   Utils.splitString({!}, {0}, {1=False})
   string[] Split(char[], *)   Utils.split({!}, new String({0}), {1=false})   Utils.splitString({!}, {0}, {1=False})
   bool StartsWith(string, StringComparison)   Utils.startsWithString({!}, {0}, {1})   Utils.startsWithString({!}, {0}, {1})
   bool StartsWith(string)   {!}.startsWith({0})   {!}.startswith({0})
   string Substring(int, int)   {!}.substring({0}, {0} + {1})   {!}[{0}:{0}+{1}]
   string Substring(int)   {!}.substring({0})   {!}[{0}:]
   char[] ToCharArray()   {!}.toCharArray() 
   string ToLower()   {!}.toLowerCase()   {!}.lower()
   string ToUpper()   {!}.toUpperCase()   {!}.upper()
   string Trim()   {!}.trim()   {!}.strip()
   string TrimEnd()   Utils.trimEnd({!})   Utils.trimEndString({!})
   string TrimStart()   Utils.trimStart({!})   Utils.trimStartString({!})
   static int Compare(string, string, *)   Utils.stringsCompare({0}, {1}, {2=false})   Utils.compareStrings({0}, {1}, {2=False})
   static bool IsNullOrEmpty(string)   Utils.isNullOrEmpty({0})   Utils.isNullOrEmpty({0})
   static string Join(string, string[])   String.join({0}, {1})   Utils.joinStrings({0}, {1})
class StringBuilderjava.lang.StringBuilderio.StringIO (import io)
   int Length { get; set; }   get: {!}.length()
   set: {!}.setLength({0})
   get: {!}.tell()
   set: Utils.setLengthStringIO({!}, {0})
   char this[int] { get; set; }   get: {!}.charAt({0})
   set: {!}.setCharAt({0}, {1})
   get: Utils.getCharAtStringIO({!}, {0})
   set: Utils.setCharAtStringIO({!}, {0}, {1})
    .ctor()   .ctor()   .ctor()
    .ctor(?)   .ctor({0})   Utils.newStringIO({0})
   StringBuilder Append(?)   {!}.append({0})   print({0}, end="", file={!})
   StringBuilder Append(char, int)   Utils.append({!}, {0}, {1}) 
   StringBuilder AppendFormat(string, *)   Model constant format string by operators   Model constant format string by operators
   StringBuilder Insert(int, ?)   {!}.insert({0}, {1})   Utils.insertStringIO({!}, {0}, {1})
   StringBuilder Remove(int, int)   {!}.delete({0}, {0} + {1})   Utils.removeStringIO({!}, {0}, {1})
   StringBuilder Replace(char, char)   Utils.replace({!}, {0}, {1})   Utils.replaceStringIO({!}, {0}, {1})
   StringBuilder Replace(string, string)   Utils.replace({!}, {0}, {1})   Utils.replaceStringIO({!}, {0}, {1})
enum StringComparisonbooleanbool
    static CurrentCulture   false   False
    static CurrentCultureIgnoreCase   true   True
    static InvariantCulture   false   False
    static InvariantCultureIgnoreCase   true   True
    static Ordinal   false   False
    static OrdinalIgnoreCase   true   True
class StringReader : TextReaderjava.io.StringReaderio.StringIO (import io)
    .ctor(string)   new java.io.BufferedReader(new java.io.StringReader({0}))   .ctor({0})
enum StringSplitOptionsbooleanbool
    static None   false   False
    static RemoveEmptyEntries   true   True
class TargetInvocationException : Exceptionjava.lang.reflect.InvocationTargetExceptionException
class TextReader : IDisposablejava.io.BufferedReaderio.TextIOBase (import io)
   void Close()   {!}.close()   {!}.close()
   void Dispose()   {!}.close()   {!}.close()
   int Read(char[], int, int)   {!}.read({0}, {1}, {2}) 
   int Read()   {!}.read() 
   string ReadLine()   {!}.readLine()   Utils.readLineIO({!})
class Threadjava.lang.Thread 
   bool IsAlive { get; }   get: {!}.isAlive() 
    .ctor(object)   .ctor({0}) 
   void Abort()   {!}.interrupt() 
   void Interrupt()   {!}.interrupt() 
   void Start()   {!}.start() 
   void Start(object)   generate special code for model start thread with parameter 
   static void Sleep(long)   Thread.sleep({0}) 
delegate ThreadStartjava.lang.Runnable 
   void call()   {!}.run() 
struct TimeSpanjava.time.Durationdatetime.timedelta (import datetime)
   long TotalDays { get; }   get: {!}.toDays()   get: {!}.days
   long TotalHours { get; }   get: {!}.toHours()   get: ({!}.total_seconds() // 3600)
   long TotalMilliseconds { get; }   get: {!}.toMillis()   get: ({!}.total_seconds() * 1000)
   long TotalMinutes { get; }   get: {!}.toMinutes()   get: ({!}.total_seconds() // 60)
   long TotalSeconds { get; }   get: {!}.getSeconds()   get: int({!}.total_seconds())
   static TimeSpan FromDays(long)   java.time.Duration.ofDays({0}) 
   static TimeSpan FromHours(long)   java.time.Duration.ofHours({0}) 
   static TimeSpan FromMilliseconds(long)   java.time.Duration.ofMillis({0}) 
   static TimeSpan FromMinutes(long)   java.time.Duration.ofMinutes({0}) 
   static TimeSpan FromSeconds(long)   java.time.Duration.ofSeconds({0}) 
class Typejava.lang.Class 
   string FullName { get; }   get: {!}.getName() 
   string Name { get; }   get: {!}.getSimpleName() 
   ConstructorInfo GetConstructor(Type[])   {!}.getDeclaredConstructor({0}) 
   ConstructorInfo[] GetConstructors()   {!}.getDeclaredConstructors() 
class uintint / java.lang.Integerint
   ulong static MaxValue   4294967295L   4294967295
   int static MinValue  
   string ToString(NumberFormatInfo)   {0}.format({!}) 
   string ToString(string)   model by String.format(format, val), format must be string lexem   model by 'format', format must be string lexem
   static uint Parse(string, NumberStyles, *)   Utils.parseInteger({0}, {1}, {2=null}) 
   static uint Parse(string)   Utils.parseInteger({0}, 0, null)   int({0})
   static bool TryParse(string, NumberStyles, NumberFormatInfo, out uint)   Utils.parseInteger({0}, {1}, {2}, {3}) 
   static bool TryParse(string, out uint)   Utils.parseInteger({0}, 0, null, {1})   Utils.tryParseInt({0}, {1})
class ulonglong / java.lang.Longint
   string ToString(NumberFormatInfo)   {0}.format({!}) 
   string ToString(string)   model by String.format(format, val), format must be string lexem   model by 'format', format must be string lexem
   static ulong Parse(string, NumberStyles, *)   Utils.parseLong({0}, {1}, {2=null}) 
   static ulong Parse(string)   Utils.parseLong({0}, 0, null)   int({0})
   static bool TryParse(string, NumberStyles, NumberFormatInfo, out ulong)   Utils.parseLong({0}, {1}, {2}, {3}) 
   static bool TryParse(string, out ulong)   Utils.parseLong({0}, 0, null, {1})   Utils.tryParseInt({0}, {1})
class Urijava.net.URI 
   string AbsoluteUri { get; }   get: {!}.toASCIIString() 
   string Authority { get; }   get: {!}.getAuthority() 
   string Fragment { get; }   get: Utils.encodeUri({!}.getFragment()) 
   string Host { get; }   get: {!}.getHost() 
   bool IsAbsolute { get; }   get: {!}.isAbsolute() 
   string LocalPath { get; }   get: Utils.encodeUri({!}.getPath()) 
   int Port { get; }   get: {!}.getPort() 
   string Query { get; }   get: Utils.encodeUri({!}.getQuery()) 
   string Scheme { get; }   get: {!}.getScheme() 
    .ctor(string)   .ctor({0}) 
   Uri MakeRelativeUri(Uri)   {!}.relativize({0}) 
   static bool TryCreate(string, UriKind, out Uri)   Utils.parseUri({0}, {2}) 
class UriFormatException : Exceptionjava.net.URISyntaxExceptionException
enum UriKindint 
    static Absolute   1 
    static Relative   2 
    static RelativeOrAbsolute   0 
class ushortshort / java.lang.Shortint
   uint static MaxValue   65535   65535
   string ToString(string)   model by String.format(format, val), format must be string lexem   model by 'format', format must be string lexem
   static ushort Parse(string, NumberStyles, *)   Utils.parseShort({0}, {1}, {2=null}) 
   static ushort Parse(string)   Utils.parseShort({0}, 0, null)   int({0})
   static bool TryParse(string, NumberStyles, NumberFormatInfo, out ushort)   Utils.parseShort({0}, {1}, {2}, {3}) 
   static bool TryParse(string, out ushort)   Utils.parseShort({0}, 0, null, {1})   Utils.tryParseInt({0}, {1})
class WebClientWebclient (our service class) 
   byte[] DownloadData(Uri)   {!}.downloadData({0}) 
   byte[] DownloadData(string)   {!}.downloadData({0}) 
   string DownloadString(string)   {!}.downloadString({0}) 
   string DownloadString(Uri)   {!}.downloadString({0}) 
   byte[] UploadData(string, byte[])   {!}.uploadData({0}, {1}) 
   byte[] UploadData(Uri, byte[])   {!}.uploadData({0}, {1}) 
class XmlAttributeorg.w3c.dom.Nodetuple
   string InnerText { get; }   get: {!}.getTextContent()   get: {!}[1]
   string LocalName { get; }   get: Utils.getXmlLocalName({!})   get: {!}[0]
   string Name { get; }   get: {!}.getNodeName()   get: {!}[0]
   string Value { get; set; }   get: {!}.getNodeValue()
   set: {!}.setNodeValue({0})
   get: {!}[1]
   set: {!}[0] = {0}
class XmlAttributeCollection [XmlAttribute]org.w3c.dom.NamedNodeMapdict
   int Count { get; }   get: {!}.getLength()   get: len({!})
   XmlAttribute this[string] { get; }   get: Utils.getXmlAttrByName({!}, {0})   get: Utils.getXmlAttrByName({!}, {0})
   XmlAttribute this[int] { get; }   get: {!}.item({0})   get: Utils.getXmlAttrByIndex({!}, {0})
class XmlDocumentXmlDocumentWrapper (our service class)xml.etree.ElementTree.Element (import xml.etree)
   XmlNode DocumentElement { get; }   get: {!}.doc.getDocumentElement()   get: {!}.getroot()
   bool PreserveWhitespace { get; set; }   get: {!}.getPreserveWhitespace() PreserveWhitespace not supported in Java (always true)
   set: {!}.setPreserveWhitespace({0}) PreserveWhitespace not supported in Java (always true)
 
    .ctor()   .ctor()   .ctor()
   void Load(Stream)   {!}.load({0})   {!} = xml.etree.ElementTree.parse({0})
   void Load(string)   {!}.doc = {!}.db.parse({0})   {!} = xml.etree.ElementTree.parse({0})
   void LoadXml(string)   {!}.doc = {!}.db.parse(new org.xml.sax.InputSource(new java.io.StringReader({0})))   {!} = Utils.parseXmlFromString({0})
class XmlException : Exceptionjavax.xml.stream.XMLStreamExceptionException
class XmlNodeorg.w3c.dom.Nodexml.etree.ElementTree.Element (import xml.etree)
   XmlAttributeCollection Attributes { get; }   get: modeled by method getAttributes   get: {!}.attrib
   XmlNodeList ChildNodes { get; }   get: modeled by method getChildNodes   get: {!}
   bool HasChildNodes { get; }   get: {!}.hasChildNodes()   get: len({!}) > 0
   string InnerText { get; }   get: {!}.getTextContent()   get: Utils.getXmlInnerText({!})
   string LocalName { get; }   get: Utils.getXmlLocalName({!})   get: {!}.tag
   string Name { get; }   get: {!}.getNodeName()   get: {!}.tag
   XmlNode NextSibling { get; }   get: {!}.getNextSibling() 
   XmlNode ParentNode { get; }   get: {!}.getParentNode() 
   XmlNode PreviousSibling { get; }   get: {!}.getPreviousSibling() 
   string Value { get; set; }   get: {!}.getNodeValue()
   set: {!}.setNodeValue({0})
   get: {!}.text
   set: {!}.text = {0}
   IEnumerator<T> GetEnumerator()   modeled by method getChildNodes   {!}
class XmlNodeList [XmlNode]org.w3c.dom.NodeListlist
   int Count { get; }   get: {!}.getLength()   get: len({!})
   XmlNode this[int] { get; }   get: {!}.item({0})   get: {!}[{0}]
class XmlWriterXmlWriterWrapper (our service class)XmlWriter (our service class)
   void Close()   {!}.close()   {!}.close()
   void Flush()   {!}.flush()   {!}.flush()
   void WriteAttributeString(string, string, string, string)   {!}.wr.writeAttribute({0}, ({2} == null) ? "" : ({2}), {1}, {3})   {!}.write_attribute_string3({0}, {1}, {2}, {3})
   void WriteAttributeString(string, string, string)   {!}.wr.writeAttribute("p2", {1}, {0}, {2}) Must set prefix for attribute with namespace   {!}.write_attribute_string2({0}, {1}, {2})
   void WriteAttributeString(string, string)   {!}.wr.writeAttribute({0}, {1})   {!}.write_attribute_string({0}, {1})
   void WriteCData(string)   {!}.wr.writeCData({0})   {!}.write_cdata({0}, {1})
   void WriteChars(char[])   {!}.wr.writeCharacters({0}) 
   void WriteComment(string)   {!}.wr.writeComment({0})   {!}.write_comment({0})
   void WriteElementString(string, string)   {!}.writeElementString({0}, {1})   {!}.write_element_string({0}, {1})
   void WriteEndDocument()   {!}.wr.writeEndDocument()   {!}.write_end_document()
   void WriteEndElement()   {!}.wr.writeEndElement()   {!}.write_end_element()
   void WriteProcessingInstruction(string)   {!}.wr.writeProcessingInstruction({0}) 
   void WriteStartDocument(*)   {!}.wr.writeStartDocument({!}.encoding, "1.0")   {!}.write_start_document()
   void WriteStartElement(string)   {!}.wr.writeStartElement({0})   {!}.write_start_element({0})
   void WriteStartElement(string, string, string)   {!}.wr.writeStartElement({0}, {1}, {2})   {!}.write_start_element3({0}, {1}, {2})
   void WriteStartElement(string, string)   {!}.wr.writeStartElement({1}, {0})   {!}.write_start_element2({0}, {1})
   void WriteString(string)   {!}.wr.writeCharacters({0})   {!}.write_string({0})
   void WriteValue(?)   {!}.wr.writeCharacters(String.valueOf({0}))   {!}.write_value({0})
   static XmlWriter Create(string, *)   new XmlWriterWrapper({0}, {1=null})   XmlWriter.create_file({0}, {1=null})
   static XmlWriter Create(Stream, *)   new XmlWriterWrapper({0}, {1=null})   XmlWriter.create_stream({0}, {1=null})
   static XmlWriter Create(StringBuilder, *)   new XmlWriterWrapper({0}, {1=null})   XmlWriter.create_string({0}, {1=null})
class XmlWriterSettingsXmlWriterSettings (our service class)XmlWriterSettings (our service class)
   Encoding Encoding { get; set; }   get: {!}.getEncoding()
   set: {!}.setEncoding({0})
   get: {!}.encoding
   set: {!}.encoding = {0}
   bool Indent { get; set; }   get: {!}.getIndent()
   set: {!}.setIndent({0})
   get: {!}.indent
   set: {!}.indent = {0}
   string IndentChars { get; set; }   get: {!}.getIndentChars()
   set: {!}.setIndentChars({0})
   get: {!}.indentChars
   set: {!}.indentChars = {0}