public GetCurrentUserResult getCurrentUser(GetCurrentUserRequest request) {request = beforeClientExecution(request);return executeGetCurrentUser(request);}

public virtual GetCurrentUserResponse GetCurrentUser(GetCurrentUserRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetCurrentUserRequestMarshaller.Instance;options.ResponseUnmarshaller = GetCurrentUserResponseUnmarshaller.Instance;return Invoke<GetCurrentUserResponse>(request, options);}

[User] public GetCurrentUserResult getCurrentUser(GetCurrentUserRequest request) {request = beforeClientExecution(request);return executeGetCurrentUser(request);}

[Assistant] public virtual GetCurrentUserResponse GetCurrentUser(GetCurrentUserRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetCurrentUserRequestMarshaller.Instance;options.ResponseUnmarshaller = GetCurrentUserResponseUnmarshaller.Instance;return Invoke<GetCurrentUserResponse>(request, options);}


public String toString() {return "ObjectDirectory[" + getDirectory() + "]"; }

public override string ToString(){return "ObjectDirectory[" + GetDirectory() + "]";}

[User] public String toString() {return "ObjectDirectory[" + getDirectory() + "]"; }

[Assistant] public override string ToString(){return "ObjectDirectory[" + GetDirectory() + "]";}


public IllegalFormatWidthException(int w) {this.w = w;}

public IllegalFormatWidthException(int w){this.w = w;}

[User] public IllegalFormatWidthException(int w) {this.w = w;}

[Assistant] public IllegalFormatWidthException(int w){this.w = w;}


public String toToken() {return this.token;}

public virtual string ToToken(){return this.token;}

[User] public String toToken() {return this.token;}

[Assistant] public virtual string ToToken(){return this.token;}


public UpdatePhoneNumberResult updatePhoneNumber(UpdatePhoneNumberRequest request) {request = beforeClientExecution(request);return executeUpdatePhoneNumber(request);}

public virtual UpdatePhoneNumberResponse UpdatePhoneNumber(UpdatePhoneNumberRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdatePhoneNumberRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdatePhoneNumberResponseUnmarshaller.Instance;return Invoke<UpdatePhoneNumberResponse>(request, options);}

[User] public UpdatePhoneNumberResult updatePhoneNumber(UpdatePhoneNumberRequest request) {request = beforeClientExecution(request);return executeUpdatePhoneNumber(request);}

[Assistant] public virtual UpdatePhoneNumberResponse UpdatePhoneNumber(UpdatePhoneNumberRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdatePhoneNumberRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdatePhoneNumberResponseUnmarshaller.Instance;return Invoke<UpdatePhoneNumberResponse>(request, options);}


public final IndexableField getField(String name) {for (IndexableField field : fields) {if (field.name().equals(name)) {return field;}}return null;}

public IIndexableField GetField(string name){foreach (IIndexableField field in fields){if (field.Name.Equals(name, StringComparison.Ordinal)){return field;}}return null;}

[User] public final IndexableField getField(String name) {for (IndexableField field : fields) {if (field.name().equals(name)) {return field;}}return null;}

[Assistant] public IIndexableField GetField(string name){foreach (IIndexableField field in fields){if (field.Name.Equals(name, StringComparison.Ordinal)){return field;}}return null;}


public DisableDomainTransferLockResult disableDomainTransferLock(DisableDomainTransferLockRequest request) {request = beforeClientExecution(request);return executeDisableDomainTransferLock(request);}

public virtual DisableDomainTransferLockResponse DisableDomainTransferLock(DisableDomainTransferLockRequest request){var options = new InvokeOptions();options.RequestMarshaller = DisableDomainTransferLockRequestMarshaller.Instance;options.ResponseUnmarshaller = DisableDomainTransferLockResponseUnmarshaller.Instance;return Invoke<DisableDomainTransferLockResponse>(request, options);}

[User] public DisableDomainTransferLockResult disableDomainTransferLock(DisableDomainTransferLockRequest request) {request = beforeClientExecution(request);return executeDisableDomainTransferLock(request);}

[Assistant] public virtual DisableDomainTransferLockResponse DisableDomainTransferLock(DisableDomainTransferLockRequest request){var options = new InvokeOptions();options.RequestMarshaller = DisableDomainTransferLockRequestMarshaller.Instance;options.ResponseUnmarshaller = DisableDomainTransferLockResponseUnmarshaller.Instance;return Invoke<DisableDomainTransferLockResponse>(request, options);}


public PrintHeadersRecord clone() {return copy();}

public override Object Clone(){PrintHeadersRecord rec = new PrintHeadersRecord();rec.field_1_print_headers = field_1_print_headers;return rec;}

[User] public PrintHeadersRecord clone() {return copy();}

[Assistant] public override Object Clone(){PrintHeadersRecord rec = new PrintHeadersRecord();rec.field_1_print_headers = field_1_print_headers;return rec;}


public UpdateDataSourceResult updateDataSource(UpdateDataSourceRequest request) {request = beforeClientExecution(request);return executeUpdateDataSource(request);}

public virtual UpdateDataSourceResponse UpdateDataSource(UpdateDataSourceRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateDataSourceRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateDataSourceResponseUnmarshaller.Instance;return Invoke<UpdateDataSourceResponse>(request, options);}

[User] public UpdateDataSourceResult updateDataSource(UpdateDataSourceRequest request) {request = beforeClientExecution(request);return executeUpdateDataSource(request);}

[Assistant] public virtual UpdateDataSourceResponse UpdateDataSource(UpdateDataSourceRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateDataSourceRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateDataSourceResponseUnmarshaller.Instance;return Invoke<UpdateDataSourceResponse>(request, options);}


public int popMode() {if ( _modeStack.isEmpty() ) throw new EmptyStackException();if ( LexerATNSimulator.debug ) System.out.println("popMode back to "+ _modeStack.peek());mode( _modeStack.pop() );return _mode;}

public virtual int PopMode(){if (_modeStack.Count == 0){throw new InvalidOperationException();}int mode = _modeStack.Pop();Mode(mode);return _mode;}

[User] public int popMode() {if ( _modeStack.isEmpty() ) throw new EmptyStackException();if ( LexerATNSimulator.debug ) System.out.println("popMode back to "+ _modeStack.peek());mode( _modeStack.pop() );return _mode;}

[Assistant] public virtual int PopMode(){if (_modeStack.Count == 0){throw new InvalidOperationException();}int mode = _modeStack.Pop();Mode(mode);return _mode;}


public ExternalSheet getExternalSheet(int externSheetIndex) {ExternalSheet sheet = _iBook.getExternalSheet(externSheetIndex);if (sheet == null) {int localSheetIndex = convertFromExternSheetIndex(externSheetIndex);if (localSheetIndex == -1) {return null;}if (localSheetIndex == -2) {return null;}String sheetName = getSheetName(localSheetIndex);int lastLocalSheetIndex = _iBook.getLastSheetIndexFromExternSheetIndex(externSheetIndex);if (lastLocalSheetIndex == localSheetIndex) {sheet = new ExternalSheet(null, sheetName);} else {String lastSheetName = getSheetName(lastLocalSheetIndex);sheet = new ExternalSheetRange(null, sheetName, lastSheetName);}}return sheet;}

public ExternalSheet GetExternalSheet(int externSheetIndex){ExternalSheet sheet = _iBook.GetExternalSheet(externSheetIndex);if (sheet == null){int localSheetIndex = ConvertFromExternSheetIndex(externSheetIndex);if (localSheetIndex == -1){return null;}if (localSheetIndex == -2){return null;}String sheetName = GetSheetName(localSheetIndex);int lastLocalSheetIndex = _iBook.GetLastSheetIndexFromExternSheetIndex(externSheetIndex);if (lastLocalSheetIndex == localSheetIndex){sheet = new ExternalSheet(null, sheetName);}else{String lastSheetName = GetSheetName(lastLocalSheetIndex);sheet = new ExternalSheetRange(null, sheetName, lastSheetName);}}return sheet;}

[User] public ExternalSheet getExternalSheet(int externSheetIndex) {ExternalSheet sheet = _iBook.getExternalSheet(externSheetIndex);if (sheet == null) {int localSheetIndex = convertFromExternSheetIndex(externSheetIndex);if (localSheetIndex == -1) {return null;}if (localSheetIndex == -2) {return null;}String sheetName = getSheetName(localSheetIndex);int lastLocalSheetIndex = _iBook.getLastSheetIndexFromExternSheetIndex(externSheetIndex);if (lastLocalSheetIndex == localSheetIndex) {sheet = new ExternalSheet(null, sheetName);} else {String lastSheetName = getSheetName(lastLocalSheetIndex);sheet = new ExternalSheetRange(null, sheetName, lastSheetName);}}return sheet;}

[Assistant] public ExternalSheet GetExternalSheet(int externSheetIndex){ExternalSheet sheet = _iBook.GetExternalSheet(externSheetIndex);if (sheet == null){int localSheetIndex = ConvertFromExternSheetIndex(externSheetIndex);if (localSheetIndex == -1){return null;}if (localSheetIndex == -2){return null;}String sheetName = GetSheetName(localSheetIndex);int lastLocalSheetIndex = _iBook.GetLastSheetIndexFromExternSheetIndex(externSheetIndex);if (lastLocalSheetIndex == localSheetIndex){sheet = new ExternalSheet(null, sheetName);}else{String lastSheetName = GetSheetName(lastLocalSheetIndex);sheet = new ExternalSheetRange(null, sheetName, lastSheetName);}}return sheet;}


public static NoteMap newEmptyMap() {NoteMap r = new NoteMap(null );r.root = new LeafBucket(0);return r;}

public static NGit.Notes.NoteMap NewEmptyMap(){NGit.Notes.NoteMap r = new NGit.Notes.NoteMap(null);r.root = new LeafBucket(0);return r;}

[User] public static NoteMap newEmptyMap() {NoteMap r = new NoteMap(null );r.root = new LeafBucket(0);return r;}

[Assistant] public static NGit.Notes.NoteMap NewEmptyMap(){NGit.Notes.NoteMap r = new NGit.Notes.NoteMap(null);r.root = new LeafBucket(0);return r;}


@Override public java.lang.Object[] toArray() {synchronized (mutex) {return c.toArray();}}

public virtual object[] toArray(){lock (mutex){return c.toArray();}}

[User] @Override public java.lang.Object[] toArray() {synchronized (mutex) {return c.toArray();}}

[Assistant] public virtual object[] toArray(){lock (mutex){return c.toArray();}}


public TagCommand setObjectId(RevObject id) {this.id = id;return this;}

public virtual NGit.Api.TagCommand SetObjectId(RevObject id){this.id = id;return this;}

[User] public TagCommand setObjectId(RevObject id) {this.id = id;return this;}

[Assistant] public virtual NGit.Api.TagCommand SetObjectId(RevObject id){this.id = id;return this;}


public static void clear() {cache.clearAll();}

public static void Clear(){cache.ClearAll();}

[User] public static void clear() {cache.clearAll();}

[Assistant] public static void Clear(){cache.ClearAll();}


public final int prefixCompare(int[] bs, int p) {int cmp;cmp = NB.compareUInt32(w1, mask(1, bs[p]));if (cmp != 0)return cmp;cmp = NB.compareUInt32(w2, mask(2, bs[p + 1]));if (cmp != 0)return cmp;cmp = NB.compareUInt32(w3, mask(3, bs[p + 2]));if (cmp != 0)return cmp;cmp = NB.compareUInt32(w4, mask(4, bs[p + 3]));if (cmp != 0)return cmp;return NB.compareUInt32(w5, mask(5, bs[p + 4]));}

public int PrefixCompare(int[] bs, int p){int cmp;cmp = NB.CompareUInt32(w1, Mask(1, bs[p]));if (cmp != 0){return cmp;}cmp = NB.CompareUInt32(w2, Mask(2, bs[p + 1]));if (cmp != 0){return cmp;}cmp = NB.CompareUInt32(w3, Mask(3, bs[p + 2]));if (cmp != 0){return cmp;}cmp = NB.CompareUInt32(w4, Mask(4, bs[p + 3]));if (cmp != 0){return cmp;}return NB.CompareUInt32(w5, Mask(5, bs[p + 4]));}

[User] public final int prefixCompare(int[] bs, int p) {int cmp;cmp = NB.compareUInt32(w1, mask(1, bs[p]));if (cmp != 0)return cmp;cmp = NB.compareUInt32(w2, mask(2, bs[p + 1]));if (cmp != 0)return cmp;cmp = NB.compareUInt32(w3, mask(3, bs[p + 2]));if (cmp != 0)return cmp;cmp = NB.compareUInt32(w4, mask(4, bs[p + 3]));if (cmp != 0)return cmp;return NB.compareUInt32(w5, mask(5, bs[p + 4]));}

[Assistant] public int PrefixCompare(int[] bs, int p){int cmp;cmp = NB.CompareUInt32(w1, Mask(1, bs[p]));if (cmp != 0){return cmp;}cmp = NB.CompareUInt32(w2, Mask(2, bs[p + 1]));if (cmp != 0){return cmp;}cmp = NB.CompareUInt32(w3, Mask(3, bs[p + 2]));if (cmp != 0){return cmp;}cmp = NB.CompareUInt32(w4, Mask(4, bs[p + 3]));if (cmp != 0){return cmp;}return NB.CompareUInt32(w5, Mask(5, bs[p + 4]));}


public LongBuffer put(long[] src, int srcOffset, int longCount) {byteBuffer.limit(limit * SizeOf.LONG);byteBuffer.position(position * SizeOf.LONG);if (byteBuffer instanceof ReadWriteDirectByteBuffer) {((ReadWriteDirectByteBuffer) byteBuffer).put(src, srcOffset, longCount);} else {((ReadWriteHeapByteBuffer) byteBuffer).put(src, srcOffset, longCount);}this.position += longCount;return this;}

public override java.nio.LongBuffer put(long[] src, int srcOffset, int longCount){byteBuffer.limit(_limit * libcore.io.SizeOf.LONG);byteBuffer.position(_position * libcore.io.SizeOf.LONG);if (byteBuffer is java.nio.ReadWriteDirectByteBuffer){((java.nio.ReadWriteDirectByteBuffer)byteBuffer).put(src, srcOffset, longCount);}else{((java.nio.ReadWriteHeapByteBuffer)byteBuffer).put(src, srcOffset, longCount);}this._position += longCount;return this;}

[User] public LongBuffer put(long[] src, int srcOffset, int longCount) {byteBuffer.limit(limit * SizeOf.LONG);byteBuffer.position(position * SizeOf.LONG);if (byteBuffer instanceof ReadWriteDirectByteBuffer) {((ReadWriteDirectByteBuffer) byteBuffer).put(src, srcOffset, longCount);} else {((ReadWriteHeapByteBuffer) byteBuffer).put(src, srcOffset, longCount);}this.position += longCount;return this;}

[Assistant] public override java.nio.LongBuffer put(long[] src, int srcOffset, int longCount){byteBuffer.limit(_limit * libcore.io.SizeOf.LONG);byteBuffer.position(_position * libcore.io.SizeOf.LONG);if (byteBuffer is java.nio.ReadWriteDirectByteBuffer){((java.nio.ReadWriteDirectByteBuffer)byteBuffer).put(src, srcOffset, longCount);}else{((java.nio.ReadWriteHeapByteBuffer)byteBuffer).put(src, srcOffset, longCount);}this._position += longCount;return this;}


public MoPenDeleteGroupRequest() {super("MoPen", "2018-02-11", "MoPenDeleteGroup", "mopen");setProtocol(ProtocolType.HTTPS);setMethod(MethodType.POST);}

public MoPenDeleteGroupRequest(): base("MoPen", "2018-02-11", "MoPenDeleteGroup", "mopen", "openAPI"){Protocol = ProtocolType.HTTPS;Method = MethodType.POST;}

[User] public MoPenDeleteGroupRequest() {super("MoPen", "2018-02-11", "MoPenDeleteGroup", "mopen");setProtocol(ProtocolType.HTTPS);setMethod(MethodType.POST);}

[Assistant] public MoPenDeleteGroupRequest(): base("MoPen", "2018-02-11", "MoPenDeleteGroup", "mopen", "openAPI"){Protocol = ProtocolType.HTTPS;Method = MethodType.POST;}


public ApplyResult addUpdatedFile(File f) {updatedFiles.add(f);return this;}

public virtual ApplyResult AddUpdatedFile(FilePath f){updatedFiles.AddItem(f);return this;}

[User] public ApplyResult addUpdatedFile(File f) {updatedFiles.add(f);return this;}

[Assistant] public virtual ApplyResult AddUpdatedFile(FilePath f){updatedFiles.AddItem(f);return this;}


public T insertWithOverflow(T element) {if (size < maxSize) {add(element);return null;} else if (size > 0 && !lessThan(element, heap[1])) {T ret = heap[1];heap[1] = element;updateTop();return ret;} else {return element;}}

public virtual T InsertWithOverflow(T element){if (size < maxSize){Add(element);return default(T);}else if (size > 0 && !LessThan(element, heap[1])){T ret = heap[1];heap[1] = element;UpdateTop();return ret;}else{return element;}}

[User] public T insertWithOverflow(T element) {if (size < maxSize) {add(element);return null;} else if (size > 0 && !lessThan(element, heap[1])) {T ret = heap[1];heap[1] = element;updateTop();return ret;} else {return element;}}

[Assistant] public virtual T InsertWithOverflow(T element){if (size < maxSize){Add(element);return default(T);}else if (size > 0 && !LessThan(element, heap[1])){T ret = heap[1];heap[1] = element;UpdateTop();return ret;}else{return element;}}


public boolean contains(Object object) {Iterator<E> it = iterator();if (object != null) {while (it.hasNext()) {if (object.equals(it.next())) {return true;}}} else {while (it.hasNext()) {if (it.next() == null) {return true;}}}return false;}

public virtual bool contains(object @object){java.util.Iterator<E> it = iterator();if (@object != null){while (it.hasNext()){if (@object.Equals(it.next())){return true;}}}else{while (it.hasNext()){if ((object)it.next() == null){return true;}}}return false;}

[User] public boolean contains(Object object) {Iterator<E> it = iterator();if (object != null) {while (it.hasNext()) {if (object.equals(it.next())) {return true;}}} else {while (it.hasNext()) {if (it.next() == null) {return true;}}}return false;}

[Assistant] public virtual bool contains(object @object){java.util.Iterator<E> it = iterator();if (@object != null){while (it.hasNext()){if (@object.Equals(it.next())){return true;}}}else{while (it.hasNext()){if ((object)it.next() == null){return true;}}}return false;}


public UploadDocumentsResult uploadDocuments(UploadDocumentsRequest request) {request = beforeClientExecution(request);return executeUploadDocuments(request);}

public virtual UploadDocumentsResponse UploadDocuments(UploadDocumentsRequest request){var options = new InvokeOptions();options.RequestMarshaller = UploadDocumentsRequestMarshaller.Instance;options.ResponseUnmarshaller = UploadDocumentsResponseUnmarshaller.Instance;return Invoke<UploadDocumentsResponse>(request, options);}

[User] public UploadDocumentsResult uploadDocuments(UploadDocumentsRequest request) {request = beforeClientExecution(request);return executeUploadDocuments(request);}

[Assistant] public virtual UploadDocumentsResponse UploadDocuments(UploadDocumentsRequest request){var options = new InvokeOptions();options.RequestMarshaller = UploadDocumentsRequestMarshaller.Instance;options.ResponseUnmarshaller = UploadDocumentsResponseUnmarshaller.Instance;return Invoke<UploadDocumentsResponse>(request, options);}


public String getAccessKeyId() {return legacyCredential.getAccessKeyId();}

public string GetAccessKeyId(){return legacyCredential.AccessKeyId;}

[User] public String getAccessKeyId() {return legacyCredential.getAccessKeyId();}

[Assistant] public string GetAccessKeyId(){return legacyCredential.AccessKeyId;}


public static String toHex(String value) {return (value == null || value.length() == 0)? "[]": toHex(value.getBytes(LocaleUtil.CHARSET_1252));}

public static string ToHex(short value){return ToHex((long)value, 4);}

[User] public static String toHex(String value) {return (value == null || value.length() == 0)? "[]": toHex(value.getBytes(LocaleUtil.CHARSET_1252));}

[Assistant] public static string ToHex(short value){return ToHex((long)value, 4);}


public String getText(Token start, Token stop) {if ( start!=null && stop!=null ) {return getText(Interval.of(start.getTokenIndex(), stop.getTokenIndex()));}return "";}

public virtual string GetText(IToken start, IToken stop){if (start != null && stop != null){return GetText(Interval.Of(start.TokenIndex, stop.TokenIndex));}return string.Empty;}

[User] public String getText(Token start, Token stop) {if ( start!=null && stop!=null ) {return getText(Interval.of(start.getTokenIndex(), stop.getTokenIndex()));}return "";}

[Assistant] public virtual string GetText(IToken start, IToken stop){if (start != null && stop != null){return GetText(Interval.Of(start.TokenIndex, stop.TokenIndex));}return string.Empty;}


public static ValueVector createColumnVector(TwoDEval tableArray, int relativeColumnIndex) {return new ColumnVector(tableArray, relativeColumnIndex);}

public static ValueVector CreateColumnVector(TwoDEval tableArray, int relativeColumnIndex){return new ColumnVector((AreaEval)tableArray, relativeColumnIndex);}

[User] public static ValueVector createColumnVector(TwoDEval tableArray, int relativeColumnIndex) {return new ColumnVector(tableArray, relativeColumnIndex);}

[Assistant] public static ValueVector CreateColumnVector(TwoDEval tableArray, int relativeColumnIndex){return new ColumnVector((AreaEval)tableArray, relativeColumnIndex);}


public AcceptDomainTransferFromAnotherAwsAccountResult acceptDomainTransferFromAnotherAwsAccount(AcceptDomainTransferFromAnotherAwsAccountRequest request) {request = beforeClientExecution(request);return executeAcceptDomainTransferFromAnotherAwsAccount(request);}

public virtual AcceptDomainTransferFromAnotherAwsAccountResponse AcceptDomainTransferFromAnotherAwsAccount(AcceptDomainTransferFromAnotherAwsAccountRequest request){var options = new InvokeOptions();options.RequestMarshaller = AcceptDomainTransferFromAnotherAwsAccountRequestMarshaller.Instance;options.ResponseUnmarshaller = AcceptDomainTransferFromAnotherAwsAccountResponseUnmarshaller.Instance;return Invoke<AcceptDomainTransferFromAnotherAwsAccountResponse>(request, options);}

[User] public AcceptDomainTransferFromAnotherAwsAccountResult acceptDomainTransferFromAnotherAwsAccount(AcceptDomainTransferFromAnotherAwsAccountRequest request) {request = beforeClientExecution(request);return executeAcceptDomainTransferFromAnotherAwsAccount(request);}

[Assistant] public virtual AcceptDomainTransferFromAnotherAwsAccountResponse AcceptDomainTransferFromAnotherAwsAccount(AcceptDomainTransferFromAnotherAwsAccountRequest request){var options = new InvokeOptions();options.RequestMarshaller = AcceptDomainTransferFromAnotherAwsAccountRequestMarshaller.Instance;options.ResponseUnmarshaller = AcceptDomainTransferFromAnotherAwsAccountResponseUnmarshaller.Instance;return Invoke<AcceptDomainTransferFromAnotherAwsAccountResponse>(request, options);}


public StartDeviceSyncResult startDeviceSync(StartDeviceSyncRequest request) {request = beforeClientExecution(request);return executeStartDeviceSync(request);}

public virtual StartDeviceSyncResponse StartDeviceSync(StartDeviceSyncRequest request){var options = new InvokeOptions();options.RequestMarshaller = StartDeviceSyncRequestMarshaller.Instance;options.ResponseUnmarshaller = StartDeviceSyncResponseUnmarshaller.Instance;return Invoke<StartDeviceSyncResponse>(request, options);}

[User] public StartDeviceSyncResult startDeviceSync(StartDeviceSyncRequest request) {request = beforeClientExecution(request);return executeStartDeviceSync(request);}

[Assistant] public virtual StartDeviceSyncResponse StartDeviceSync(StartDeviceSyncRequest request){var options = new InvokeOptions();options.RequestMarshaller = StartDeviceSyncRequestMarshaller.Instance;options.ResponseUnmarshaller = StartDeviceSyncResponseUnmarshaller.Instance;return Invoke<StartDeviceSyncResponse>(request, options);}


@Override public boolean containsKey(Object key) {return isInBounds(key) && TreeMap.this.containsKey(key);}

public override bool containsKey(object key){return this.isInBounds(key) && this._enclosing.containsKey(key);}

[User] @Override public boolean containsKey(Object key) {return isInBounds(key) && TreeMap.this.containsKey(key);}

[Assistant] public override bool containsKey(object key){return this.isInBounds(key) && this._enclosing.containsKey(key);}


public static int idealObjectArraySize(int need) {return idealByteArraySize(need * 4) / 4;}

public static int idealObjectArraySize(int need){return idealByteArraySize(need * 4) / 4;}

[User] public static int idealObjectArraySize(int need) {return idealByteArraySize(need * 4) / 4;}

[Assistant] public static int idealObjectArraySize(int need){return idealByteArraySize(need * 4) / 4;}


public DescribeWorkspacesResult describeWorkspaces() {return describeWorkspaces(new DescribeWorkspacesRequest());}

public virtual DescribeWorkspacesResponse DescribeWorkspaces(){var request = new DescribeWorkspacesRequest();return DescribeWorkspaces(request);}

[User] public DescribeWorkspacesResult describeWorkspaces() {return describeWorkspaces(new DescribeWorkspacesRequest());}

[Assistant] public virtual DescribeWorkspacesResponse DescribeWorkspaces(){var request = new DescribeWorkspacesRequest();return DescribeWorkspaces(request);}


@Override public Iterator<Entry<K, V>> iterator() {return new EntryIterator();}

public override java.util.Iterator<java.util.MapClass.Entry<K, V>> iterator(){return new java.util.Hashtable<K, V>.EntryIterator(this._enclosing);}

[User] @Override public Iterator<Entry<K, V>> iterator() {return new EntryIterator();}

[Assistant] public override java.util.Iterator<java.util.MapClass.Entry<K, V>> iterator(){return new java.util.Hashtable<K, V>.EntryIterator(this._enclosing);}


public GlobalCluster removeFromGlobalCluster(RemoveFromGlobalClusterRequest request) {request = beforeClientExecution(request);return executeRemoveFromGlobalCluster(request);}

public virtual RemoveFromGlobalClusterResponse RemoveFromGlobalCluster(RemoveFromGlobalClusterRequest request){var options = new InvokeOptions();options.RequestMarshaller = RemoveFromGlobalClusterRequestMarshaller.Instance;options.ResponseUnmarshaller = RemoveFromGlobalClusterResponseUnmarshaller.Instance;return Invoke<RemoveFromGlobalClusterResponse>(request, options);}

[User] public GlobalCluster removeFromGlobalCluster(RemoveFromGlobalClusterRequest request) {request = beforeClientExecution(request);return executeRemoveFromGlobalCluster(request);}

[Assistant] public virtual RemoveFromGlobalClusterResponse RemoveFromGlobalCluster(RemoveFromGlobalClusterRequest request){var options = new InvokeOptions();options.RequestMarshaller = RemoveFromGlobalClusterRequestMarshaller.Instance;options.ResponseUnmarshaller = RemoveFromGlobalClusterResponseUnmarshaller.Instance;return Invoke<RemoveFromGlobalClusterResponse>(request, options);}


public Map<String, MergeResult<? extends Sequence>> getMergeResults() {return mergeResults;}

public virtual IDictionary<string, MergeResult<Sequence>> GetMergeResults(){return mergeResults;}

[User] public Map<String, MergeResult<? extends Sequence>> getMergeResults() {return mergeResults;}

[Assistant] public virtual IDictionary<string, MergeResult<Sequence>> GetMergeResults(){return mergeResults;}


public static final int parseTimeZoneOffset(byte[] b, int ptr) {return parseTimeZoneOffset(b, ptr, null);}

public static int ParseTimeZoneOffset(byte[] b, int ptr){int v = ParseBase10(b, ptr, null);int tzMins = v % 100;int tzHours = v / 100;return tzHours * 60 + tzMins;}

[User] public static final int parseTimeZoneOffset(byte[] b, int ptr) {return parseTimeZoneOffset(b, ptr, null);}

[Assistant] public static int ParseTimeZoneOffset(byte[] b, int ptr){int v = ParseBase10(b, ptr, null);int tzMins = v % 100;int tzHours = v / 100;return tzHours * 60 + tzMins;}


public String toString() {synchronized (Hashtable.this) {return super.toString();}}

public override string ToString(){lock (this._enclosing){return base.ToString();}}

[User] public String toString() {synchronized (Hashtable.this) {return super.toString();}}

[Assistant] public override string ToString(){lock (this._enclosing){return base.ToString();}}


public void reset() throws IOException {in.reset();lineNumber = markedLineNumber;lastChar = markedLastChar;}

public override void reset(){throw new System.NotImplementedException();}

[User] public void reset() throws IOException {in.reset();lineNumber = markedLineNumber;lastChar = markedLastChar;}

[Assistant] public override void reset(){throw new System.NotImplementedException();}


public FS newInstance() {return new FS_Win32(this);}

public override FS NewInstance(){return new NGit.Util.FS_Win32(this);}

[User] public FS newInstance() {return new FS_Win32(this);}

[Assistant] public override FS NewInstance(){return new NGit.Util.FS_Win32(this);}


public byte[] toByteArray() {if (buf != null) {byte[] r = new byte[ptr];System.arraycopy(buf, 0, r, 0, ptr);return r;}try {return overflowBuffer.toByteArray();} catch (IOException err) {throw new RuntimeException(err);}}

public virtual byte[] ToByteArray(){if (buf != null){byte[] r = new byte[ptr];System.Array.Copy(buf, 0, r, 0, ptr);return r;}try{return overflowBuffer.ToByteArray();}catch (IOException err){throw new RuntimeException(err);}}

[User] public byte[] toByteArray() {if (buf != null) {byte[] r = new byte[ptr];System.arraycopy(buf, 0, r, 0, ptr);return r;}try {return overflowBuffer.toByteArray();} catch (IOException err) {throw new RuntimeException(err);}}

[Assistant] public virtual byte[] ToByteArray(){if (buf != null){byte[] r = new byte[ptr];System.Array.Copy(buf, 0, r, 0, ptr);return r;}try{return overflowBuffer.ToByteArray();}catch (IOException err){throw new RuntimeException(err);}}


public AreaEval offset(int relFirstRowIx, int relLastRowIx, int relFirstColIx, int relLastColIx) {AreaI area = new OffsetArea(getFirstRow(), getFirstColumn(),relFirstRowIx, relLastRowIx, relFirstColIx, relLastColIx);return new LazyAreaEval(area, _evaluator);}

public override AreaEval Offset(int relFirstRowIx, int relLastRowIx, int relFirstColIx, int relLastColIx){AreaI area = new OffsetArea(FirstRow, FirstColumn,relFirstRowIx, relLastRowIx, relFirstColIx, relLastColIx);return new LazyAreaEval(area, _evaluator);}

[User] public AreaEval offset(int relFirstRowIx, int relLastRowIx, int relFirstColIx, int relLastColIx) {AreaI area = new OffsetArea(getFirstRow(), getFirstColumn(),relFirstRowIx, relLastRowIx, relFirstColIx, relLastColIx);return new LazyAreaEval(area, _evaluator);}

[Assistant] public override AreaEval Offset(int relFirstRowIx, int relLastRowIx, int relFirstColIx, int relLastColIx){AreaI area = new OffsetArea(FirstRow, FirstColumn,relFirstRowIx, relLastRowIx, relFirstColIx, relLastColIx);return new LazyAreaEval(area, _evaluator);}


public TerminateJobFlowsResult terminateJobFlows(TerminateJobFlowsRequest request) {request = beforeClientExecution(request);return executeTerminateJobFlows(request);}

public virtual TerminateJobFlowsResponse TerminateJobFlows(TerminateJobFlowsRequest request){var options = new InvokeOptions();options.RequestMarshaller = TerminateJobFlowsRequestMarshaller.Instance;options.ResponseUnmarshaller = TerminateJobFlowsResponseUnmarshaller.Instance;return Invoke<TerminateJobFlowsResponse>(request, options);}

[User] public TerminateJobFlowsResult terminateJobFlows(TerminateJobFlowsRequest request) {request = beforeClientExecution(request);return executeTerminateJobFlows(request);}

[Assistant] public virtual TerminateJobFlowsResponse TerminateJobFlows(TerminateJobFlowsRequest request){var options = new InvokeOptions();options.RequestMarshaller = TerminateJobFlowsRequestMarshaller.Instance;options.ResponseUnmarshaller = TerminateJobFlowsResponseUnmarshaller.Instance;return Invoke<TerminateJobFlowsResponse>(request, options);}


public CreateTopicRequest(String name) {setName(name);}

public CreateTopicRequest(string name){_name = name;}

[User] public CreateTopicRequest(String name) {setName(name);}

[Assistant] public CreateTopicRequest(string name){_name = name;}


public void freeBefore(int pos) {final int toFree = count - (nextPos - pos);assert toFree >= 0;assert toFree <= count;int index = nextWrite - count;if (index < 0) {index += positions.length;}for(int i=0;i<toFree;i++) {if (index == positions.length) {index = 0;}positions[index].reset();index++;}count -= toFree;}

public void FreeBefore(int pos){int toFree = count - (nextPos - pos);Debug.Assert(toFree >= 0);Debug.Assert(toFree <= count);int index = nextWrite - count;if (index < 0){index += positions.Length;}for (int i = 0; i < toFree; i++){if (index == positions.Length){index = 0;}positions[index].Reset();index++;}count -= toFree;}

[User] public void freeBefore(int pos) {final int toFree = count - (nextPos - pos);assert toFree >= 0;assert toFree <= count;int index = nextWrite - count;if (index < 0) {index += positions.length;}for(int i=0;i<toFree;i++) {if (index == positions.length) {index = 0;}positions[index].reset();index++;}count -= toFree;}

[Assistant] public void FreeBefore(int pos){int toFree = count - (nextPos - pos);Debug.Assert(toFree >= 0);Debug.Assert(toFree <= count);int index = nextWrite - count;if (index < 0){index += positions.Length;}for (int i = 0; i < toFree; i++){if (index == positions.Length){index = 0;}positions[index].Reset();index++;}count -= toFree;}


public LengthFilter create(TokenStream input) {final LengthFilter filter = new LengthFilter(input,min,max);return filter;}

public override TokenStream Create(TokenStream input){#pragma warning disable 612, 618var filter = new LengthFilter(m_luceneMatchVersion, enablePositionIncrements, input, min, max);#pragma warning restore 612, 618return filter;}

[User] public LengthFilter create(TokenStream input) {final LengthFilter filter = new LengthFilter(input,min,max);return filter;}

[Assistant] public override TokenStream Create(TokenStream input){#pragma warning disable 612, 618var filter = new LengthFilter(m_luceneMatchVersion, enablePositionIncrements, input, min, max);#pragma warning restore 612, 618return filter;}


public StandardQueryParser() {super(new StandardQueryConfigHandler(), new StandardSyntaxParser(),new StandardQueryNodeProcessorPipeline(null),new StandardQueryTreeBuilder());setEnablePositionIncrements(true);}

public StandardQueryParser(): base(new StandardQueryConfigHandler(), new StandardSyntaxParser(),new StandardQueryNodeProcessorPipeline(null),new StandardQueryTreeBuilder()){EnablePositionIncrements = true;}

[User] public StandardQueryParser() {super(new StandardQueryConfigHandler(), new StandardSyntaxParser(),new StandardQueryNodeProcessorPipeline(null),new StandardQueryTreeBuilder());setEnablePositionIncrements(true);}

[Assistant] public StandardQueryParser(): base(new StandardQueryConfigHandler(), new StandardSyntaxParser(),new StandardQueryNodeProcessorPipeline(null),new StandardQueryTreeBuilder()){EnablePositionIncrements = true;}


public GetUserSourceRepoRefListRequest(): base("cr", "2016-06-07", "GetUserSourceRepoRefList", "cr", "openAPI"){UriPattern = "/users/sourceAccount/[SourceAccountId]/repos/[SourceRepoNamespace]/[SourceRepoName]/refs";Method = MethodType.GET;}

[User] public GetUserSourceRepoRefListRequest() {super("cr", "2016-06-07", "GetUserSourceRepoRefList", "cr");setUriPattern("/users/sourceAccount/[SourceAccountId]/repos/[SourceRepoNamespace]/[SourceRepoName]/refs");setMethod(MethodType.GET);}

[Assistant] public GetUserSourceRepoRefListRequest(): base("cr", "2016-06-07", "GetUserSourceRepoRefList", "cr", "openAPI"){UriPattern = "/users/sourceAccount/[SourceAccountId]/repos/[SourceRepoNamespace]/[SourceRepoName]/refs";Method = MethodType.GET;}


public static LongBuffer wrap(long[] array, int start, int longCount) {Arrays.checkOffsetAndCount(array.length, start, longCount);LongBuffer buf = new ReadWriteLongArrayBuffer(array);buf.position = start;buf.limit = start + longCount;return buf;}

public static java.nio.LongBuffer wrap(long[] array_1, int start, int longCount){java.util.Arrays.checkOffsetAndCount(array_1.Length, start, longCount);java.nio.LongBuffer buf = new java.nio.ReadWriteLongArrayBuffer(array_1);buf._position = start;buf._limit = start + longCount;return buf;}

[User] public static LongBuffer wrap(long[] array, int start, int longCount) {Arrays.checkOffsetAndCount(array.length, start, longCount);LongBuffer buf = new ReadWriteLongArrayBuffer(array);buf.position = start;buf.limit = start + longCount;return buf;}

[Assistant] public static java.nio.LongBuffer wrap(long[] array_1, int start, int longCount){java.util.Arrays.checkOffsetAndCount(array_1.Length, start, longCount);java.nio.LongBuffer buf = new java.nio.ReadWriteLongArrayBuffer(array_1);buf._position = start;buf._limit = start + longCount;return buf;}


public UpperCaseFilterFactory(Map<String,String> args) {super(args);if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

public UpperCaseFilterFactory(IDictionary<string, string> args): base(args){AssureMatchVersion();if (args.Count > 0){throw new System.ArgumentException("Unknown parameters: " + args);}}

[User] public UpperCaseFilterFactory(Map<String,String> args) {super(args);if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

[Assistant] public UpperCaseFilterFactory(IDictionary<string, string> args): base(args){AssureMatchVersion();if (args.Count > 0){throw new System.ArgumentException("Unknown parameters: " + args);}}


public ListNotesCommand notesList() {return new ListNotesCommand(repo);}

public virtual ListNotesCommand NotesList(){return new ListNotesCommand(repo);}

[User] public ListNotesCommand notesList() {return new ListNotesCommand(repo);}

[Assistant] public virtual ListNotesCommand NotesList(){return new ListNotesCommand(repo);}


public boolean isMissingNewlineAtEnd() {final int end = lines.get(lines.size() - 1);if (end == 0)return true;return content[end - 1] != '\n';}

public virtual bool IsMissingNewlineAtEnd(){int end = lines.Get(lines.Size() - 1);if (end == 0){return true;}return content[end - 1] != '\n';}

[User] public boolean isMissingNewlineAtEnd() {final int end = lines.get(lines.size() - 1);if (end == 0)return true;return content[end - 1] != '\n';}

[Assistant] public virtual bool IsMissingNewlineAtEnd(){int end = lines.Get(lines.Size() - 1);if (end == 0){return true;}return content[end - 1] != '\n';}


public CreateDashboardResult createDashboard(CreateDashboardRequest request) {request = beforeClientExecution(request);return executeCreateDashboard(request);}

public virtual CreateDashboardResponse CreateDashboard(CreateDashboardRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateDashboardRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateDashboardResponseUnmarshaller.Instance;return Invoke<CreateDashboardResponse>(request, options);}

[User] public CreateDashboardResult createDashboard(CreateDashboardRequest request) {request = beforeClientExecution(request);return executeCreateDashboard(request);}

[Assistant] public virtual CreateDashboardResponse CreateDashboard(CreateDashboardRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateDashboardRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateDashboardResponseUnmarshaller.Instance;return Invoke<CreateDashboardResponse>(request, options);}


public void write(String str, int offset, int count) {write(str.substring(offset, offset + count).toCharArray());}

public override void write(string str, int offset, int count){write(Sharpen.StringHelper.Substring(str, offset, offset + count).ToCharArray());}

[User] public void write(String str, int offset, int count) {write(str.substring(offset, offset + count).toCharArray());}

[Assistant] public override void write(string str, int offset, int count){write(Sharpen.StringHelper.Substring(str, offset, offset + count).ToCharArray());}


public UpdateNamespaceAuthorizationRequest(): base("cr", "2016-06-07", "UpdateNamespaceAuthorization", "cr", "openAPI"){UriPattern = "/namespace/[Namespace]/authorizations/[AuthorizeId]";Method = MethodType.POST;}

[User] public UpdateNamespaceAuthorizationRequest() {super("cr", "2016-06-07", "UpdateNamespaceAuthorization", "cr");setUriPattern("/namespace/[Namespace]/authorizations/[AuthorizeId]");setMethod(MethodType.POST);}

[Assistant] public UpdateNamespaceAuthorizationRequest(): base("cr", "2016-06-07", "UpdateNamespaceAuthorization", "cr", "openAPI"){UriPattern = "/namespace/[Namespace]/authorizations/[AuthorizeId]";Method = MethodType.POST;}


public DescribeStreamResult describeStream(DescribeStreamRequest request) {request = beforeClientExecution(request);return executeDescribeStream(request);}

public virtual DescribeStreamResponse DescribeStream(DescribeStreamRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeStreamRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeStreamResponseUnmarshaller.Instance;return Invoke<DescribeStreamResponse>(request, options);}

[User] public DescribeStreamResult describeStream(DescribeStreamRequest request) {request = beforeClientExecution(request);return executeDescribeStream(request);}

[Assistant] public virtual DescribeStreamResponse DescribeStream(DescribeStreamRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeStreamRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeStreamResponseUnmarshaller.Instance;return Invoke<DescribeStreamResponse>(request, options);}


public void mark(int markLimit) throws IOException {if (markLimit < 0) {throw new IllegalArgumentException();}synchronized (lock) {checkNotClosed();this.markLimit = markLimit;mark = pos;}}

public override void mark(int markLimit){if (markLimit < 0){throw new System.ArgumentException();}lock (@lock){checkNotClosed();this.markLimit = markLimit;_mark = pos;}}

[User] public void mark(int markLimit) throws IOException {if (markLimit < 0) {throw new IllegalArgumentException();}synchronized (lock) {checkNotClosed();this.markLimit = markLimit;mark = pos;}}

[Assistant] public override void mark(int markLimit){if (markLimit < 0){throw new System.ArgumentException();}lock (@lock){checkNotClosed();this.markLimit = markLimit;_mark = pos;}}


public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {for (int i = 0; i < iterations; ++i) {final long byte0 = blocks[blocksOffset++] & 0xFF;final long byte1 = blocks[blocksOffset++] & 0xFF;final long byte2 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = (byte0 << 16) | (byte1 << 8) | byte2;}}

public override void Decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations){for (int i = 0; i < iterations; ++i){int byte0 = blocks[blocksOffset++] & 0xFF;int byte1 = blocks[blocksOffset++] & 0xFF;int byte2 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = (byte0 << 16) | (byte1 << 8) | byte2;}}

[User] public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {for (int i = 0; i < iterations; ++i) {final long byte0 = blocks[blocksOffset++] & 0xFF;final long byte1 = blocks[blocksOffset++] & 0xFF;final long byte2 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = (byte0 << 16) | (byte1 << 8) | byte2;}}

[Assistant] public override void Decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations){for (int i = 0; i < iterations; ++i){int byte0 = blocks[blocksOffset++] & 0xFF;int byte1 = blocks[blocksOffset++] & 0xFF;int byte2 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = (byte0 << 16) | (byte1 << 8) | byte2;}}


public String toString() {return String.format("channel(%d)", channel);}

public override string ToString(){return string.Format("channel({0})", channel);}

[User] public String toString() {return String.format("channel(%d)", channel);}

[Assistant] public override string ToString(){return string.Format("channel({0})", channel);}


public String getName() {int separatorIndex = path.lastIndexOf(separator);return (separatorIndex < 0) ? path : path.substring(separatorIndex + 1, path.length());}

public string getName(){int separatorIndex = path.LastIndexOf(separator);return (separatorIndex < 0) ? path : Sharpen.StringHelper.Substring(path, separatorIndex+ 1, path.Length);}

[User] public String getName() {int separatorIndex = path.lastIndexOf(separator);return (separatorIndex < 0) ? path : path.substring(separatorIndex + 1, path.length());}

[Assistant] public string getName(){int separatorIndex = path.LastIndexOf(separator);return (separatorIndex < 0) ? path : Sharpen.StringHelper.Substring(path, separatorIndex+ 1, path.Length);}


public TestInvokeMethodResult testInvokeMethod(TestInvokeMethodRequest request) {request = beforeClientExecution(request);return executeTestInvokeMethod(request);}

public virtual TestInvokeMethodResponse TestInvokeMethod(TestInvokeMethodRequest request){var options = new InvokeOptions();options.RequestMarshaller = TestInvokeMethodRequestMarshaller.Instance;options.ResponseUnmarshaller = TestInvokeMethodResponseUnmarshaller.Instance;return Invoke<TestInvokeMethodResponse>(request, options);}

[User] public TestInvokeMethodResult testInvokeMethod(TestInvokeMethodRequest request) {request = beforeClientExecution(request);return executeTestInvokeMethod(request);}

[Assistant] public virtual TestInvokeMethodResponse TestInvokeMethod(TestInvokeMethodRequest request){var options = new InvokeOptions();options.RequestMarshaller = TestInvokeMethodRequestMarshaller.Instance;options.ResponseUnmarshaller = TestInvokeMethodResponseUnmarshaller.Instance;return Invoke<TestInvokeMethodResponse>(request, options);}


public final void clearAttributes() {for (State state = getCurrentState(); state != null; state = state.next) {state.attribute.clear();}}

public void ClearAttributes(){for (State state = GetCurrentState(); state != null; state = state.next){state.attribute.Clear();}}

[User] public final void clearAttributes() {for (State state = getCurrentState(); state != null; state = state.next) {state.attribute.clear();}}

[Assistant] public void ClearAttributes(){for (State state = GetCurrentState(); state != null; state = state.next){state.attribute.Clear();}}


public ListRecipesResult listRecipes(ListRecipesRequest request) {request = beforeClientExecution(request);return executeListRecipes(request);}

public virtual ListRecipesResponse ListRecipes(ListRecipesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListRecipesRequestMarshaller.Instance;options.ResponseUnmarshaller = ListRecipesResponseUnmarshaller.Instance;return Invoke<ListRecipesResponse>(request, options);}

[User] public ListRecipesResult listRecipes(ListRecipesRequest request) {request = beforeClientExecution(request);return executeListRecipes(request);}

[Assistant] public virtual ListRecipesResponse ListRecipes(ListRecipesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListRecipesRequestMarshaller.Instance;options.ResponseUnmarshaller = ListRecipesResponseUnmarshaller.Instance;return Invoke<ListRecipesResponse>(request, options);}


public void setText(CharacterIterator newText) {text = newText;text.setIndex(text.getBeginIndex());currentSentence = 0;Span[] spans = sentenceOp.splitSentences(characterIteratorToString());sentenceStarts = new int[spans.length];for (int i = 0; i < spans.length; ++i) {sentenceStarts[i] = spans[i].getStart() + text.getBeginIndex();}}

public override void SetText(CharacterIterator newText){text = newText;text.SetIndex(text.BeginIndex);currentSentence = 0;Span[] spans = sentenceOp.SplitSentences(CharacterIteratorToString());sentenceStarts = new int[spans.Length];for (int i = 0; i < spans.Length; ++i){sentenceStarts[i] = spans[i].getStart() + text.BeginIndex;}}

[User] public void setText(CharacterIterator newText) {text = newText;text.setIndex(text.getBeginIndex());currentSentence = 0;Span[] spans = sentenceOp.splitSentences(characterIteratorToString());sentenceStarts = new int[spans.length];for (int i = 0; i < spans.length; ++i) {sentenceStarts[i] = spans[i].getStart() + text.getBeginIndex();}}

[Assistant] public override void SetText(CharacterIterator newText){text = newText;text.SetIndex(text.BeginIndex);currentSentence = 0;Span[] spans = sentenceOp.SplitSentences(CharacterIteratorToString());sentenceStarts = new int[spans.Length];for (int i = 0; i < spans.Length; ++i){sentenceStarts[i] = spans[i].getStart() + text.BeginIndex;}}


public String formatWithConflicts(String message,List<String> conflictingPaths) {StringBuilder sb = new StringBuilder();String[] lines = message.split("\n"); int firstFooterLine = ChangeIdUtil.indexOfFirstFooterLine(lines);for (int i = 0; i < firstFooterLine; i++)sb.append(lines[i]).append('\n');if (firstFooterLine == lines.length && message.length() != 0)sb.append('\n');addConflictsMessage(conflictingPaths, sb);if (firstFooterLine < lines.length)sb.append('\n');for (int i = firstFooterLine; i < lines.length; i++)sb.append(lines[i]).append('\n');return sb.toString();}

public virtual string FormatWithConflicts(string message, IList<string> conflictingPaths){StringBuilder sb = new StringBuilder(message);if (!message.EndsWith("\n") && message.Length != 0){sb.Append("\n");}sb.Append("\n");sb.Append("Conflicts:\n");foreach (string conflictingPath in conflictingPaths){sb.Append('\t').Append(conflictingPath).Append('\n');}return sb.ToString();}

[User] public String formatWithConflicts(String message,List<String> conflictingPaths) {StringBuilder sb = new StringBuilder();String[] lines = message.split("\n"); int firstFooterLine = ChangeIdUtil.indexOfFirstFooterLine(lines);for (int i = 0; i < firstFooterLine; i++)sb.append(lines[i]).append('\n');if (firstFooterLine == lines.length && message.length() != 0)sb.append('\n');addConflictsMessage(conflictingPaths, sb);if (firstFooterLine < lines.length)sb.append('\n');for (int i = firstFooterLine; i < lines.length; i++)sb.append(lines[i]).append('\n');return sb.toString();}

[Assistant] public virtual string FormatWithConflicts(string message, IList<string> conflictingPaths){StringBuilder sb = new StringBuilder(message);if (!message.EndsWith("\n") && message.Length != 0){sb.Append("\n");}sb.Append("\n");sb.Append("Conflicts:\n");foreach (string conflictingPath in conflictingPaths){sb.Append('\t').Append(conflictingPath).Append('\n');}return sb.ToString();}


public boolean get(int index) {return bits.get(index);}

public virtual bool Get(int index){return bits.SafeGet(index);}

[User] public boolean get(int index) {return bits.get(index);}

[Assistant] public virtual bool Get(int index){return bits.SafeGet(index);}


public DescribeTaskSetsResult describeTaskSets(DescribeTaskSetsRequest request) {request = beforeClientExecution(request);return executeDescribeTaskSets(request);}

public virtual DescribeTaskSetsResponse DescribeTaskSets(DescribeTaskSetsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeTaskSetsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeTaskSetsResponseUnmarshaller.Instance;return Invoke<DescribeTaskSetsResponse>(request, options);}

[User] public DescribeTaskSetsResult describeTaskSets(DescribeTaskSetsRequest request) {request = beforeClientExecution(request);return executeDescribeTaskSets(request);}

[Assistant] public virtual DescribeTaskSetsResponse DescribeTaskSets(DescribeTaskSetsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeTaskSetsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeTaskSetsResponseUnmarshaller.Instance;return Invoke<DescribeTaskSetsResponse>(request, options);}


public void add(FormulaRecordAggregate agg) {if (_numberOfFormulas == 0) {if (_firstCell.getRow() != agg.getRow() || _firstCell.getCol() != agg.getColumn()) {throw new IllegalStateException("shared formula coding error: "+_firstCell.getCol()+'/'+_firstCell.getRow()+" != "+agg.getColumn()+'/'+agg.getRow());}}if (_numberOfFormulas >= _frAggs.length) {throw new RuntimeException("Too many formula records for shared formula group");}_frAggs[_numberOfFormulas++] = agg;}

public void Add(FormulaRecordAggregate agg){if (_numberOfFormulas == 0){if (_firstCell.Row != agg.Row || _firstCell.Col != agg.Column){throw new InvalidOperationException("shared formula coding error");}}if (_numberOfFormulas >= _frAggs.Length){throw new Exception("Too many formula records for shared formula group");}_frAggs[_numberOfFormulas++] = agg;}

[User] public void add(FormulaRecordAggregate agg) {if (_numberOfFormulas == 0) {if (_firstCell.getRow() != agg.getRow() || _firstCell.getCol() != agg.getColumn()) {throw new IllegalStateException("shared formula coding error: "+_firstCell.getCol()+'/'+_firstCell.getRow()+" != "+agg.getColumn()+'/'+agg.getRow());}}if (_numberOfFormulas >= _frAggs.length) {throw new RuntimeException("Too many formula records for shared formula group");}_frAggs[_numberOfFormulas++] = agg;}

[Assistant] public void Add(FormulaRecordAggregate agg){if (_numberOfFormulas == 0){if (_firstCell.Row != agg.Row || _firstCell.Col != agg.Column){throw new InvalidOperationException("shared formula coding error");}}if (_numberOfFormulas >= _frAggs.Length){throw new Exception("Too many formula records for shared formula group");}_frAggs[_numberOfFormulas++] = agg;}


public PacketLineOutRefAdvertiser(PacketLineOut out) {pckOut = out;}

public PacketLineOutRefAdvertiser(PacketLineOut @out){pckOut = @out;}

[User] public PacketLineOutRefAdvertiser(PacketLineOut out) {pckOut = out;}

[Assistant] public PacketLineOutRefAdvertiser(PacketLineOut @out){pckOut = @out;}


public UpdateDataSetResult updateDataSet(UpdateDataSetRequest request) {request = beforeClientExecution(request);return executeUpdateDataSet(request);}

public virtual UpdateDataSetResponse UpdateDataSet(UpdateDataSetRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateDataSetRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateDataSetResponseUnmarshaller.Instance;return Invoke<UpdateDataSetResponse>(request, options);}

[User] public UpdateDataSetResult updateDataSet(UpdateDataSetRequest request) {request = beforeClientExecution(request);return executeUpdateDataSet(request);}

[Assistant] public virtual UpdateDataSetResponse UpdateDataSet(UpdateDataSetRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateDataSetRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateDataSetResponseUnmarshaller.Instance;return Invoke<UpdateDataSetResponse>(request, options);}


public ListKeyPhrasesDetectionJobsResult listKeyPhrasesDetectionJobs(ListKeyPhrasesDetectionJobsRequest request) {request = beforeClientExecution(request);return executeListKeyPhrasesDetectionJobs(request);}

public virtual ListKeyPhrasesDetectionJobsResponse ListKeyPhrasesDetectionJobs(ListKeyPhrasesDetectionJobsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListKeyPhrasesDetectionJobsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListKeyPhrasesDetectionJobsResponseUnmarshaller.Instance;return Invoke<ListKeyPhrasesDetectionJobsResponse>(request, options);}

[User] public ListKeyPhrasesDetectionJobsResult listKeyPhrasesDetectionJobs(ListKeyPhrasesDetectionJobsRequest request) {request = beforeClientExecution(request);return executeListKeyPhrasesDetectionJobs(request);}

[Assistant] public virtual ListKeyPhrasesDetectionJobsResponse ListKeyPhrasesDetectionJobs(ListKeyPhrasesDetectionJobsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListKeyPhrasesDetectionJobsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListKeyPhrasesDetectionJobsResponseUnmarshaller.Instance;return Invoke<ListKeyPhrasesDetectionJobsResponse>(request, options);}


@Override public void clear() {Impl.this.clear();}

public override void clear(){this._enclosing.clear();}

[User] @Override public void clear() {Impl.this.clear();}

[Assistant] public override void clear(){this._enclosing.clear();}


public VaultNotificationConfig(String sNSTopic, java.util.List<String> events) {setSNSTopic(sNSTopic);setEvents(events);}

public VaultNotificationConfig(string snsTopic, List<string> events){_snsTopic = snsTopic;_events = events;}

[User] public VaultNotificationConfig(String sNSTopic, java.util.List<String> events) {setSNSTopic(sNSTopic);setEvents(events);}

[Assistant] public VaultNotificationConfig(string snsTopic, List<string> events){_snsTopic = snsTopic;_events = events;}


public String[] lemmatize(String[] words, String[] postags) {String[] lemmas = null;String[] maxEntLemmas = null;if (dictionaryLemmatizer != null) {lemmas = dictionaryLemmatizer.lemmatize(words, postags);for (int i = 0; i < lemmas.length; ++i) {if (lemmas[i].equals("O")) {   if (lemmatizerME != null) {  if (maxEntLemmas == null) {maxEntLemmas = lemmatizerME.lemmatize(words, postags);}if ("_".equals(maxEntLemmas[i])) {lemmas[i] = words[i];    } else {lemmas[i] = maxEntLemmas[i];}} else {                     lemmas[i] = words[i];      }}}} else {                           maxEntLemmas = lemmatizerME.lemmatize(words, postags);for (int i = 0 ; i < maxEntLemmas.length ; ++i) {if ("_".equals(maxEntLemmas[i])) {maxEntLemmas[i] = words[i];  }}lemmas = maxEntLemmas;}return lemmas;}

public virtual string[] Lemmatize(string[] words, string[] postags){string[] lemmas = null;string[] maxEntLemmas = null;if (dictionaryLemmatizer != null){lemmas = dictionaryLemmatizer.lemmatize(words, postags);for (int i = 0; i < lemmas.Length; ++i){if (lemmas[i].Equals("O")){   if (lemmatizerME != null){  if (maxEntLemmas == null){maxEntLemmas = lemmatizerME.lemmatize(words, postags);}if ("_".Equals(maxEntLemmas[i])){lemmas[i] = words[i];    }else{lemmas[i] = maxEntLemmas[i];}}else{                     lemmas[i] = words[i];      }}}}else{                           maxEntLemmas = lemmatizerME.lemmatize(words, postags);for (int i = 0; i < maxEntLemmas.Length; ++i){if ("_".Equals(maxEntLemmas[i])){maxEntLemmas[i] = words[i];  }}lemmas = maxEntLemmas;}return lemmas;}

[User] public String[] lemmatize(String[] words, String[] postags) {String[] lemmas = null;String[] maxEntLemmas = null;if (dictionaryLemmatizer != null) {lemmas = dictionaryLemmatizer.lemmatize(words, postags);for (int i = 0; i < lemmas.length; ++i) {if (lemmas[i].equals("O")) {   if (lemmatizerME != null) {  if (maxEntLemmas == null) {maxEntLemmas = lemmatizerME.lemmatize(words, postags);}if ("_".equals(maxEntLemmas[i])) {lemmas[i] = words[i];    } else {lemmas[i] = maxEntLemmas[i];}} else {                     lemmas[i] = words[i];      }}}} else {                           maxEntLemmas = lemmatizerME.lemmatize(words, postags);for (int i = 0 ; i < maxEntLemmas.length ; ++i) {if ("_".equals(maxEntLemmas[i])) {maxEntLemmas[i] = words[i];  }}lemmas = maxEntLemmas;}return lemmas;}

[Assistant] public virtual string[] Lemmatize(string[] words, string[] postags){string[] lemmas = null;string[] maxEntLemmas = null;if (dictionaryLemmatizer != null){lemmas = dictionaryLemmatizer.lemmatize(words, postags);for (int i = 0; i < lemmas.Length; ++i){if (lemmas[i].Equals("O")){   if (lemmatizerME != null){  if (maxEntLemmas == null){maxEntLemmas = lemmatizerME.lemmatize(words, postags);}if ("_".Equals(maxEntLemmas[i])){lemmas[i] = words[i];    }else{lemmas[i] = maxEntLemmas[i];}}else{                     lemmas[i] = words[i];      }}}}else{                           maxEntLemmas = lemmatizerME.lemmatize(words, postags);for (int i = 0; i < maxEntLemmas.Length; ++i){if ("_".Equals(maxEntLemmas[i])){maxEntLemmas[i] = words[i];  }}lemmas = maxEntLemmas;}return lemmas;}


public PaletteRecord(RecordInputStream in) {int field_1_numcolors = in.readShort();_colors.ensureCapacity(field_1_numcolors);for (int k = 0; k < field_1_numcolors; k++) {_colors.add(new PColor(in));}}

public PaletteRecord(RecordInputStream in1){short field_1_numcolors = in1.ReadShort();field_2_colors = new List<PColor>(field_1_numcolors);for (int k = 0; k < field_1_numcolors; k++){field_2_colors.Add(new PColor(in1));}}

[User] public PaletteRecord(RecordInputStream in) {int field_1_numcolors = in.readShort();_colors.ensureCapacity(field_1_numcolors);for (int k = 0; k < field_1_numcolors; k++) {_colors.add(new PColor(in));}}

[Assistant] public PaletteRecord(RecordInputStream in1){short field_1_numcolors = in1.ReadShort();field_2_colors = new List<PColor>(field_1_numcolors);for (int k = 0; k < field_1_numcolors; k++){field_2_colors.Add(new PColor(in1));}}


public GetJobOutputRequest(String accountId, String vaultName, String jobId, String range) {setAccountId(accountId);setVaultName(vaultName);setJobId(jobId);setRange(range);}

public GetJobOutputRequest(string accountId, string vaultName, string jobId, string range){_accountId = accountId;_vaultName = vaultName;_jobId = jobId;_range = range;}

[User] public GetJobOutputRequest(String accountId, String vaultName, String jobId, String range) {setAccountId(accountId);setVaultName(vaultName);setJobId(jobId);setRange(range);}

[Assistant] public GetJobOutputRequest(string accountId, string vaultName, string jobId, string range){_accountId = accountId;_vaultName = vaultName;_jobId = jobId;_range = range;}


public ISigner getSigner() {return null;}

public ISigner GetSigner(){return null;}

[User] public ISigner getSigner() {return null;}

[Assistant] public ISigner GetSigner(){return null;}


public static int codePointCount(BytesRef utf8) {int pos = utf8.offset;final int limit = pos + utf8.length;final byte[] bytes = utf8.bytes;int codePointCount = 0;for (; pos < limit; codePointCount++) {int v = bytes[pos] & 0xFF;if (v <    0x80) { pos += 1; continue; }if (v >=   0xc0) {if (v <  0xe0) { pos += 2; continue; }if (v <  0xf0) { pos += 3; continue; }if (v <  0xf8) { pos += 4; continue; }}throw new IllegalArgumentException();}if (pos > limit) throw new IllegalArgumentException();return codePointCount;}

public static int CodePointCount(BytesRef utf8){int pos = utf8.Offset;int limit = pos + utf8.Length;var bytes = utf8.Bytes;int codePointCount = 0;for (; pos < limit; codePointCount++){int v = bytes[pos] & 0xFF;if (v <    0x80) { pos += 1; continue; }if (v >=   0xc0){if (v <  0xe0) { pos += 2; continue; }if (v <  0xf0) { pos += 3; continue; }if (v <  0xf8) { pos += 4; continue; }}throw new ArgumentException();}if (pos > limit) throw new ArgumentException();return codePointCount;}

[User] public static int codePointCount(BytesRef utf8) {int pos = utf8.offset;final int limit = pos + utf8.length;final byte[] bytes = utf8.bytes;int codePointCount = 0;for (; pos < limit; codePointCount++) {int v = bytes[pos] & 0xFF;if (v <    0x80) { pos += 1; continue; }if (v >=   0xc0) {if (v <  0xe0) { pos += 2; continue; }if (v <  0xf0) { pos += 3; continue; }if (v <  0xf8) { pos += 4; continue; }}throw new IllegalArgumentException();}if (pos > limit) throw new IllegalArgumentException();return codePointCount;}

[Assistant] public static int CodePointCount(BytesRef utf8){int pos = utf8.Offset;int limit = pos + utf8.Length;var bytes = utf8.Bytes;int codePointCount = 0;for (; pos < limit; codePointCount++){int v = bytes[pos] & 0xFF;if (v <    0x80) { pos += 1; continue; }if (v >=   0xc0){if (v <  0xe0) { pos += 2; continue; }if (v <  0xf0) { pos += 3; continue; }if (v <  0xf8) { pos += 4; continue; }}throw new ArgumentException();}if (pos > limit) throw new ArgumentException();return codePointCount;}


public static Class<? extends Record> getRecordClass(int sid) {I_RecordCreator rc = _recordCreatorsById.get(Integer.valueOf(sid));if (rc == null) {return null;}return rc.getRecordClass();}

public static Type GetRecordClass(int sid){I_RecordCreator rc = _recordCreatorsById[(short)sid];if (rc == null){return null;}return rc.GetRecordClass();}

[User] public static Class<? extends Record> getRecordClass(int sid) {I_RecordCreator rc = _recordCreatorsById.get(Integer.valueOf(sid));if (rc == null) {return null;}return rc.getRecordClass();}

[Assistant] public static Type GetRecordClass(int sid){I_RecordCreator rc = _recordCreatorsById[(short)sid];if (rc == null){return null;}return rc.GetRecordClass();}


public WriteAccessRecord(RecordInputStream in) {if (in.remaining() > DATA_SIZE) {throw new RecordFormatException("Expected data size (" + DATA_SIZE + ") but got ("+ in.remaining() + ")");}int nChars = in.readUShort();int is16BitFlag = in.readUByte();if (nChars > DATA_SIZE || (is16BitFlag & 0xFE) != 0) {byte[] data = new byte[3 + in.remaining()];LittleEndian.putUShort(data, 0, nChars);LittleEndian.putByte(data, 2, is16BitFlag);in.readFully(data, 3, data.length-3);String rawValue = new String(data, StringUtil.UTF8);setUsername(rawValue.trim());return;}String rawText;if ((is16BitFlag & 0x01) == 0x00) {rawText = StringUtil.readCompressedUnicode(in, nChars);} else {rawText = StringUtil.readUnicodeLE(in, nChars);}field_1_username = rawText.trim();int padSize = in.remaining();while (padSize > 0) {in.readUByte();padSize--;}}

public WriteAccessRecord(RecordInputStream in1){if (in1.Remaining > DATA_SIZE){throw new RecordFormatException("Expected data size (" + DATA_SIZE + ") but got ("+ in1.Remaining + ")");}int nChars = in1.ReadUShort();int is16BitFlag = in1.ReadUByte();if (nChars > DATA_SIZE || (is16BitFlag & 0xFE) != 0){byte[] data = new byte[3 + in1.Remaining];LittleEndian.PutUShort(data, 0, nChars);LittleEndian.PutByte(data, 2, is16BitFlag);in1.ReadFully(data, 3, data.Length - 3);char[] data1=new char[data.Length];for (int i = 0; i < data.Length; i++){data1[i] = (char)data[i];}String rawValue = new String(data1);Username = rawValue.Trim();return;}String rawText;if ((is16BitFlag & 0x01) == 0x00){rawText = StringUtil.ReadCompressedUnicode(in1, nChars);}else{rawText = StringUtil.ReadUnicodeLE(in1, nChars);}field_1_username = rawText.Trim();int padSize = in1.Remaining;while (padSize > 0){in1.ReadUByte();padSize--;}}

[User] public WriteAccessRecord(RecordInputStream in) {if (in.remaining() > DATA_SIZE) {throw new RecordFormatException("Expected data size (" + DATA_SIZE + ") but got ("+ in.remaining() + ")");}int nChars = in.readUShort();int is16BitFlag = in.readUByte();if (nChars > DATA_SIZE || (is16BitFlag & 0xFE) != 0) {byte[] data = new byte[3 + in.remaining()];LittleEndian.putUShort(data, 0, nChars);LittleEndian.putByte(data, 2, is16BitFlag);in.readFully(data, 3, data.length-3);String rawValue = new String(data, StringUtil.UTF8);setUsername(rawValue.trim());return;}String rawText;if ((is16BitFlag & 0x01) == 0x00) {rawText = StringUtil.readCompressedUnicode(in, nChars);} else {rawText = StringUtil.readUnicodeLE(in, nChars);}field_1_username = rawText.trim();int padSize = in.remaining();while (padSize > 0) {in.readUByte();padSize--;}}

[Assistant] public WriteAccessRecord(RecordInputStream in1){if (in1.Remaining > DATA_SIZE){throw new RecordFormatException("Expected data size (" + DATA_SIZE + ") but got ("+ in1.Remaining + ")");}int nChars = in1.ReadUShort();int is16BitFlag = in1.ReadUByte();if (nChars > DATA_SIZE || (is16BitFlag & 0xFE) != 0){byte[] data = new byte[3 + in1.Remaining];LittleEndian.PutUShort(data, 0, nChars);LittleEndian.PutByte(data, 2, is16BitFlag);in1.ReadFully(data, 3, data.Length - 3);char[] data1=new char[data.Length];for (int i = 0; i < data.Length; i++){data1[i] = (char)data[i];}String rawValue = new String(data1);Username = rawValue.Trim();return;}String rawText;if ((is16BitFlag & 0x01) == 0x00){rawText = StringUtil.ReadCompressedUnicode(in1, nChars);}else{rawText = StringUtil.ReadUnicodeLE(in1, nChars);}field_1_username = rawText.Trim();int padSize = in1.Remaining;while (padSize > 0){in1.ReadUByte();padSize--;}}


public FontBasisRecord(RecordInputStream in){field_1_xBasis                 = in.readShort();field_2_yBasis                 = in.readShort();field_3_heightBasis            = in.readShort();field_4_scale                  = in.readShort();field_5_indexToFontTable       = in.readShort();}

public FontBasisRecord(RecordInputStream in1){field_1_xBasis = in1.ReadShort();field_2_yBasis = in1.ReadShort();field_3_heightBasis = in1.ReadShort();field_4_scale = in1.ReadShort();field_5_indexToFontTable = in1.ReadShort();}

[User] public FontBasisRecord(RecordInputStream in){field_1_xBasis                 = in.readShort();field_2_yBasis                 = in.readShort();field_3_heightBasis            = in.readShort();field_4_scale                  = in.readShort();field_5_indexToFontTable       = in.readShort();}

[Assistant] public FontBasisRecord(RecordInputStream in1){field_1_xBasis = in1.ReadShort();field_2_yBasis = in1.ReadShort();field_3_heightBasis = in1.ReadShort();field_4_scale = in1.ReadShort();field_5_indexToFontTable = in1.ReadShort();}


public String encodeText(String originalText) {return originalText;}

public virtual string EncodeText(string originalText){return originalText;}

[User] public String encodeText(String originalText) {return originalText;}

[Assistant] public virtual string EncodeText(string originalText){return originalText;}


public PathEdit(String entryPath) {path = Constants.encode(entryPath);}

public PathEdit(string entryPath){path = Constants.Encode(entryPath);}

[User] public PathEdit(String entryPath) {path = Constants.encode(entryPath);}

[Assistant] public PathEdit(string entryPath){path = Constants.Encode(entryPath);}


public boolean add(char[] text) {return map.put(text, PLACEHOLDER) == null;}

public virtual bool Add(char[] text){return map.Put(text);}

[User] public boolean add(char[] text) {return map.put(text, PLACEHOLDER) == null;}

[Assistant] public virtual bool Add(char[] text){return map.Put(text);}


public ResolveAliasResult resolveAlias(ResolveAliasRequest request) {request = beforeClientExecution(request);return executeResolveAlias(request);}

public virtual ResolveAliasResponse ResolveAlias(ResolveAliasRequest request){var options = new InvokeOptions();options.RequestMarshaller = ResolveAliasRequestMarshaller.Instance;options.ResponseUnmarshaller = ResolveAliasResponseUnmarshaller.Instance;return Invoke<ResolveAliasResponse>(request, options);}

[User] public ResolveAliasResult resolveAlias(ResolveAliasRequest request) {request = beforeClientExecution(request);return executeResolveAlias(request);}

[Assistant] public virtual ResolveAliasResponse ResolveAlias(ResolveAliasRequest request){var options = new InvokeOptions();options.RequestMarshaller = ResolveAliasRequestMarshaller.Instance;options.ResponseUnmarshaller = ResolveAliasResponseUnmarshaller.Instance;return Invoke<ResolveAliasResponse>(request, options);}


public TokenStream create(TokenStream input) {return new GreekStemFilter(input);}

public override TokenStream Create(TokenStream input){return new GreekStemFilter(input);}

[User] public TokenStream create(TokenStream input) {return new GreekStemFilter(input);}

[Assistant] public override TokenStream Create(TokenStream input){return new GreekStemFilter(input);}


public DescribeCacheSecurityGroupsRequest(string cacheSecurityGroupName){_cacheSecurityGroupName = cacheSecurityGroupName;}

[User] public DescribeCacheSecurityGroupsRequest(String cacheSecurityGroupName) {setCacheSecurityGroupName(cacheSecurityGroupName);}

[Assistant] public DescribeCacheSecurityGroupsRequest(string cacheSecurityGroupName){_cacheSecurityGroupName = cacheSecurityGroupName;}


public void readFully(byte[] buf, int off, int len) {if (shouldSkipEncryptionOnCurrentRecord) {readPlain(buf, off, buf.length);} else {ccis.readFully(buf, off, len);}}

public void ReadFully(byte[] buf, int off, int len){_le.ReadFully(buf, off, len);_rc4.Xor(buf, off, len);}

[User] public void readFully(byte[] buf, int off, int len) {if (shouldSkipEncryptionOnCurrentRecord) {readPlain(buf, off, buf.length);} else {ccis.readFully(buf, off, len);}}

[Assistant] public void ReadFully(byte[] buf, int off, int len){_le.ReadFully(buf, off, len);_rc4.Xor(buf, off, len);}


public static byte[] copyOf(byte[] original, int newLength) {if (newLength < 0) {throw new NegativeArraySizeException();}return copyOfRange(original, 0, newLength);}

public static byte[] copyOf(byte[] original, int newLength){if (newLength < 0){throw new java.lang.NegativeArraySizeException();}return copyOfRange(original, 0, newLength);}

[User] public static byte[] copyOf(byte[] original, int newLength) {if (newLength < 0) {throw new NegativeArraySizeException();}return copyOfRange(original, 0, newLength);}

[Assistant] public static byte[] copyOf(byte[] original, int newLength){if (newLength < 0){throw new java.lang.NegativeArraySizeException();}return copyOfRange(original, 0, newLength);}


public DeleteDomainNameResult deleteDomainName(DeleteDomainNameRequest request) {request = beforeClientExecution(request);return executeDeleteDomainName(request);}

public virtual DeleteDomainNameResponse DeleteDomainName(DeleteDomainNameRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteDomainNameRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteDomainNameResponseUnmarshaller.Instance;return Invoke<DeleteDomainNameResponse>(request, options);}

[User] public DeleteDomainNameResult deleteDomainName(DeleteDomainNameRequest request) {request = beforeClientExecution(request);return executeDeleteDomainName(request);}

[Assistant] public virtual DeleteDomainNameResponse DeleteDomainName(DeleteDomainNameRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteDomainNameRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteDomainNameResponseUnmarshaller.Instance;return Invoke<DeleteDomainNameResponse>(request, options);}


public GlobalReplicationGroup decreaseNodeGroupsInGlobalReplicationGroup(DecreaseNodeGroupsInGlobalReplicationGroupRequest request) {request = beforeClientExecution(request);return executeDecreaseNodeGroupsInGlobalReplicationGroup(request);}

public virtual DecreaseNodeGroupsInGlobalReplicationGroupResponse DecreaseNodeGroupsInGlobalReplicationGroup(DecreaseNodeGroupsInGlobalReplicationGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = DecreaseNodeGroupsInGlobalReplicationGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = DecreaseNodeGroupsInGlobalReplicationGroupResponseUnmarshaller.Instance;return Invoke<DecreaseNodeGroupsInGlobalReplicationGroupResponse>(request, options);}

[User] public GlobalReplicationGroup decreaseNodeGroupsInGlobalReplicationGroup(DecreaseNodeGroupsInGlobalReplicationGroupRequest request) {request = beforeClientExecution(request);return executeDecreaseNodeGroupsInGlobalReplicationGroup(request);}

[Assistant] public virtual DecreaseNodeGroupsInGlobalReplicationGroupResponse DecreaseNodeGroupsInGlobalReplicationGroup(DecreaseNodeGroupsInGlobalReplicationGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = DecreaseNodeGroupsInGlobalReplicationGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = DecreaseNodeGroupsInGlobalReplicationGroupResponseUnmarshaller.Instance;return Invoke<DecreaseNodeGroupsInGlobalReplicationGroupResponse>(request, options);}


public SelectRequest(String selectExpression, Boolean consistentRead) {setSelectExpression(selectExpression);setConsistentRead(consistentRead);}

public SelectRequest(string selectExpression, bool consistentRead){_selectExpression = selectExpression;_consistentRead = consistentRead;}

[User] public SelectRequest(String selectExpression, Boolean consistentRead) {setSelectExpression(selectExpression);setConsistentRead(consistentRead);}

[Assistant] public SelectRequest(string selectExpression, bool consistentRead){_selectExpression = selectExpression;_consistentRead = consistentRead;}


public SubmoduleAddCommand setURI(String uri) {this.uri = uri;return this;}

public virtual NGit.Api.SubmoduleAddCommand SetURI(string uri){this.uri = uri;return this;}

[User] public SubmoduleAddCommand setURI(String uri) {this.uri = uri;return this;}

[Assistant] public virtual NGit.Api.SubmoduleAddCommand SetURI(string uri){this.uri = uri;return this;}


public PutRestApiResult putRestApi(PutRestApiRequest request) {request = beforeClientExecution(request);return executePutRestApi(request);}

public virtual PutRestApiResponse PutRestApi(PutRestApiRequest request){var options = new InvokeOptions();options.RequestMarshaller = PutRestApiRequestMarshaller.Instance;options.ResponseUnmarshaller = PutRestApiResponseUnmarshaller.Instance;return Invoke<PutRestApiResponse>(request, options);}

[User] public PutRestApiResult putRestApi(PutRestApiRequest request) {request = beforeClientExecution(request);return executePutRestApi(request);}

[Assistant] public virtual PutRestApiResponse PutRestApi(PutRestApiRequest request){var options = new InvokeOptions();options.RequestMarshaller = PutRestApiRequestMarshaller.Instance;options.ResponseUnmarshaller = PutRestApiResponseUnmarshaller.Instance;return Invoke<PutRestApiResponse>(request, options);}


public Ptg get3DReferencePtg(AreaReference areaRef, SheetIdentifier sheet) {int extIx = getSheetExtIx(sheet);return new Area3DPtg(areaRef, extIx);}

public Ptg Get3DReferencePtg(CellReference cr, SheetIdentifier sheet){int extIx = GetSheetExtIx(sheet);return new Ref3DPtg(cr, extIx);}

[User] public Ptg get3DReferencePtg(AreaReference areaRef, SheetIdentifier sheet) {int extIx = getSheetExtIx(sheet);return new Area3DPtg(areaRef, extIx);}

[Assistant] public Ptg Get3DReferencePtg(CellReference cr, SheetIdentifier sheet){int extIx = GetSheetExtIx(sheet);return new Ref3DPtg(cr, extIx);}


public CreateRequestValidatorResult createRequestValidator(CreateRequestValidatorRequest request) {request = beforeClientExecution(request);return executeCreateRequestValidator(request);}

public virtual CreateRequestValidatorResponse CreateRequestValidator(CreateRequestValidatorRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateRequestValidatorRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateRequestValidatorResponseUnmarshaller.Instance;return Invoke<CreateRequestValidatorResponse>(request, options);}

[User] public CreateRequestValidatorResult createRequestValidator(CreateRequestValidatorRequest request) {request = beforeClientExecution(request);return executeCreateRequestValidator(request);}

[Assistant] public virtual CreateRequestValidatorResponse CreateRequestValidator(CreateRequestValidatorRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateRequestValidatorRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateRequestValidatorResponseUnmarshaller.Instance;return Invoke<CreateRequestValidatorResponse>(request, options);}


public ByteBuffer duplicate() {return copy(this, mark);}

public override java.nio.ByteBuffer duplicate(){return copy(this, _mark);}

[User] public ByteBuffer duplicate() {return copy(this, mark);}

[Assistant] public override java.nio.ByteBuffer duplicate(){return copy(this, _mark);}


public void setPackedGitWindowSize(int newSize) {packedGitWindowSize = newSize;}

public virtual void SetPackedGitWindowSize(int newSize){packedGitWindowSize = newSize;}

[User] public void setPackedGitWindowSize(int newSize) {packedGitWindowSize = newSize;}

[Assistant] public virtual void SetPackedGitWindowSize(int newSize){packedGitWindowSize = newSize;}


public DisassociateMembershipResult disassociateMembership(DisassociateMembershipRequest request) {request = beforeClientExecution(request);return executeDisassociateMembership(request);}

public virtual DisassociateMembershipResponse DisassociateMembership(DisassociateMembershipRequest request){var options = new InvokeOptions();options.RequestMarshaller = DisassociateMembershipRequestMarshaller.Instance;options.ResponseUnmarshaller = DisassociateMembershipResponseUnmarshaller.Instance;return Invoke<DisassociateMembershipResponse>(request, options);}

[User] public DisassociateMembershipResult disassociateMembership(DisassociateMembershipRequest request) {request = beforeClientExecution(request);return executeDisassociateMembership(request);}

[Assistant] public virtual DisassociateMembershipResponse DisassociateMembership(DisassociateMembershipRequest request){var options = new InvokeOptions();options.RequestMarshaller = DisassociateMembershipRequestMarshaller.Instance;options.ResponseUnmarshaller = DisassociateMembershipResponseUnmarshaller.Instance;return Invoke<DisassociateMembershipResponse>(request, options);}


public void parse(Reader in) throws IOException, ParseException {LineNumberReader br = new LineNumberReader(in);try {String line = null;String lastSynSetID = "";CharsRef synset[] = new CharsRef[8];int synsetSize = 0;while ((line = br.readLine()) != null) {String synSetID = line.substring(2, 11);if (!synSetID.equals(lastSynSetID)) {addInternal(synset, synsetSize);synsetSize = 0;}synset = ArrayUtil.grow(synset, synsetSize + 1);synset[synsetSize] = parseSynonym(line, new CharsRefBuilder());synsetSize++;lastSynSetID = synSetID;}addInternal(synset, synsetSize);} catch (IllegalArgumentException e) {ParseException ex = new ParseException("Invalid synonym rule at line " + br.getLineNumber(), 0);ex.initCause(e);throw ex;} finally {br.close();}}

public override void Parse(TextReader @in){int lineNumber = 0;TextReader br = @in;try{string line = null;string lastSynSetID = "";CharsRef[] synset = new CharsRef[8];int synsetSize = 0;while ((line = br.ReadLine()) != null){lineNumber++;string synSetID = line.Substring(2, 9);if (!synSetID.Equals(lastSynSetID, StringComparison.Ordinal)){AddInternal(synset, synsetSize);synsetSize = 0;}if (synset.Length <= synsetSize + 1){CharsRef[] larger = new CharsRef[synset.Length * 2];Array.Copy(synset, 0, larger, 0, synsetSize);synset = larger;}synset[synsetSize] = ParseSynonym(line, synset[synsetSize]);synsetSize++;lastSynSetID = synSetID;}AddInternal(synset, synsetSize);}catch (System.ArgumentException e){throw new Exception("Invalid synonym rule at line " + lineNumber.ToString(), e);}finally{br.Dispose();}}

[User] public void parse(Reader in) throws IOException, ParseException {LineNumberReader br = new LineNumberReader(in);try {String line = null;String lastSynSetID = "";CharsRef synset[] = new CharsRef[8];int synsetSize = 0;while ((line = br.readLine()) != null) {String synSetID = line.substring(2, 11);if (!synSetID.equals(lastSynSetID)) {addInternal(synset, synsetSize);synsetSize = 0;}synset = ArrayUtil.grow(synset, synsetSize + 1);synset[synsetSize] = parseSynonym(line, new CharsRefBuilder());synsetSize++;lastSynSetID = synSetID;}addInternal(synset, synsetSize);} catch (IllegalArgumentException e) {ParseException ex = new ParseException("Invalid synonym rule at line " + br.getLineNumber(), 0);ex.initCause(e);throw ex;} finally {br.close();}}

[Assistant] public override void Parse(TextReader @in){int lineNumber = 0;TextReader br = @in;try{string line = null;string lastSynSetID = "";CharsRef[] synset = new CharsRef[8];int synsetSize = 0;while ((line = br.ReadLine()) != null){lineNumber++;string synSetID = line.Substring(2, 9);if (!synSetID.Equals(lastSynSetID, StringComparison.Ordinal)){AddInternal(synset, synsetSize);synsetSize = 0;}if (synset.Length <= synsetSize + 1){CharsRef[] larger = new CharsRef[synset.Length * 2];Array.Copy(synset, 0, larger, 0, synsetSize);synset = larger;}synset[synsetSize] = ParseSynonym(line, synset[synsetSize]);synsetSize++;lastSynSetID = synSetID;}AddInternal(synset, synsetSize);}catch (System.ArgumentException e){throw new Exception("Invalid synonym rule at line " + lineNumber.ToString(), e);}finally{br.Dispose();}}


public String[] list() {return listImpl(path);}

public string[] list(){return listImpl(path);}

[User] public String[] list() {return listImpl(path);}

[Assistant] public string[] list(){return listImpl(path);}


public String toString() {StringBuilder buffer = new StringBuilder();buffer.append("[ENDOBJECT]\n");buffer.append("    .rt         =").append(HexDump.shortToHex(rt)).append('\n');buffer.append("    .grbitFrt   =").append(HexDump.shortToHex(grbitFrt)).append('\n');buffer.append("    .iObjectKind=").append(HexDump.shortToHex(iObjectKind)).append('\n');buffer.append("    .reserved   =").append(HexDump.toHex(reserved)).append('\n');buffer.append("[/ENDOBJECT]\n");return buffer.toString();}

public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append("[ENDOBJECT]\n");buffer.Append("    .rt         =").Append(HexDump.ShortToHex(rt)).Append('\n');buffer.Append("    .grbitFrt   =").Append(HexDump.ShortToHex(grbitFrt)).Append('\n');buffer.Append("    .iObjectKind=").Append(HexDump.ShortToHex(iObjectKind)).Append('\n');buffer.Append("    .unused     =").Append(HexDump.ToHex(reserved)).Append('\n');buffer.Append("[/ENDOBJECT]\n");return buffer.ToString();}

[User] public String toString() {StringBuilder buffer = new StringBuilder();buffer.append("[ENDOBJECT]\n");buffer.append("    .rt         =").append(HexDump.shortToHex(rt)).append('\n');buffer.append("    .grbitFrt   =").append(HexDump.shortToHex(grbitFrt)).append('\n');buffer.append("    .iObjectKind=").append(HexDump.shortToHex(iObjectKind)).append('\n');buffer.append("    .reserved   =").append(HexDump.toHex(reserved)).append('\n');buffer.append("[/ENDOBJECT]\n");return buffer.toString();}

[Assistant] public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append("[ENDOBJECT]\n");buffer.Append("    .rt         =").Append(HexDump.ShortToHex(rt)).Append('\n');buffer.Append("    .grbitFrt   =").Append(HexDump.ShortToHex(grbitFrt)).Append('\n');buffer.Append("    .iObjectKind=").Append(HexDump.ShortToHex(iObjectKind)).Append('\n');buffer.Append("    .unused     =").Append(HexDump.ToHex(reserved)).Append('\n');buffer.Append("[/ENDOBJECT]\n");return buffer.ToString();}


public static final RevFilter after(Date ts) {return after(ts.getTime());}

public static RevFilter After(DateTime ts){return After(ts.GetTime());}

[User] public static final RevFilter after(Date ts) {return after(ts.getTime());}

[Assistant] public static RevFilter After(DateTime ts){return After(ts.GetTime());}


public static Element getFirstChildElement(Element element) {for (Node kid = element.getFirstChild(); kid != null; kid = kid.getNextSibling()) {if (kid.getNodeType() == Node.ELEMENT_NODE) {return (Element) kid;}}return null;}

public static XmlElement GetFirstChildElement(XmlElement element){for (XmlNode kid = element.FirstChild; kid != null; kid = kid.NextSibling){if (kid.NodeType == XmlNodeType.Element){return (XmlElement)kid;}}return null;}

[User] public static Element getFirstChildElement(Element element) {for (Node kid = element.getFirstChild(); kid != null; kid = kid.getNextSibling()) {if (kid.getNodeType() == Node.ELEMENT_NODE) {return (Element) kid;}}return null;}

[Assistant] public static XmlElement GetFirstChildElement(XmlElement element){for (XmlNode kid = element.FirstChild; kid != null; kid = kid.NextSibling){if (kid.NodeType == XmlNodeType.Element){return (XmlElement)kid;}}return null;}


@Override public boolean add(E object) {synchronized (mutex) {return c.add(object);}}

public virtual bool add(E @object){lock (mutex){return c.add(@object);}}

[User] @Override public boolean add(E object) {synchronized (mutex) {return c.add(object);}}

[Assistant] public virtual bool add(E @object){lock (mutex){return c.add(@object);}}


public LongMap() {table = createArray(64);growAt = (int) (table.length * LOAD_FACTOR);}

public LongMap(){table = CreateArray<V>(64);growAt = (int)(table.Length * LOAD_FACTOR);}

[User] public LongMap() {table = createArray(64);growAt = (int) (table.length * LOAD_FACTOR);}

[Assistant] public LongMap(){table = CreateArray<V>(64);growAt = (int)(table.Length * LOAD_FACTOR);}


public ClaimGameServerResult claimGameServer(ClaimGameServerRequest request) {request = beforeClientExecution(request);return executeClaimGameServer(request);}

public virtual ClaimGameServerResponse ClaimGameServer(ClaimGameServerRequest request){var options = new InvokeOptions();options.RequestMarshaller = ClaimGameServerRequestMarshaller.Instance;options.ResponseUnmarshaller = ClaimGameServerResponseUnmarshaller.Instance;return Invoke<ClaimGameServerResponse>(request, options);}

[User] public ClaimGameServerResult claimGameServer(ClaimGameServerRequest request) {request = beforeClientExecution(request);return executeClaimGameServer(request);}

[Assistant] public virtual ClaimGameServerResponse ClaimGameServer(ClaimGameServerRequest request){var options = new InvokeOptions();options.RequestMarshaller = ClaimGameServerRequestMarshaller.Instance;options.ResponseUnmarshaller = ClaimGameServerResponseUnmarshaller.Instance;return Invoke<ClaimGameServerResponse>(request, options);}


public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval venumerator, ValueEval vedenominator) {double enumerator = 0;try {enumerator = OperandResolver.coerceValueToDouble(venumerator);} catch (EvaluationException e) {return ErrorEval.VALUE_INVALID;}double denominator = 0;try {denominator = OperandResolver.coerceValueToDouble(vedenominator);} catch (EvaluationException e) {return ErrorEval.VALUE_INVALID;}if (denominator == 0) {return ErrorEval.DIV_ZERO;}return new NumberEval((int)(enumerator / denominator));}

public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval venumerator, ValueEval vedenominator){double enumerator = 0;try{enumerator = OperandResolver.CoerceValueToDouble(venumerator);}catch (EvaluationException){return ErrorEval.VALUE_INVALID;}double denominator = 0;try{denominator = OperandResolver.CoerceValueToDouble(vedenominator);}catch (EvaluationException){return ErrorEval.VALUE_INVALID;}if (denominator == 0){return ErrorEval.DIV_ZERO;}return new NumberEval(((int)(enumerator / denominator)));}

[User] public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval venumerator, ValueEval vedenominator) {double enumerator = 0;try {enumerator = OperandResolver.coerceValueToDouble(venumerator);} catch (EvaluationException e) {return ErrorEval.VALUE_INVALID;}double denominator = 0;try {denominator = OperandResolver.coerceValueToDouble(vedenominator);} catch (EvaluationException e) {return ErrorEval.VALUE_INVALID;}if (denominator == 0) {return ErrorEval.DIV_ZERO;}return new NumberEval((int)(enumerator / denominator));}

[Assistant] public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval venumerator, ValueEval vedenominator){double enumerator = 0;try{enumerator = OperandResolver.CoerceValueToDouble(venumerator);}catch (EvaluationException){return ErrorEval.VALUE_INVALID;}double denominator = 0;try{denominator = OperandResolver.CoerceValueToDouble(vedenominator);}catch (EvaluationException){return ErrorEval.VALUE_INVALID;}if (denominator == 0){return ErrorEval.DIV_ZERO;}return new NumberEval(((int)(enumerator / denominator)));}


public synchronized V put(K key, V value) {if (value == null) {throw new NullPointerException();}int hash = secondaryHash(key.hashCode());HashtableEntry<K, V>[] tab = table;int index = hash & (tab.length - 1);HashtableEntry<K, V> first = tab[index];for (HashtableEntry<K, V> e = first; e != null; e = e.next) {if (e.hash == hash && key.equals(e.key)) {V oldValue = e.value;e.value = value;return oldValue;}}modCount++;if (size++ > threshold) {rehash();  tab = doubleCapacity();index = hash & (tab.length - 1);first = tab[index];}tab[index] = new HashtableEntry<K, V>(key, value, hash, first);return null;}

public override V put(K key, V value){lock (this){if ((object)value == null){throw new System.ArgumentNullException();}int hash = secondaryHash(key.GetHashCode());java.util.Hashtable.HashtableEntry<K, V>[] tab = table;int index = hash & (tab.Length - 1);java.util.Hashtable.HashtableEntry<K, V> first = tab[index];{for (java.util.Hashtable.HashtableEntry<K, V> e = first; e != null; e = e.next){if (e.hash == hash && key.Equals(e.key)){V oldValue = e.value;e.value = value;return oldValue;}}}modCount++;if (_size++ > threshold){rehash();tab = doubleCapacity();index = hash & (tab.Length - 1);first = tab[index];}tab[index] = new java.util.Hashtable.HashtableEntry<K, V>(key, value, hash, first);return default(V);}}

[User] public synchronized V put(K key, V value) {if (value == null) {throw new NullPointerException();}int hash = secondaryHash(key.hashCode());HashtableEntry<K, V>[] tab = table;int index = hash & (tab.length - 1);HashtableEntry<K, V> first = tab[index];for (HashtableEntry<K, V> e = first; e != null; e = e.next) {if (e.hash == hash && key.equals(e.key)) {V oldValue = e.value;e.value = value;return oldValue;}}modCount++;if (size++ > threshold) {rehash();  tab = doubleCapacity();index = hash & (tab.length - 1);first = tab[index];}tab[index] = new HashtableEntry<K, V>(key, value, hash, first);return null;}

[Assistant] public override V put(K key, V value){lock (this){if ((object)value == null){throw new System.ArgumentNullException();}int hash = secondaryHash(key.GetHashCode());java.util.Hashtable.HashtableEntry<K, V>[] tab = table;int index = hash & (tab.Length - 1);java.util.Hashtable.HashtableEntry<K, V> first = tab[index];{for (java.util.Hashtable.HashtableEntry<K, V> e = first; e != null; e = e.next){if (e.hash == hash && key.Equals(e.key)){V oldValue = e.value;e.value = value;return oldValue;}}}modCount++;if (_size++ > threshold){rehash();tab = doubleCapacity();index = hash & (tab.Length - 1);first = tab[index];}tab[index] = new java.util.Hashtable.HashtableEntry<K, V>(key, value, hash, first);return default(V);}}


public DescribeAutoScalingNotificationTypesResult describeAutoScalingNotificationTypes(DescribeAutoScalingNotificationTypesRequest request) {request = beforeClientExecution(request);return executeDescribeAutoScalingNotificationTypes(request);}

public virtual DescribeAutoScalingNotificationTypesResponse DescribeAutoScalingNotificationTypes(DescribeAutoScalingNotificationTypesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeAutoScalingNotificationTypesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeAutoScalingNotificationTypesResponseUnmarshaller.Instance;return Invoke<DescribeAutoScalingNotificationTypesResponse>(request, options);}

[User] public DescribeAutoScalingNotificationTypesResult describeAutoScalingNotificationTypes(DescribeAutoScalingNotificationTypesRequest request) {request = beforeClientExecution(request);return executeDescribeAutoScalingNotificationTypes(request);}

[Assistant] public virtual DescribeAutoScalingNotificationTypesResponse DescribeAutoScalingNotificationTypes(DescribeAutoScalingNotificationTypesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeAutoScalingNotificationTypesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeAutoScalingNotificationTypesResponseUnmarshaller.Instance;return Invoke<DescribeAutoScalingNotificationTypesResponse>(request, options);}


public ScandinavianFoldingFilterFactory(Map<String,String> args) {super(args);if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

public ScandinavianFoldingFilterFactory(IDictionary<string, string> args): base(args){if (args.Count > 0){throw new System.ArgumentException("Unknown parameters: " + args);}}

[User] public ScandinavianFoldingFilterFactory(Map<String,String> args) {super(args);if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

[Assistant] public ScandinavianFoldingFilterFactory(IDictionary<string, string> args): base(args){if (args.Count > 0){throw new System.ArgumentException("Unknown parameters: " + args);}}


public ContentHandler getContentHandler () {return (theContentHandler == this) ? null : theContentHandler;}

public void close (){lock (this.mBlock) {if (this.mParseState != null) {this.mParseState.Dispose ();this.mParseState = null;this.mBlock.decOpenCountLocked ();}}}

[User] public ContentHandler getContentHandler () {return (theContentHandler == this) ? null : theContentHandler;}

[Assistant] public void close (){lock (this.mBlock) {if (this.mParseState != null) {this.mParseState.Dispose ();this.mParseState = null;this.mBlock.decOpenCountLocked ();}}}


public override string ToString(){return "$";}

[User] public String toString() {return "$";}

[Assistant] public override string ToString(){return "$";}


public ListAssessmentRunsResult listAssessmentRuns(ListAssessmentRunsRequest request) {request = beforeClientExecution(request);return executeListAssessmentRuns(request);}

public virtual ListAssessmentRunsResponse ListAssessmentRuns(ListAssessmentRunsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListAssessmentRunsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListAssessmentRunsResponseUnmarshaller.Instance;return Invoke<ListAssessmentRunsResponse>(request, options);}

[User] public ListAssessmentRunsResult listAssessmentRuns(ListAssessmentRunsRequest request) {request = beforeClientExecution(request);return executeListAssessmentRuns(request);}

[Assistant] public virtual ListAssessmentRunsResponse ListAssessmentRuns(ListAssessmentRunsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListAssessmentRunsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListAssessmentRunsResponseUnmarshaller.Instance;return Invoke<ListAssessmentRunsResponse>(request, options);}


public ShortBuffer compact() {throw new ReadOnlyBufferException();}

public override java.nio.ShortBuffer compact(){throw new java.nio.ReadOnlyBufferException();}

[User] public ShortBuffer compact() {throw new ReadOnlyBufferException();}

[Assistant] public override java.nio.ShortBuffer compact(){throw new java.nio.ReadOnlyBufferException();}


public DeleteAssessmentRunResult deleteAssessmentRun(DeleteAssessmentRunRequest request) {request = beforeClientExecution(request);return executeDeleteAssessmentRun(request);}

public virtual DeleteAssessmentRunResponse DeleteAssessmentRun(DeleteAssessmentRunRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteAssessmentRunRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteAssessmentRunResponseUnmarshaller.Instance;return Invoke<DeleteAssessmentRunResponse>(request, options);}

[User] public DeleteAssessmentRunResult deleteAssessmentRun(DeleteAssessmentRunRequest request) {request = beforeClientExecution(request);return executeDeleteAssessmentRun(request);}

[Assistant] public virtual DeleteAssessmentRunResponse DeleteAssessmentRun(DeleteAssessmentRunRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteAssessmentRunRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteAssessmentRunResponseUnmarshaller.Instance;return Invoke<DeleteAssessmentRunResponse>(request, options);}


public GetAppsResult getApps(GetAppsRequest request) {request = beforeClientExecution(request);return executeGetApps(request);}

public virtual GetAppsResponse GetApps(GetAppsRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetAppsRequestMarshaller.Instance;options.ResponseUnmarshaller = GetAppsResponseUnmarshaller.Instance;return Invoke<GetAppsResponse>(request, options);}

[User] public GetAppsResult getApps(GetAppsRequest request) {request = beforeClientExecution(request);return executeGetApps(request);}

[Assistant] public virtual GetAppsResponse GetApps(GetAppsRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetAppsRequestMarshaller.Instance;options.ResponseUnmarshaller = GetAppsResponseUnmarshaller.Instance;return Invoke<GetAppsResponse>(request, options);}