public DetachInstancesFromLoadBalancerResult detachInstancesFromLoadBalancer(DetachInstancesFromLoadBalancerRequest request) {request = beforeClientExecution(request);return executeDetachInstancesFromLoadBalancer(request);}

public virtual DetachInstancesFromLoadBalancerResponse DetachInstancesFromLoadBalancer(DetachInstancesFromLoadBalancerRequest request){var options = new InvokeOptions();options.RequestMarshaller = DetachInstancesFromLoadBalancerRequestMarshaller.Instance;options.ResponseUnmarshaller = DetachInstancesFromLoadBalancerResponseUnmarshaller.Instance;return Invoke<DetachInstancesFromLoadBalancerResponse>(request, options);}

[User] public DetachInstancesFromLoadBalancerResult detachInstancesFromLoadBalancer(DetachInstancesFromLoadBalancerRequest request) {request = beforeClientExecution(request);return executeDetachInstancesFromLoadBalancer(request);}

[Assistant] public virtual DetachInstancesFromLoadBalancerResponse DetachInstancesFromLoadBalancer(DetachInstancesFromLoadBalancerRequest request){var options = new InvokeOptions();options.RequestMarshaller = DetachInstancesFromLoadBalancerRequestMarshaller.Instance;options.ResponseUnmarshaller = DetachInstancesFromLoadBalancerResponseUnmarshaller.Instance;return Invoke<DetachInstancesFromLoadBalancerResponse>(request, options);}


public int getSourceStart() {return outRegion.sourceStart;}

public virtual int GetSourceStart(){return currentSource.regionList.sourceStart;}

[User] public int getSourceStart() {return outRegion.sourceStart;}

[Assistant] public virtual int GetSourceStart(){return currentSource.regionList.sourceStart;}


public String toString() {StringBuilder buffer = new StringBuilder();buffer.append("[FORMAT]\n");buffer.append("    .indexcode       = ").append(HexDump.shortToHex(getIndexCode())).append("\n");buffer.append("    .isUnicode       = ").append(field_3_hasMultibyte ).append("\n");buffer.append("    .formatstring    = ").append(getFormatString()).append("\n");buffer.append("[/FORMAT]\n");return buffer.toString();}

public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append("[FORMAT]\n");buffer.Append("    .indexcode       = ").Append(HexDump.ShortToHex(IndexCode)).Append("\n");buffer.Append("    .isUnicode       = ").Append(field_3_hasMultibyte).Append("\n");buffer.Append("    .formatstring    = ").Append(FormatString).Append("\n");buffer.Append("[/FORMAT]\n");return buffer.ToString();}

[User] public String toString() {StringBuilder buffer = new StringBuilder();buffer.append("[FORMAT]\n");buffer.append("    .indexcode       = ").append(HexDump.shortToHex(getIndexCode())).append("\n");buffer.append("    .isUnicode       = ").append(field_3_hasMultibyte ).append("\n");buffer.append("    .formatstring    = ").append(getFormatString()).append("\n");buffer.append("[/FORMAT]\n");return buffer.toString();}

[Assistant] public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append("[FORMAT]\n");buffer.Append("    .indexcode       = ").Append(HexDump.ShortToHex(IndexCode)).Append("\n");buffer.Append("    .isUnicode       = ").Append(field_3_hasMultibyte).Append("\n");buffer.Append("    .formatstring    = ").Append(FormatString).Append("\n");buffer.Append("[/FORMAT]\n");return buffer.ToString();}


public void remove() {if (lastReturned == null) {throw new IllegalStateException();}Impl.this.remove(lastReturned.getKey());lastReturned = null;}

public virtual void remove(){if (this.lastEntryReturned == null){throw new System.InvalidOperationException();}if (this._enclosing.modCount != this.expectedModCount){throw new java.util.ConcurrentModificationException();}this._enclosing.remove(this.lastEntryReturned.key);this.lastEntryReturned = null;this.expectedModCount = this._enclosing.modCount;}

[User] public void remove() {if (lastReturned == null) {throw new IllegalStateException();}Impl.this.remove(lastReturned.getKey());lastReturned = null;}

[Assistant] public virtual void remove(){if (this.lastEntryReturned == null){throw new System.InvalidOperationException();}if (this._enclosing.modCount != this.expectedModCount){throw new java.util.ConcurrentModificationException();}this._enclosing.remove(this.lastEntryReturned.key);this.lastEntryReturned = null;this.expectedModCount = this._enclosing.modCount;}


public String toString() {if (getChildren() == null || getChildren().size() == 0)return "<boolean operation='or'/>";StringBuilder sb = new StringBuilder();sb.append("<boolean operation='or'>");for (QueryNode child : getChildren()) {sb.append("\n");sb.append(child.toString());}sb.append("\n</boolean>");return sb.toString();}

public override string ToString(){var children = GetChildren();if (children == null || children.Count == 0)return "<boolean operation='or'/>";StringBuilder sb = new StringBuilder();sb.Append("<boolean operation='or'>");foreach (IQueryNode child in children){sb.Append("\n");sb.Append(child.ToString());}sb.Append("\n</boolean>");return sb.ToString();}

[User] public String toString() {if (getChildren() == null || getChildren().size() == 0)return "<boolean operation='or'/>";StringBuilder sb = new StringBuilder();sb.append("<boolean operation='or'>");for (QueryNode child : getChildren()) {sb.append("\n");sb.append(child.toString());}sb.append("\n</boolean>");return sb.toString();}

[Assistant] public override string ToString(){var children = GetChildren();if (children == null || children.Count == 0)return "<boolean operation='or'/>";StringBuilder sb = new StringBuilder();sb.Append("<boolean operation='or'>");foreach (IQueryNode child in children){sb.Append("\n");sb.Append(child.ToString());}sb.Append("\n</boolean>");return sb.ToString();}


public String getPartOfSpeech(int wordId) {return getFeature(wordId, 1);}

public string GetPartOfSpeech(int wordId){return GetFeature(wordId, 1);}

[User] public String getPartOfSpeech(int wordId) {return getFeature(wordId, 1);}

[Assistant] public string GetPartOfSpeech(int wordId){return GetFeature(wordId, 1);}


public BatchWriteResult batchWrite(BatchWriteRequest request) {request = beforeClientExecution(request);return executeBatchWrite(request);}

public virtual BatchWriteResponse BatchWrite(BatchWriteRequest request){var options = new InvokeOptions();options.RequestMarshaller = BatchWriteRequestMarshaller.Instance;options.ResponseUnmarshaller = BatchWriteResponseUnmarshaller.Instance;return Invoke<BatchWriteResponse>(request, options);}

[User] public BatchWriteResult batchWrite(BatchWriteRequest request) {request = beforeClientExecution(request);return executeBatchWrite(request);}

[Assistant] public virtual BatchWriteResponse BatchWrite(BatchWriteRequest request){var options = new InvokeOptions();options.RequestMarshaller = BatchWriteRequestMarshaller.Instance;options.ResponseUnmarshaller = BatchWriteResponseUnmarshaller.Instance;return Invoke<BatchWriteResponse>(request, options);}


public ObjectId idFor(int type, byte[] data) {return delegate().idFor(type, data);}

public virtual ObjectId IdFor(int type, byte[] data){return IdFor(type, data, 0, data.Length);}

[User] public ObjectId idFor(int type, byte[] data) {return delegate().idFor(type, data);}

[Assistant] public virtual ObjectId IdFor(int type, byte[] data){return IdFor(type, data, 0, data.Length);}


public ConfirmTransitVirtualInterfaceResult confirmTransitVirtualInterface(ConfirmTransitVirtualInterfaceRequest request) {request = beforeClientExecution(request);return executeConfirmTransitVirtualInterface(request);}

public virtual ConfirmTransitVirtualInterfaceResponse ConfirmTransitVirtualInterface(ConfirmTransitVirtualInterfaceRequest request){var options = new InvokeOptions();options.RequestMarshaller = ConfirmTransitVirtualInterfaceRequestMarshaller.Instance;options.ResponseUnmarshaller = ConfirmTransitVirtualInterfaceResponseUnmarshaller.Instance;return Invoke<ConfirmTransitVirtualInterfaceResponse>(request, options);}

[User] public ConfirmTransitVirtualInterfaceResult confirmTransitVirtualInterface(ConfirmTransitVirtualInterfaceRequest request) {request = beforeClientExecution(request);return executeConfirmTransitVirtualInterface(request);}

[Assistant] public virtual ConfirmTransitVirtualInterfaceResponse ConfirmTransitVirtualInterface(ConfirmTransitVirtualInterfaceRequest request){var options = new InvokeOptions();options.RequestMarshaller = ConfirmTransitVirtualInterfaceRequestMarshaller.Instance;options.ResponseUnmarshaller = ConfirmTransitVirtualInterfaceResponseUnmarshaller.Instance;return Invoke<ConfirmTransitVirtualInterfaceResponse>(request, options);}


public GetFileUploadURLResult getFileUploadURL(GetFileUploadURLRequest request) {request = beforeClientExecution(request);return executeGetFileUploadURL(request);}

public virtual GetFileUploadURLResponse GetFileUploadURL(GetFileUploadURLRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetFileUploadURLRequestMarshaller.Instance;options.ResponseUnmarshaller = GetFileUploadURLResponseUnmarshaller.Instance;return Invoke<GetFileUploadURLResponse>(request, options);}

[User] public GetFileUploadURLResult getFileUploadURL(GetFileUploadURLRequest request) {request = beforeClientExecution(request);return executeGetFileUploadURL(request);}

[Assistant] public virtual GetFileUploadURLResponse GetFileUploadURL(GetFileUploadURLRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetFileUploadURLRequestMarshaller.Instance;options.ResponseUnmarshaller = GetFileUploadURLResponseUnmarshaller.Instance;return Invoke<GetFileUploadURLResponse>(request, options);}


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

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

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

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


public StartWorkspacesResult startWorkspaces(StartWorkspacesRequest request) {request = beforeClientExecution(request);return executeStartWorkspaces(request);}

public virtual StartWorkspacesResponse StartWorkspaces(StartWorkspacesRequest request){var options = new InvokeOptions();options.RequestMarshaller = StartWorkspacesRequestMarshaller.Instance;options.ResponseUnmarshaller = StartWorkspacesResponseUnmarshaller.Instance;return Invoke<StartWorkspacesResponse>(request, options);}

[User] public StartWorkspacesResult startWorkspaces(StartWorkspacesRequest request) {request = beforeClientExecution(request);return executeStartWorkspaces(request);}

[Assistant] public virtual StartWorkspacesResponse StartWorkspaces(StartWorkspacesRequest request){var options = new InvokeOptions();options.RequestMarshaller = StartWorkspacesRequestMarshaller.Instance;options.ResponseUnmarshaller = StartWorkspacesResponseUnmarshaller.Instance;return Invoke<StartWorkspacesResponse>(request, options);}


public int getDeltaCacheLimit() {return deltaCacheLimit;}

public virtual int GetDeltaCacheLimit(){return deltaCacheLimit;}

[User] public int getDeltaCacheLimit() {return deltaCacheLimit;}

[Assistant] public virtual int GetDeltaCacheLimit(){return deltaCacheLimit;}


public RebootJumpserverRequest() {super("HPC", "2016-06-03", "RebootJumpserver", "hpc");setMethod(MethodType.POST);}

public RebootJumpserverRequest(): base("HPC", "2016-06-03", "RebootJumpserver"){Method = MethodType.POST;}

[User] public RebootJumpserverRequest() {super("HPC", "2016-06-03", "RebootJumpserver", "hpc");setMethod(MethodType.POST);}

[Assistant] public RebootJumpserverRequest(): base("HPC", "2016-06-03", "RebootJumpserver"){Method = MethodType.POST;}


public int getResultEnd() {Region r = outRegion;return r.resultStart + r.length;}

public virtual int GetResultEnd(){Region r = currentSource.regionList;return r.resultStart + r.length;}

[User] public int getResultEnd() {Region r = outRegion;return r.resultStart + r.length;}

[Assistant] public virtual int GetResultEnd(){Region r = currentSource.regionList;return r.resultStart + r.length;}


public CreateLagResult createLag(CreateLagRequest request) {request = beforeClientExecution(request);return executeCreateLag(request);}

public virtual CreateLagResponse CreateLag(CreateLagRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateLagRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateLagResponseUnmarshaller.Instance;return Invoke<CreateLagResponse>(request, options);}

[User] public CreateLagResult createLag(CreateLagRequest request) {request = beforeClientExecution(request);return executeCreateLag(request);}

[Assistant] public virtual CreateLagResponse CreateLag(CreateLagRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateLagRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateLagResponseUnmarshaller.Instance;return Invoke<CreateLagResponse>(request, options);}


public ConflictState getConflictState() {return conflictState;}

public virtual MergeChunk.ConflictState GetConflictState(){return conflictState;}

[User] public ConflictState getConflictState() {return conflictState;}

[Assistant] public virtual MergeChunk.ConflictState GetConflictState(){return conflictState;}


public final void writeByte(int val) throws IOException {write(val & 0xFF);}

public virtual void writeByte(int val){throw new System.NotImplementedException();}

[User] public final void writeByte(int val) throws IOException {write(val & 0xFF);}

[Assistant] public virtual void writeByte(int val){throw new System.NotImplementedException();}


public UpdateRelationalDatabaseResult updateRelationalDatabase(UpdateRelationalDatabaseRequest request) {request = beforeClientExecution(request);return executeUpdateRelationalDatabase(request);}

public virtual UpdateRelationalDatabaseResponse UpdateRelationalDatabase(UpdateRelationalDatabaseRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateRelationalDatabaseRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateRelationalDatabaseResponseUnmarshaller.Instance;return Invoke<UpdateRelationalDatabaseResponse>(request, options);}

[User] public UpdateRelationalDatabaseResult updateRelationalDatabase(UpdateRelationalDatabaseRequest request) {request = beforeClientExecution(request);return executeUpdateRelationalDatabase(request);}

[Assistant] public virtual UpdateRelationalDatabaseResponse UpdateRelationalDatabase(UpdateRelationalDatabaseRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateRelationalDatabaseRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateRelationalDatabaseResponseUnmarshaller.Instance;return Invoke<UpdateRelationalDatabaseResponse>(request, options);}


public Entry<K, V> lowerEntry(K key) {return immutableCopy(findBounded(key, LOWER));}

public java.util.MapClass.Entry<K, V> lowerEntry(K key){return this._enclosing.immutableCopy(this.findBounded(key, java.util.TreeMap.Relation.LOWER));}

[User] public Entry<K, V> lowerEntry(K key) {return immutableCopy(findBounded(key, LOWER));}

[Assistant] public java.util.MapClass.Entry<K, V> lowerEntry(K key){return this._enclosing.immutableCopy(this.findBounded(key, java.util.TreeMap.Relation.LOWER));}


public ExternalNameRecord() {field_2_ixals = 0;}

public ExternalNameRecord(){field_2_ixals = 0;}

[User] public ExternalNameRecord() {field_2_ixals = 0;}

[Assistant] public ExternalNameRecord(){field_2_ixals = 0;}


public int stem(char s[], int len) {len = stemPrefix(s, len);len = stemSuffix(s, len);return len;}

public virtual int Stem(char[] s, int len){len = StemPrefix(s, len);len = StemSuffix(s, len);return len;}

[User] public int stem(char s[], int len) {len = stemPrefix(s, len);len = stemSuffix(s, len);return len;}

[Assistant] public virtual int Stem(char[] s, int len){len = StemPrefix(s, len);len = StemSuffix(s, len);return len;}


public final void remove(RevFlagSet set) {flags &= ~set.mask;}

public void Remove(RevFlag flag){flags &= ~flag.mask;}

[User] public final void remove(RevFlagSet set) {flags &= ~set.mask;}

[Assistant] public void Remove(RevFlag flag){flags &= ~flag.mask;}


public IllegalFormatFlagsException(String flags) {if (flags == null) {throw new NullPointerException();}this.flags = flags;}

public IllegalFormatFlagsException(string flags){if (flags == null){throw new System.ArgumentNullException();}this.flags = flags;}

[User] public IllegalFormatFlagsException(String flags) {if (flags == null) {throw new NullPointerException();}this.flags = flags;}

[Assistant] public IllegalFormatFlagsException(string flags){if (flags == null){throw new System.ArgumentNullException();}this.flags = flags;}


public boolean shouldBeRecursive() {return false;}

public override bool ShouldBeRecursive(){return false;}

[User] public boolean shouldBeRecursive() {return false;}

[Assistant] public override bool ShouldBeRecursive(){return false;}


public CapitalizationFilter create(TokenStream input) {return new CapitalizationFilter(input, onlyFirstWord, keep,forceFirstLetter, okPrefix, minWordLength, maxWordCount, maxTokenLength);}

public override TokenStream Create(TokenStream input){return new CapitalizationFilter(input, onlyFirstWord, keep, forceFirstLetter, okPrefix, minWordLength, maxWordCount, maxTokenLength, culture);}

[User] public CapitalizationFilter create(TokenStream input) {return new CapitalizationFilter(input, onlyFirstWord, keep,forceFirstLetter, okPrefix, minWordLength, maxWordCount, maxTokenLength);}

[Assistant] public override TokenStream Create(TokenStream input){return new CapitalizationFilter(input, onlyFirstWord, keep, forceFirstLetter, okPrefix, minWordLength, maxWordCount, maxTokenLength, culture);}


public GetAppliedSchemaVersionResult getAppliedSchemaVersion(GetAppliedSchemaVersionRequest request) {request = beforeClientExecution(request);return executeGetAppliedSchemaVersion(request);}

public virtual GetAppliedSchemaVersionResponse GetAppliedSchemaVersion(GetAppliedSchemaVersionRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetAppliedSchemaVersionRequestMarshaller.Instance;options.ResponseUnmarshaller = GetAppliedSchemaVersionResponseUnmarshaller.Instance;return Invoke<GetAppliedSchemaVersionResponse>(request, options);}

[User] public GetAppliedSchemaVersionResult getAppliedSchemaVersion(GetAppliedSchemaVersionRequest request) {request = beforeClientExecution(request);return executeGetAppliedSchemaVersion(request);}

[Assistant] public virtual GetAppliedSchemaVersionResponse GetAppliedSchemaVersion(GetAppliedSchemaVersionRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetAppliedSchemaVersionRequestMarshaller.Instance;options.ResponseUnmarshaller = GetAppliedSchemaVersionResponseUnmarshaller.Instance;return Invoke<GetAppliedSchemaVersionResponse>(request, options);}


public DescribeLabelingJobResult describeLabelingJob(DescribeLabelingJobRequest request) {request = beforeClientExecution(request);return executeDescribeLabelingJob(request);}

public virtual DescribeLabelingJobResponse DescribeLabelingJob(DescribeLabelingJobRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeLabelingJobRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeLabelingJobResponseUnmarshaller.Instance;return Invoke<DescribeLabelingJobResponse>(request, options);}

[User] public DescribeLabelingJobResult describeLabelingJob(DescribeLabelingJobRequest request) {request = beforeClientExecution(request);return executeDescribeLabelingJob(request);}

[Assistant] public virtual DescribeLabelingJobResponse DescribeLabelingJob(DescribeLabelingJobRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeLabelingJobRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeLabelingJobResponseUnmarshaller.Instance;return Invoke<DescribeLabelingJobResponse>(request, options);}


public DeleteAttendeeResult deleteAttendee(DeleteAttendeeRequest request) {request = beforeClientExecution(request);return executeDeleteAttendee(request);}

public virtual DeleteAttendeeResponse DeleteAttendee(DeleteAttendeeRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteAttendeeRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteAttendeeResponseUnmarshaller.Instance;return Invoke<DeleteAttendeeResponse>(request, options);}

[User] public DeleteAttendeeResult deleteAttendee(DeleteAttendeeRequest request) {request = beforeClientExecution(request);return executeDeleteAttendee(request);}

[Assistant] public virtual DeleteAttendeeResponse DeleteAttendee(DeleteAttendeeRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteAttendeeRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteAttendeeResponseUnmarshaller.Instance;return Invoke<DeleteAttendeeResponse>(request, options);}


public final String toString(List<String> ruleNames) {return toString(ruleNames, null);}

public string ToString(IList<string> ruleNames){return ToString(ruleNames, null);}

[User] public final String toString(List<String> ruleNames) {return toString(ruleNames, null);}

[Assistant] public string ToString(IList<string> ruleNames){return ToString(ruleNames, null);}


public RejectAssignmentResult rejectAssignment(RejectAssignmentRequest request) {request = beforeClientExecution(request);return executeRejectAssignment(request);}

public virtual RejectAssignmentResponse RejectAssignment(RejectAssignmentRequest request){var options = new InvokeOptions();options.RequestMarshaller = RejectAssignmentRequestMarshaller.Instance;options.ResponseUnmarshaller = RejectAssignmentResponseUnmarshaller.Instance;return Invoke<RejectAssignmentResponse>(request, options);}

[User] public RejectAssignmentResult rejectAssignment(RejectAssignmentRequest request) {request = beforeClientExecution(request);return executeRejectAssignment(request);}

[Assistant] public virtual RejectAssignmentResponse RejectAssignment(RejectAssignmentRequest request){var options = new InvokeOptions();options.RequestMarshaller = RejectAssignmentRequestMarshaller.Instance;options.ResponseUnmarshaller = RejectAssignmentResponseUnmarshaller.Instance;return Invoke<RejectAssignmentResponse>(request, options);}


public CharVector(char[] a, int capacity) {if (capacity > 0) {blockSize = capacity;} else {blockSize = DEFAULT_BLOCK_SIZE;}array = a;n = a.length;}

public CharVector(char[] a, int capacity){if (capacity > 0){blockSize = capacity;}else{blockSize = DEFAULT_BLOCK_SIZE;}array = a;n = a.Length;}

[User] public CharVector(char[] a, int capacity) {if (capacity > 0) {blockSize = capacity;} else {blockSize = DEFAULT_BLOCK_SIZE;}array = a;n = a.length;}

[Assistant] public CharVector(char[] a, int capacity){if (capacity > 0){blockSize = capacity;}else{blockSize = DEFAULT_BLOCK_SIZE;}array = a;n = a.Length;}


public UnsubscribeFromEventResult unsubscribeFromEvent(UnsubscribeFromEventRequest request) {request = beforeClientExecution(request);return executeUnsubscribeFromEvent(request);}

public virtual UnsubscribeFromEventResponse UnsubscribeFromEvent(UnsubscribeFromEventRequest request){var options = new InvokeOptions();options.RequestMarshaller = UnsubscribeFromEventRequestMarshaller.Instance;options.ResponseUnmarshaller = UnsubscribeFromEventResponseUnmarshaller.Instance;return Invoke<UnsubscribeFromEventResponse>(request, options);}

[User] public UnsubscribeFromEventResult unsubscribeFromEvent(UnsubscribeFromEventRequest request) {request = beforeClientExecution(request);return executeUnsubscribeFromEvent(request);}

[Assistant] public virtual UnsubscribeFromEventResponse UnsubscribeFromEvent(UnsubscribeFromEventRequest request){var options = new InvokeOptions();options.RequestMarshaller = UnsubscribeFromEventRequestMarshaller.Instance;options.ResponseUnmarshaller = UnsubscribeFromEventResponseUnmarshaller.Instance;return Invoke<UnsubscribeFromEventResponse>(request, options);}


public String getNextToken() {if( pos >= format.length() ) {return null;}int subStart = pos;final char curChar = format.charAt(pos);++pos;if( curChar == '\'' ) {while( ( pos < format.length() ) && ( format.charAt(pos) != '\'' ) ) {++pos;}if( pos < format.length() ) {++pos;}} else {while( ( pos < format.length() ) && ( format.charAt(pos) == curChar ) ) {++pos;}}return format.substring(subStart,pos);}

public string GetNextToken(){if (pos >= format.Length){return null;}int subStart = pos;char curChar = format[pos];++pos;if (curChar == '\''){while ((pos < format.Length) && ((curChar = format[pos]) != '\'')){++pos;}if (pos < format.Length){++pos;}}else{char activeChar = curChar;while ((pos < format.Length) && ((curChar = format[pos])) == activeChar){++pos;}}return format.Substring(subStart, pos - subStart);}

[User] public String getNextToken() {if( pos >= format.length() ) {return null;}int subStart = pos;final char curChar = format.charAt(pos);++pos;if( curChar == '\'' ) {while( ( pos < format.length() ) && ( format.charAt(pos) != '\'' ) ) {++pos;}if( pos < format.length() ) {++pos;}} else {while( ( pos < format.length() ) && ( format.charAt(pos) == curChar ) ) {++pos;}}return format.substring(subStart,pos);}

[Assistant] public string GetNextToken(){if (pos >= format.Length){return null;}int subStart = pos;char curChar = format[pos];++pos;if (curChar == '\''){while ((pos < format.Length) && ((curChar = format[pos]) != '\'')){++pos;}if (pos < format.Length){++pos;}}else{char activeChar = curChar;while ((pos < format.Length) && ((curChar = format[pos])) == activeChar){++pos;}}return format.Substring(subStart, pos - subStart);}


public Policy withId(String id) {setId(id);return this;}

public Policy WithId(string id){Id = id;return this;}

[User] public Policy withId(String id) {setId(id);return this;}

[Assistant] public Policy WithId(string id){Id = id;return this;}


public void setStringValue(String value) {if (!(fieldsData instanceof String)) {throw new IllegalArgumentException("cannot change value type from " + fieldsData.getClass().getSimpleName() + " to String");}if (value == null) {throw new IllegalArgumentException("value must not be null");}fieldsData = value;}

public virtual void SetStringValue(string value){if (!(FieldsData is string)){throw new ArgumentException("cannot change value type from " + FieldsData.GetType().Name + " to string");}FieldsData = value;}

[User] public void setStringValue(String value) {if (!(fieldsData instanceof String)) {throw new IllegalArgumentException("cannot change value type from " + fieldsData.getClass().getSimpleName() + " to String");}if (value == null) {throw new IllegalArgumentException("value must not be null");}fieldsData = value;}

[Assistant] public virtual void SetStringValue(string value){if (!(FieldsData is string)){throw new ArgumentException("cannot change value type from " + FieldsData.GetType().Name + " to string");}FieldsData = value;}


public Area3DPtg(String arearef, int externIdx) {super(new AreaReference(arearef, SpreadsheetVersion.EXCEL97));setExternSheetIndex(externIdx);}

public Area3DPtg(String arearef, int externIdx):base(arearef){ExternSheetIndex=externIdx;}

[User] public Area3DPtg(String arearef, int externIdx) {super(new AreaReference(arearef, SpreadsheetVersion.EXCEL97));setExternSheetIndex(externIdx);}

[Assistant] public Area3DPtg(String arearef, int externIdx):base(arearef){ExternSheetIndex=externIdx;}


public boolean empty() {return isEmpty();}

public virtual bool empty(){return isEmpty();}

[User] public boolean empty() {return isEmpty();}

[Assistant] public virtual bool empty(){return isEmpty();}


public DeleteMemberResult deleteMember(DeleteMemberRequest request) {request = beforeClientExecution(request);return executeDeleteMember(request);}

public virtual DeleteMemberResponse DeleteMember(DeleteMemberRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteMemberRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteMemberResponseUnmarshaller.Instance;return Invoke<DeleteMemberResponse>(request, options);}

[User] public DeleteMemberResult deleteMember(DeleteMemberRequest request) {request = beforeClientExecution(request);return executeDeleteMember(request);}

[Assistant] public virtual DeleteMemberResponse DeleteMember(DeleteMemberRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteMemberRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteMemberResponseUnmarshaller.Instance;return Invoke<DeleteMemberResponse>(request, options);}


public DeleteRepositoryResult deleteRepository(DeleteRepositoryRequest request) {request = beforeClientExecution(request);return executeDeleteRepository(request);}

public virtual DeleteRepositoryResponse DeleteRepository(DeleteRepositoryRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteRepositoryRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteRepositoryResponseUnmarshaller.Instance;return Invoke<DeleteRepositoryResponse>(request, options);}

[User] public DeleteRepositoryResult deleteRepository(DeleteRepositoryRequest request) {request = beforeClientExecution(request);return executeDeleteRepository(request);}

[Assistant] public virtual DeleteRepositoryResponse DeleteRepository(DeleteRepositoryRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteRepositoryRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteRepositoryResponseUnmarshaller.Instance;return Invoke<DeleteRepositoryResponse>(request, options);}


public GetChangeResult getChange(GetChangeRequest request) {request = beforeClientExecution(request);return executeGetChange(request);}

public virtual GetChangeResponse GetChange(GetChangeRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetChangeRequestMarshaller.Instance;options.ResponseUnmarshaller = GetChangeResponseUnmarshaller.Instance;return Invoke<GetChangeResponse>(request, options);}

[User] public GetChangeResult getChange(GetChangeRequest request) {request = beforeClientExecution(request);return executeGetChange(request);}

[Assistant] public virtual GetChangeResponse GetChange(GetChangeRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetChangeRequestMarshaller.Instance;options.ResponseUnmarshaller = GetChangeResponseUnmarshaller.Instance;return Invoke<GetChangeResponse>(request, options);}


public PrefixCodedTerms finish() {return new PrefixCodedTerms(output.toBufferList(), size);}

public FieldInfos Finish(){return new FieldInfos(byName.Values.ToArray());}

[User] public PrefixCodedTerms finish() {return new PrefixCodedTerms(output.toBufferList(), size);}

[Assistant] public FieldInfos Finish(){return new FieldInfos(byName.Values.ToArray());}


@Override public synchronized void clear() {elements = EmptyArray.OBJECT;}

public virtual void clear(){lock (this){elements = libcore.util.EmptyArray.OBJECT;}}

[User] @Override public synchronized void clear() {elements = EmptyArray.OBJECT;}

[Assistant] public virtual void clear(){lock (this){elements = libcore.util.EmptyArray.OBJECT;}}


public LongBuffer duplicate() {ByteBuffer bb = byteBuffer.duplicate().order(byteBuffer.order());LongToByteBufferAdapter buf = new LongToByteBufferAdapter(bb);buf.limit = limit;buf.position = position;buf.mark = mark;return buf;}

public override java.nio.LongBuffer duplicate(){java.nio.ByteBuffer bb = byteBuffer.duplicate().order(byteBuffer.order());java.nio.LongToByteBufferAdapter buf = new java.nio.LongToByteBufferAdapter(bb);buf._limit = _limit;buf._position = _position;buf._mark = _mark;return buf;}

[User] public LongBuffer duplicate() {ByteBuffer bb = byteBuffer.duplicate().order(byteBuffer.order());LongToByteBufferAdapter buf = new LongToByteBufferAdapter(bb);buf.limit = limit;buf.position = position;buf.mark = mark;return buf;}

[Assistant] public override java.nio.LongBuffer duplicate(){java.nio.ByteBuffer bb = byteBuffer.duplicate().order(byteBuffer.order());java.nio.LongToByteBufferAdapter buf = new java.nio.LongToByteBufferAdapter(bb);buf._limit = _limit;buf._position = _position;buf._mark = _mark;return buf;}


public StyleRecord() {field_1_xf_index = isBuiltinFlag.set(0);}

public StyleRecord(){field_1_xf_index = isBuiltinFlag.Set(field_1_xf_index);}

[User] public StyleRecord() {field_1_xf_index = isBuiltinFlag.set(0);}

[Assistant] public StyleRecord(){field_1_xf_index = isBuiltinFlag.Set(field_1_xf_index);}


public boolean equals(Object o) {if (o instanceof AbbreviatedObjectId) {final AbbreviatedObjectId b = (AbbreviatedObjectId) o;return nibbles == b.nibbles && w1 == b.w1 && w2 == b.w2&& w3 == b.w3 && w4 == b.w4 && w5 == b.w5;}return false;}

public override bool Equals(object o){if (o is NGit.AbbreviatedObjectId){NGit.AbbreviatedObjectId b = (NGit.AbbreviatedObjectId)o;return nibbles == b.nibbles && w1 == b.w1 && w2 == b.w2 && w3 == b.w3 && w4 == b.w4 && w5 == b.w5;}return false;}

[User] public boolean equals(Object o) {if (o instanceof AbbreviatedObjectId) {final AbbreviatedObjectId b = (AbbreviatedObjectId) o;return nibbles == b.nibbles && w1 == b.w1 && w2 == b.w2&& w3 == b.w3 && w4 == b.w4 && w5 == b.w5;}return false;}

[Assistant] public override bool Equals(object o){if (o is NGit.AbbreviatedObjectId){NGit.AbbreviatedObjectId b = (NGit.AbbreviatedObjectId)o;return nibbles == b.nibbles && w1 == b.w1 && w2 == b.w2 && w3 == b.w3 && w4 == b.w4 && w5 == b.w5;}return false;}


public void ReInit(QueryParserTokenManager tm) {token_source = tm;token = new Token();jj_ntk = -1;jj_gen = 0;for (int i = 0; i < 10; i++) jj_la1[i] = -1;for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();}

public virtual void ReInit(QueryParserTokenManager tm){TokenSource = tm;Token = new Token();jj_ntk = -1;jj_gen = 0;for (int i = 0; i < 10; i++) jj_la1[i] = -1;for (int i = 0; i < jj_2_rtns.Length; i++) jj_2_rtns[i] = new JJCalls();}

[User] public void ReInit(QueryParserTokenManager tm) {token_source = tm;token = new Token();jj_ntk = -1;jj_gen = 0;for (int i = 0; i < 10; i++) jj_la1[i] = -1;for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();}

[Assistant] public virtual void ReInit(QueryParserTokenManager tm){TokenSource = tm;Token = new Token();jj_ntk = -1;jj_gen = 0;for (int i = 0; i < 10; i++) jj_la1[i] = -1;for (int i = 0; i < jj_2_rtns.Length; i++) jj_2_rtns[i] = new JJCalls();}


public ExtendedFormatRecord getExFormatAt(int index) {int xfptr = records.getXfpos() - (numxfs - 1);xfptr += index;return ( ExtendedFormatRecord ) records.get(xfptr);}

public ExtendedFormatRecord GetExFormatAt(int index){int xfptr = records.Xfpos - (numxfs - 1);xfptr += index;ExtendedFormatRecord retval =(ExtendedFormatRecord)records[xfptr];return retval;}

[User] public ExtendedFormatRecord getExFormatAt(int index) {int xfptr = records.getXfpos() - (numxfs - 1);xfptr += index;return ( ExtendedFormatRecord ) records.get(xfptr);}

[Assistant] public ExtendedFormatRecord GetExFormatAt(int index){int xfptr = records.Xfpos - (numxfs - 1);xfptr += index;ExtendedFormatRecord retval =(ExtendedFormatRecord)records[xfptr];return retval;}


public Resource(String resource) {this.resource = resource;}

public Resource(string resource){this.resource = resource;}

[User] public Resource(String resource) {this.resource = resource;}

[Assistant] public Resource(string resource){this.resource = resource;}


public NorwegianLightStemFilterFactory(Map<String,String> args) {super(args);String variant = get(args, "variant");if (variant == null || "nb".equals(variant)) {flags = BOKMAAL;} else if ("nn".equals(variant)) {flags = NYNORSK;} else if ("no".equals(variant)) {flags = BOKMAAL | NYNORSK;} else {throw new IllegalArgumentException("invalid variant: " + variant);}if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

public NorwegianLightStemFilterFactory(IDictionary<string, string> args): base(args){string variant = Get(args, "variant");if (variant == null || "nb".Equals(variant, StringComparison.Ordinal)){flags = NorwegianStandard.BOKMAAL;}else if ("nn".Equals(variant, StringComparison.Ordinal)){flags = NorwegianStandard.NYNORSK;}else if ("no".Equals(variant, StringComparison.Ordinal)){flags = NorwegianStandard.BOKMAAL | NorwegianStandard.NYNORSK;}else{throw new System.ArgumentException("invalid variant: " + variant);}if (args.Count > 0){throw new System.ArgumentException("Unknown parameters: " + args);}}

[User] public NorwegianLightStemFilterFactory(Map<String,String> args) {super(args);String variant = get(args, "variant");if (variant == null || "nb".equals(variant)) {flags = BOKMAAL;} else if ("nn".equals(variant)) {flags = NYNORSK;} else if ("no".equals(variant)) {flags = BOKMAAL | NYNORSK;} else {throw new IllegalArgumentException("invalid variant: " + variant);}if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

[Assistant] public NorwegianLightStemFilterFactory(IDictionary<string, string> args): base(args){string variant = Get(args, "variant");if (variant == null || "nb".Equals(variant, StringComparison.Ordinal)){flags = NorwegianStandard.BOKMAAL;}else if ("nn".Equals(variant, StringComparison.Ordinal)){flags = NorwegianStandard.NYNORSK;}else if ("no".Equals(variant, StringComparison.Ordinal)){flags = NorwegianStandard.BOKMAAL | NorwegianStandard.NYNORSK;}else{throw new System.ArgumentException("invalid variant: " + variant);}if (args.Count > 0){throw new System.ArgumentException("Unknown parameters: " + args);}}


public UpdateTypedLinkFacetResult updateTypedLinkFacet(UpdateTypedLinkFacetRequest request) {request = beforeClientExecution(request);return executeUpdateTypedLinkFacet(request);}

public virtual UpdateTypedLinkFacetResponse UpdateTypedLinkFacet(UpdateTypedLinkFacetRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateTypedLinkFacetRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateTypedLinkFacetResponseUnmarshaller.Instance;return Invoke<UpdateTypedLinkFacetResponse>(request, options);}

[User] public UpdateTypedLinkFacetResult updateTypedLinkFacet(UpdateTypedLinkFacetRequest request) {request = beforeClientExecution(request);return executeUpdateTypedLinkFacet(request);}

[Assistant] public virtual UpdateTypedLinkFacetResponse UpdateTypedLinkFacet(UpdateTypedLinkFacetRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateTypedLinkFacetRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateTypedLinkFacetResponseUnmarshaller.Instance;return Invoke<UpdateTypedLinkFacetResponse>(request, options);}


public E higher(E e) {return backingMap.higherKey(e);}

public virtual E higher(E e){return backingMap.higherKey(e);}

[User] public E higher(E e) {return backingMap.higherKey(e);}

[Assistant] public virtual E higher(E e){return backingMap.higherKey(e);}


public ListReceiptFiltersResult listReceiptFilters(ListReceiptFiltersRequest request) {request = beforeClientExecution(request);return executeListReceiptFilters(request);}

public virtual ListReceiptFiltersResponse ListReceiptFilters(ListReceiptFiltersRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListReceiptFiltersRequestMarshaller.Instance;options.ResponseUnmarshaller = ListReceiptFiltersResponseUnmarshaller.Instance;return Invoke<ListReceiptFiltersResponse>(request, options);}

[User] public ListReceiptFiltersResult listReceiptFilters(ListReceiptFiltersRequest request) {request = beforeClientExecution(request);return executeListReceiptFilters(request);}

[Assistant] public virtual ListReceiptFiltersResponse ListReceiptFilters(ListReceiptFiltersRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListReceiptFiltersRequestMarshaller.Instance;options.ResponseUnmarshaller = ListReceiptFiltersResponseUnmarshaller.Instance;return Invoke<ListReceiptFiltersResponse>(request, options);}


public int size() {synchronized (lock) {return count;}}

public virtual int size(){lock (@lock){return count;}}

[User] public int size() {synchronized (lock) {return count;}}

[Assistant] public virtual int size(){lock (@lock){return count;}}


public CreateVaultRequest(String vaultName) {setVaultName(vaultName);}

public CreateVaultRequest(string vaultName){_vaultName = vaultName;}

[User] public CreateVaultRequest(String vaultName) {setVaultName(vaultName);}

[Assistant] public CreateVaultRequest(string vaultName){_vaultName = vaultName;}


public PendingOutputs() {outputs = new CharsRefBuilder[1];endOffsets = new int[1];posLengths = new int[1];}

public PendingOutputs(){outputs = new CharsRef[1];endOffsets = new int[1];posLengths = new int[1];}

[User] public PendingOutputs() {outputs = new CharsRefBuilder[1];endOffsets = new int[1];posLengths = new int[1];}

[Assistant] public PendingOutputs(){outputs = new CharsRef[1];endOffsets = new int[1];posLengths = new int[1];}


public static double getExcelDate(Date date, boolean use1904windowing) {Calendar calStart = LocaleUtil.getLocaleCalendar();calStart.setTime(date);int year = calStart.get(Calendar.YEAR);int dayOfYear = calStart.get(Calendar.DAY_OF_YEAR);int hour = calStart.get(Calendar.HOUR_OF_DAY);int minute = calStart.get(Calendar.MINUTE);int second = calStart.get(Calendar.SECOND);int milliSecond = calStart.get(Calendar.MILLISECOND);return internalGetExcelDate(year, dayOfYear, hour, minute, second, milliSecond, use1904windowing);}

public static double GetExcelDate(DateTime date, bool use1904windowing){if ((!use1904windowing && date.Year < 1900)  || (use1904windowing && date.Year < 1904))   {return BAD_DATE;}DateTime startdate;if (use1904windowing){startdate = new DateTime(1904, 1, 1);}else{startdate = new DateTime(1900, 1, 1);}double value = (date - startdate).TotalDays + 1;if (!use1904windowing && value >= 60){value++;}else if (use1904windowing){value--;}return value;}

[User] public static double getExcelDate(Date date, boolean use1904windowing) {Calendar calStart = LocaleUtil.getLocaleCalendar();calStart.setTime(date);int year = calStart.get(Calendar.YEAR);int dayOfYear = calStart.get(Calendar.DAY_OF_YEAR);int hour = calStart.get(Calendar.HOUR_OF_DAY);int minute = calStart.get(Calendar.MINUTE);int second = calStart.get(Calendar.SECOND);int milliSecond = calStart.get(Calendar.MILLISECOND);return internalGetExcelDate(year, dayOfYear, hour, minute, second, milliSecond, use1904windowing);}

[Assistant] public static double GetExcelDate(DateTime date, bool use1904windowing){if ((!use1904windowing && date.Year < 1900)  || (use1904windowing && date.Year < 1904))   {return BAD_DATE;}DateTime startdate;if (use1904windowing){startdate = new DateTime(1904, 1, 1);}else{startdate = new DateTime(1900, 1, 1);}double value = (date - startdate).TotalDays + 1;if (!use1904windowing && value >= 60){value++;}else if (use1904windowing){value--;}return value;}


public ValueEval evaluate(ValueEval[] args, OperationEvaluationContext ec) {int nIncomingArgs = args.length;if(nIncomingArgs < 1) {throw new RuntimeException("function name argument missing");}ValueEval nameArg = args[0];String functionName;if (nameArg instanceof FunctionNameEval) {functionName = ((FunctionNameEval) nameArg).getFunctionName();} else {throw new RuntimeException("First argument should be a NameEval, but got ("+ nameArg.getClass().getName() + ")");}FreeRefFunction targetFunc = ec.findUserDefinedFunction(functionName);if (targetFunc == null) {throw new NotImplementedFunctionException(functionName);}int nOutGoingArgs = nIncomingArgs -1;ValueEval[] outGoingArgs = new ValueEval[nOutGoingArgs];System.arraycopy(args, 1, outGoingArgs, 0, nOutGoingArgs);return targetFunc.evaluate(outGoingArgs, ec);}

public ValueEval Evaluate(ValueEval[] args, OperationEvaluationContext ec){int nIncomingArgs = args.Length;if (nIncomingArgs < 1){throw new Exception("function name argument missing");}ValueEval nameArg = args[0];String functionName = string.Empty ;if (nameArg is FunctionNameEval){functionName = ((FunctionNameEval)nameArg).FunctionName;}else{throw new Exception("First argument should be a NameEval, but got ("+ nameArg.GetType().Name + ")");}FreeRefFunction targetFunc = ec.FindUserDefinedFunction(functionName);if (targetFunc == null){throw new NotImplementedFunctionException(functionName);}int nOutGoingArgs = nIncomingArgs - 1;ValueEval[] outGoingArgs = new ValueEval[nOutGoingArgs];Array.Copy(args, 1, outGoingArgs, 0, nOutGoingArgs);return targetFunc.Evaluate(outGoingArgs, ec);}

[User] public ValueEval evaluate(ValueEval[] args, OperationEvaluationContext ec) {int nIncomingArgs = args.length;if(nIncomingArgs < 1) {throw new RuntimeException("function name argument missing");}ValueEval nameArg = args[0];String functionName;if (nameArg instanceof FunctionNameEval) {functionName = ((FunctionNameEval) nameArg).getFunctionName();} else {throw new RuntimeException("First argument should be a NameEval, but got ("+ nameArg.getClass().getName() + ")");}FreeRefFunction targetFunc = ec.findUserDefinedFunction(functionName);if (targetFunc == null) {throw new NotImplementedFunctionException(functionName);}int nOutGoingArgs = nIncomingArgs -1;ValueEval[] outGoingArgs = new ValueEval[nOutGoingArgs];System.arraycopy(args, 1, outGoingArgs, 0, nOutGoingArgs);return targetFunc.evaluate(outGoingArgs, ec);}

[Assistant] public ValueEval Evaluate(ValueEval[] args, OperationEvaluationContext ec){int nIncomingArgs = args.Length;if (nIncomingArgs < 1){throw new Exception("function name argument missing");}ValueEval nameArg = args[0];String functionName = string.Empty ;if (nameArg is FunctionNameEval){functionName = ((FunctionNameEval)nameArg).FunctionName;}else{throw new Exception("First argument should be a NameEval, but got ("+ nameArg.GetType().Name + ")");}FreeRefFunction targetFunc = ec.FindUserDefinedFunction(functionName);if (targetFunc == null){throw new NotImplementedFunctionException(functionName);}int nOutGoingArgs = nIncomingArgs - 1;ValueEval[] outGoingArgs = new ValueEval[nOutGoingArgs];Array.Copy(args, 1, outGoingArgs, 0, nOutGoingArgs);return targetFunc.Evaluate(outGoingArgs, ec);}


public int indexOf(Object object) {int pos = 0;Link<E> link = voidLink.next;if (object != null) {while (link != voidLink) {if (object.equals(link.data)) {return pos;}link = link.next;pos++;}} else {while (link != voidLink) {if (link.data == null) {return pos;}link = link.next;pos++;}}return -1;}

public override int indexOf(object @object){int pos = 0;java.util.LinkedList.Link<E> link = voidLink.next;if (@object != null){while (link != voidLink){if (@object.Equals(link.data)){return pos;}link = link.next;pos++;}}else{while (link != voidLink){if ((object)link.data == null){return pos;}link = link.next;pos++;}}return -1;}

[User] public int indexOf(Object object) {int pos = 0;Link<E> link = voidLink.next;if (object != null) {while (link != voidLink) {if (object.equals(link.data)) {return pos;}link = link.next;pos++;}} else {while (link != voidLink) {if (link.data == null) {return pos;}link = link.next;pos++;}}return -1;}

[Assistant] public override int indexOf(object @object){int pos = 0;java.util.LinkedList.Link<E> link = voidLink.next;if (@object != null){while (link != voidLink){if (@object.Equals(link.data)){return pos;}link = link.next;pos++;}}else{while (link != voidLink){if ((object)link.data == null){return pos;}link = link.next;pos++;}}return -1;}


public DescribeVpcClassicLinkResult describeVpcClassicLink(DescribeVpcClassicLinkRequest request) {request = beforeClientExecution(request);return executeDescribeVpcClassicLink(request);}

public virtual DescribeVpcClassicLinkResponse DescribeVpcClassicLink(DescribeVpcClassicLinkRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeVpcClassicLinkRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeVpcClassicLinkResponseUnmarshaller.Instance;return Invoke<DescribeVpcClassicLinkResponse>(request, options);}

[User] public DescribeVpcClassicLinkResult describeVpcClassicLink(DescribeVpcClassicLinkRequest request) {request = beforeClientExecution(request);return executeDescribeVpcClassicLink(request);}

[Assistant] public virtual DescribeVpcClassicLinkResponse DescribeVpcClassicLink(DescribeVpcClassicLinkRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeVpcClassicLinkRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeVpcClassicLinkResponseUnmarshaller.Instance;return Invoke<DescribeVpcClassicLinkResponse>(request, options);}


public void sort(RevSort s, boolean use) {if (s == RevSort.TOPO && !use)throw new IllegalArgumentException(JGitText.get().topologicalSortRequired);super.sort(s, use);}

public override void Sort(RevSort s, bool use){if (s == RevSort.TOPO && !use){throw new ArgumentException(JGitText.Get().topologicalSortRequired);}base.Sort(s, use);}

[User] public void sort(RevSort s, boolean use) {if (s == RevSort.TOPO && !use)throw new IllegalArgumentException(JGitText.get().topologicalSortRequired);super.sort(s, use);}

[Assistant] public override void Sort(RevSort s, bool use){if (s == RevSort.TOPO && !use){throw new ArgumentException(JGitText.Get().topologicalSortRequired);}base.Sort(s, use);}


public synchronized StringBuffer delete(int start, int end) {delete0(start, end);return this;}

public java.lang.StringBuffer delete(int start, int end){lock (this){delete0(start, end);return this;}}

[User] public synchronized StringBuffer delete(int start, int end) {delete0(start, end);return this;}

[Assistant] public java.lang.StringBuffer delete(int start, int end){lock (this){delete0(start, end);return this;}}


public void write(int b) throws IOException {throw new UnsupportedOperationException();}

public override void Write(int b){throw new NGit.Errors.NotSupportedException();}

[User] public void write(int b) throws IOException {throw new UnsupportedOperationException();}

[Assistant] public override void Write(int b){throw new NGit.Errors.NotSupportedException();}


public boolean isModeDifferent(int rawMode) {int modeDiff = getEntryRawMode() ^ rawMode;if (modeDiff == 0)return false;if (getOptions().getSymLinks() == SymLinks.FALSE)if (FileMode.SYMLINK.equals(rawMode))return false;if (!state.options.isFileMode())modeDiff &= ~FileMode.EXECUTABLE_FILE.getBits();return modeDiff != 0;}

public virtual bool IsModeDifferent(int rawMode){int modeDiff = EntryRawMode ^ rawMode;if (modeDiff == 0){return false;}if (FileMode.SYMLINK.Equals(rawMode)){return false;}if (!state.options.IsFileMode()){modeDiff &= ~FileMode.EXECUTABLE_FILE.GetBits();}return modeDiff != 0;}

[User] public boolean isModeDifferent(int rawMode) {int modeDiff = getEntryRawMode() ^ rawMode;if (modeDiff == 0)return false;if (getOptions().getSymLinks() == SymLinks.FALSE)if (FileMode.SYMLINK.equals(rawMode))return false;if (!state.options.isFileMode())modeDiff &= ~FileMode.EXECUTABLE_FILE.getBits();return modeDiff != 0;}

[Assistant] public virtual bool IsModeDifferent(int rawMode){int modeDiff = EntryRawMode ^ rawMode;if (modeDiff == 0){return false;}if (FileMode.SYMLINK.Equals(rawMode)){return false;}if (!state.options.IsFileMode()){modeDiff &= ~FileMode.EXECUTABLE_FILE.GetBits();}return modeDiff != 0;}


public DescribeReservedInstancesModificationsResult describeReservedInstancesModifications(DescribeReservedInstancesModificationsRequest request) {request = beforeClientExecution(request);return executeDescribeReservedInstancesModifications(request);}

public virtual DescribeReservedInstancesModificationsResponse DescribeReservedInstancesModifications(DescribeReservedInstancesModificationsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeReservedInstancesModificationsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeReservedInstancesModificationsResponseUnmarshaller.Instance;return Invoke<DescribeReservedInstancesModificationsResponse>(request, options);}

[User] public DescribeReservedInstancesModificationsResult describeReservedInstancesModifications(DescribeReservedInstancesModificationsRequest request) {request = beforeClientExecution(request);return executeDescribeReservedInstancesModifications(request);}

[Assistant] public virtual DescribeReservedInstancesModificationsResponse DescribeReservedInstancesModifications(DescribeReservedInstancesModificationsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeReservedInstancesModificationsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeReservedInstancesModificationsResponseUnmarshaller.Instance;return Invoke<DescribeReservedInstancesModificationsResponse>(request, options);}


public EventSubscription addSourceIdentifierToSubscription(AddSourceIdentifierToSubscriptionRequest request) {request = beforeClientExecution(request);return executeAddSourceIdentifierToSubscription(request);}

public virtual AddSourceIdentifierToSubscriptionResponse AddSourceIdentifierToSubscription(AddSourceIdentifierToSubscriptionRequest request){var options = new InvokeOptions();options.RequestMarshaller = AddSourceIdentifierToSubscriptionRequestMarshaller.Instance;options.ResponseUnmarshaller = AddSourceIdentifierToSubscriptionResponseUnmarshaller.Instance;return Invoke<AddSourceIdentifierToSubscriptionResponse>(request, options);}

[User] public EventSubscription addSourceIdentifierToSubscription(AddSourceIdentifierToSubscriptionRequest request) {request = beforeClientExecution(request);return executeAddSourceIdentifierToSubscription(request);}

[Assistant] public virtual AddSourceIdentifierToSubscriptionResponse AddSourceIdentifierToSubscription(AddSourceIdentifierToSubscriptionRequest request){var options = new InvokeOptions();options.RequestMarshaller = AddSourceIdentifierToSubscriptionRequestMarshaller.Instance;options.ResponseUnmarshaller = AddSourceIdentifierToSubscriptionResponseUnmarshaller.Instance;return Invoke<AddSourceIdentifierToSubscriptionResponse>(request, options);}


@Override public boolean equals(Object o) {if (o == this) {return true;}synchronized (mutex) {return delegate().equals(o);}}

public override bool Equals(object @object){lock (mutex){return list.Equals(@object);}}

[User] @Override public boolean equals(Object o) {if (o == this) {return true;}synchronized (mutex) {return delegate().equals(o);}}

[Assistant] public override bool Equals(object @object){lock (mutex){return list.Equals(@object);}}


public PagedBytesDataOutput getDataOutput() {if (frozen) {throw new IllegalStateException("cannot get DataOutput after freeze()");}return new PagedBytesDataOutput();}

public PagedBytesDataOutput GetDataOutput(){if (frozen){throw new InvalidOperationException("cannot get DataOutput after Freeze()");}return new PagedBytesDataOutput(this);}

[User] public PagedBytesDataOutput getDataOutput() {if (frozen) {throw new IllegalStateException("cannot get DataOutput after freeze()");}return new PagedBytesDataOutput();}

[Assistant] public PagedBytesDataOutput GetDataOutput(){if (frozen){throw new InvalidOperationException("cannot get DataOutput after Freeze()");}return new PagedBytesDataOutput(this);}


public static short[] copyOfRange(short[] original, int start, int end) {if (start > end) {throw new IllegalArgumentException();}int originalLength = original.length;if (start < 0 || start > originalLength) {throw new ArrayIndexOutOfBoundsException();}int resultLength = end - start;int copyLength = Math.min(resultLength, originalLength - start);short[] result = new short[resultLength];System.arraycopy(original, start, result, 0, copyLength);return result;}

public static short[] copyOfRange(short[] original, int start, int end){if (start > end){throw new System.ArgumentException();}int originalLength = original.Length;if (start < 0 || start > originalLength){throw new System.IndexOutOfRangeException();}int resultLength = end - start;int copyLength = System.Math.Min(resultLength, originalLength - start);short[] result = new short[resultLength];System.Array.Copy(original, start, result, 0, copyLength);return result;}

[User] public static short[] copyOfRange(short[] original, int start, int end) {if (start > end) {throw new IllegalArgumentException();}int originalLength = original.length;if (start < 0 || start > originalLength) {throw new ArrayIndexOutOfBoundsException();}int resultLength = end - start;int copyLength = Math.min(resultLength, originalLength - start);short[] result = new short[resultLength];System.arraycopy(original, start, result, 0, copyLength);return result;}

[Assistant] public static short[] copyOfRange(short[] original, int start, int end){if (start > end){throw new System.ArgumentException();}int originalLength = original.Length;if (start < 0 || start > originalLength){throw new System.IndexOutOfRangeException();}int resultLength = end - start;int copyLength = System.Math.Min(resultLength, originalLength - start);short[] result = new short[resultLength];System.Array.Copy(original, start, result, 0, copyLength);return result;}


public boolean removeURI(URIish toRemove) {return uris.remove(toRemove);}

public virtual bool RemoveURI(URIish toRemove){return uris.Remove(toRemove);}

[User] public boolean removeURI(URIish toRemove) {return uris.remove(toRemove);}

[Assistant] public virtual bool RemoveURI(URIish toRemove){return uris.Remove(toRemove);}


public DescribeGameServerResult describeGameServer(DescribeGameServerRequest request) {request = beforeClientExecution(request);return executeDescribeGameServer(request);}

public virtual DescribeGameServerResponse DescribeGameServer(DescribeGameServerRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeGameServerRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeGameServerResponseUnmarshaller.Instance;return Invoke<DescribeGameServerResponse>(request, options);}

[User] public DescribeGameServerResult describeGameServer(DescribeGameServerRequest request) {request = beforeClientExecution(request);return executeDescribeGameServer(request);}

[Assistant] public virtual DescribeGameServerResponse DescribeGameServer(DescribeGameServerRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeGameServerRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeGameServerResponseUnmarshaller.Instance;return Invoke<DescribeGameServerResponse>(request, options);}


public boolean hasNext() {return pos < keys.length;}

public bool HasNext(){return this.next_Renamed != null;}

[User] public boolean hasNext() {return pos < keys.length;}

[Assistant] public bool HasNext(){return this.next_Renamed != null;}


public IntervalSet subtract(IntSet a) {if (a == null || a.isNil()) {return new IntervalSet(this);}if (a instanceof IntervalSet) {return subtract(this, (IntervalSet)a);}IntervalSet other = new IntervalSet();other.addAll(a);return subtract(this, other);}

public virtual Antlr4.Runtime.Misc.IntervalSet Subtract(IIntSet a){if (a == null || a.IsNil){return new Antlr4.Runtime.Misc.IntervalSet(this);}if (a is Antlr4.Runtime.Misc.IntervalSet){return Subtract(this, (Antlr4.Runtime.Misc.IntervalSet)a);}Antlr4.Runtime.Misc.IntervalSet other = new Antlr4.Runtime.Misc.IntervalSet();other.AddAll(a);return Subtract(this, other);}

[User] public IntervalSet subtract(IntSet a) {if (a == null || a.isNil()) {return new IntervalSet(this);}if (a instanceof IntervalSet) {return subtract(this, (IntervalSet)a);}IntervalSet other = new IntervalSet();other.addAll(a);return subtract(this, other);}

[Assistant] public virtual Antlr4.Runtime.Misc.IntervalSet Subtract(IIntSet a){if (a == null || a.IsNil){return new Antlr4.Runtime.Misc.IntervalSet(this);}if (a is Antlr4.Runtime.Misc.IntervalSet){return Subtract(this, (Antlr4.Runtime.Misc.IntervalSet)a);}Antlr4.Runtime.Misc.IntervalSet other = new Antlr4.Runtime.Misc.IntervalSet();other.AddAll(a);return Subtract(this, other);}


public String displayName() {return this.canonicalName;}

public virtual string displayName(){return this.canonicalName;}

[User] public String displayName() {return this.canonicalName;}

[Assistant] public virtual string displayName(){return this.canonicalName;}


public final ValueEval getValue(int row, int col) {return getRelativeValue(row, col);}

public ValueEval GetValue(int row, int col){return GetRelativeValue(row, col);}

[User] public final ValueEval getValue(int row, int col) {return getRelativeValue(row, col);}

[Assistant] public ValueEval GetValue(int row, int col){return GetRelativeValue(row, col);}


public AttrPtg(LittleEndianInput in) {_options = in.readByte();_data    = in.readShort();if (isOptimizedChoose()) {int[] jumpTable = new int[(int) _data];for (int i = 0; i < jumpTable.length; i++) {jumpTable[i] = in.readUShort();}_jumpTable = jumpTable;_chooseFuncOffset = in.readUShort();} else {_jumpTable = null;_chooseFuncOffset = -1;}}

public AttrPtg(ILittleEndianInput in1){field_1_options =(byte)in1.ReadByte();field_2_data = in1.ReadShort();if (IsOptimizedChoose){int nCases = field_2_data;int[] jumpTable = new int[nCases];for (int i = 0; i < jumpTable.Length; i++){jumpTable[i] = in1.ReadUShort();}_jumpTable = jumpTable;_chooseFuncOffset = in1.ReadUShort();}else{_jumpTable = null;_chooseFuncOffset = -1;}}

[User] public AttrPtg(LittleEndianInput in) {_options = in.readByte();_data    = in.readShort();if (isOptimizedChoose()) {int[] jumpTable = new int[(int) _data];for (int i = 0; i < jumpTable.length; i++) {jumpTable[i] = in.readUShort();}_jumpTable = jumpTable;_chooseFuncOffset = in.readUShort();} else {_jumpTable = null;_chooseFuncOffset = -1;}}

[Assistant] public AttrPtg(ILittleEndianInput in1){field_1_options =(byte)in1.ReadByte();field_2_data = in1.ReadShort();if (IsOptimizedChoose){int nCases = field_2_data;int[] jumpTable = new int[nCases];for (int i = 0; i < jumpTable.Length; i++){jumpTable[i] = in1.ReadUShort();}_jumpTable = jumpTable;_chooseFuncOffset = in1.ReadUShort();}else{_jumpTable = null;_chooseFuncOffset = -1;}}


public DescribeTrafficMirrorFiltersResult describeTrafficMirrorFilters(DescribeTrafficMirrorFiltersRequest request) {request = beforeClientExecution(request);return executeDescribeTrafficMirrorFilters(request);}

public virtual DescribeTrafficMirrorFiltersResponse DescribeTrafficMirrorFilters(DescribeTrafficMirrorFiltersRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeTrafficMirrorFiltersRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeTrafficMirrorFiltersResponseUnmarshaller.Instance;return Invoke<DescribeTrafficMirrorFiltersResponse>(request, options);}

[User] public DescribeTrafficMirrorFiltersResult describeTrafficMirrorFilters(DescribeTrafficMirrorFiltersRequest request) {request = beforeClientExecution(request);return executeDescribeTrafficMirrorFilters(request);}

[Assistant] public virtual DescribeTrafficMirrorFiltersResponse DescribeTrafficMirrorFilters(DescribeTrafficMirrorFiltersRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeTrafficMirrorFiltersRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeTrafficMirrorFiltersResponseUnmarshaller.Instance;return Invoke<DescribeTrafficMirrorFiltersResponse>(request, options);}


public final ShortBuffer put(short[] src) {return put(src, 0, src.length);}

public java.nio.ShortBuffer put(short[] src){return put(src, 0, src.Length);}

[User] public final ShortBuffer put(short[] src) {return put(src, 0, src.length);}

[Assistant] public java.nio.ShortBuffer put(short[] src){return put(src, 0, src.Length);}


public DescribeReservedNodeOfferingsResult describeReservedNodeOfferings() {return describeReservedNodeOfferings(new DescribeReservedNodeOfferingsRequest());}

public virtual DescribeReservedNodeOfferingsResponse DescribeReservedNodeOfferings(){return DescribeReservedNodeOfferings(new DescribeReservedNodeOfferingsRequest());}

[User] public DescribeReservedNodeOfferingsResult describeReservedNodeOfferings() {return describeReservedNodeOfferings(new DescribeReservedNodeOfferingsRequest());}

[Assistant] public virtual DescribeReservedNodeOfferingsResponse DescribeReservedNodeOfferings(){return DescribeReservedNodeOfferings(new DescribeReservedNodeOfferingsRequest());}


public CreateLogStreamRequest(String logGroupName, String logStreamName) {setLogGroupName(logGroupName);setLogStreamName(logStreamName);}

public CreateLogStreamRequest(string logGroupName, string logStreamName){_logGroupName = logGroupName;_logStreamName = logStreamName;}

[User] public CreateLogStreamRequest(String logGroupName, String logStreamName) {setLogGroupName(logGroupName);setLogStreamName(logStreamName);}

[Assistant] public CreateLogStreamRequest(string logGroupName, string logStreamName){_logGroupName = logGroupName;_logStreamName = logStreamName;}


public DetachStaticIpResult detachStaticIp(DetachStaticIpRequest request) {request = beforeClientExecution(request);return executeDetachStaticIp(request);}

public virtual DetachStaticIpResponse DetachStaticIp(DetachStaticIpRequest request){var options = new InvokeOptions();options.RequestMarshaller = DetachStaticIpRequestMarshaller.Instance;options.ResponseUnmarshaller = DetachStaticIpResponseUnmarshaller.Instance;return Invoke<DetachStaticIpResponse>(request, options);}

[User] public DetachStaticIpResult detachStaticIp(DetachStaticIpRequest request) {request = beforeClientExecution(request);return executeDetachStaticIp(request);}

[Assistant] public virtual DetachStaticIpResponse DetachStaticIp(DetachStaticIpRequest request){var options = new InvokeOptions();options.RequestMarshaller = DetachStaticIpRequestMarshaller.Instance;options.ResponseUnmarshaller = DetachStaticIpResponseUnmarshaller.Instance;return Invoke<DetachStaticIpResponse>(request, options);}


public static CharArraySet unmodifiableSet(CharArraySet set) {if (set == null)throw new NullPointerException("Given set is null");if (set == EMPTY_SET)return EMPTY_SET;if (set.map instanceof CharArrayMap.UnmodifiableCharArrayMap)return set;return new CharArraySet(CharArrayMap.unmodifiableMap(set.map));}

public static CharArraySet UnmodifiableSet(CharArraySet set){if (set == null){throw new System.ArgumentNullException("Given set is null");}if (set == EMPTY_SET){return EMPTY_SET;}if (set.map is CharArrayMap.UnmodifiableCharArrayMap<object>){return set;}return new CharArraySet(CharArrayMap.UnmodifiableMap<object>(set.map));}

[User] public static CharArraySet unmodifiableSet(CharArraySet set) {if (set == null)throw new NullPointerException("Given set is null");if (set == EMPTY_SET)return EMPTY_SET;if (set.map instanceof CharArrayMap.UnmodifiableCharArrayMap)return set;return new CharArraySet(CharArrayMap.unmodifiableMap(set.map));}

[Assistant] public static CharArraySet UnmodifiableSet(CharArraySet set){if (set == null){throw new System.ArgumentNullException("Given set is null");}if (set == EMPTY_SET){return EMPTY_SET;}if (set.map is CharArrayMap.UnmodifiableCharArrayMap<object>){return set;}return new CharArraySet(CharArrayMap.UnmodifiableMap<object>(set.map));}


public BatchDetectKeyPhrasesResult batchDetectKeyPhrases(BatchDetectKeyPhrasesRequest request) {request = beforeClientExecution(request);return executeBatchDetectKeyPhrases(request);}

public virtual BatchDetectKeyPhrasesResponse BatchDetectKeyPhrases(BatchDetectKeyPhrasesRequest request){var options = new InvokeOptions();options.RequestMarshaller = BatchDetectKeyPhrasesRequestMarshaller.Instance;options.ResponseUnmarshaller = BatchDetectKeyPhrasesResponseUnmarshaller.Instance;return Invoke<BatchDetectKeyPhrasesResponse>(request, options);}

[User] public BatchDetectKeyPhrasesResult batchDetectKeyPhrases(BatchDetectKeyPhrasesRequest request) {request = beforeClientExecution(request);return executeBatchDetectKeyPhrases(request);}

[Assistant] public virtual BatchDetectKeyPhrasesResponse BatchDetectKeyPhrases(BatchDetectKeyPhrasesRequest request){var options = new InvokeOptions();options.RequestMarshaller = BatchDetectKeyPhrasesRequestMarshaller.Instance;options.ResponseUnmarshaller = BatchDetectKeyPhrasesResponseUnmarshaller.Instance;return Invoke<BatchDetectKeyPhrasesResponse>(request, options);}


public final ValueEval evaluate(ValueEval[] args, int srcRowIndex, int srcColumnIndex) {if (args.length != 1) {return ErrorEval.VALUE_INVALID;}return evaluate(srcRowIndex, srcColumnIndex, args[0]);}

public ValueEval Evaluate(ValueEval[] args, int srcRowIndex, int srcColumnIndex){if (args.Length != 1){return ErrorEval.VALUE_INVALID;}return Evaluate(srcRowIndex, srcColumnIndex, args[0]);}

[User] public final ValueEval evaluate(ValueEval[] args, int srcRowIndex, int srcColumnIndex) {if (args.length != 1) {return ErrorEval.VALUE_INVALID;}return evaluate(srcRowIndex, srcColumnIndex, args[0]);}

[Assistant] public ValueEval Evaluate(ValueEval[] args, int srcRowIndex, int srcColumnIndex){if (args.Length != 1){return ErrorEval.VALUE_INVALID;}return Evaluate(srcRowIndex, srcColumnIndex, args[0]);}


public void removeWordCount() {remove1stProperty(PropertyIDMap.PID_WORDCOUNT);}

public void RemoveWordCount(){MutableSection s = (MutableSection)FirstSection;s.RemoveProperty(PropertyIDMap.PID_WORDCOUNT);}

[User] public void removeWordCount() {remove1stProperty(PropertyIDMap.PID_WORDCOUNT);}

[Assistant] public void RemoveWordCount(){MutableSection s = (MutableSection)FirstSection;s.RemoveProperty(PropertyIDMap.PID_WORDCOUNT);}


public boolean equals(Object o) {if (this == o) {return true;}else if ( !(o instanceof SingletonPredictionContext) ) {return false;}if ( this.hashCode() != o.hashCode() ) {return false; }SingletonPredictionContext s = (SingletonPredictionContext)o;return returnState == s.returnState &&(parent!=null && parent.equals(s.parent));}

public override bool Equals(object o){if (o == this){return true;}else{if (!(o is Antlr4.Runtime.Atn.SingletonPredictionContext)){return false;}}if (this.GetHashCode() != o.GetHashCode()){return false;}Antlr4.Runtime.Atn.SingletonPredictionContext other = (Antlr4.Runtime.Atn.SingletonPredictionContext)o;return returnState == other.returnState && parent.Equals(other.parent);}

[User] public boolean equals(Object o) {if (this == o) {return true;}else if ( !(o instanceof SingletonPredictionContext) ) {return false;}if ( this.hashCode() != o.hashCode() ) {return false; }SingletonPredictionContext s = (SingletonPredictionContext)o;return returnState == s.returnState &&(parent!=null && parent.equals(s.parent));}

[Assistant] public override bool Equals(object o){if (o == this){return true;}else{if (!(o is Antlr4.Runtime.Atn.SingletonPredictionContext)){return false;}}if (this.GetHashCode() != o.GetHashCode()){return false;}Antlr4.Runtime.Atn.SingletonPredictionContext other = (Antlr4.Runtime.Atn.SingletonPredictionContext)o;return returnState == other.returnState && parent.Equals(other.parent);}


public ResourceBundle resourceBundle() {return resourceBundle;}

public virtual Sharpen.ResourceBundle ResourceBundle(){return resourceBundle;}

[User] public ResourceBundle resourceBundle() {return resourceBundle;}

[Assistant] public virtual Sharpen.ResourceBundle ResourceBundle(){return resourceBundle;}


public TokenStream create(TokenStream stream) {if (stopTags != null) {final TokenStream filter = new JapanesePartOfSpeechStopFilter(stream, stopTags);return filter;} else {return stream;}}

public override TokenStream Create(TokenStream stream){if (stopTags != null){#pragma warning disable 612, 618TokenStream filter = new JapanesePartOfSpeechStopFilter(m_luceneMatchVersion, enablePositionIncrements, stream, stopTags);#pragma warning restore 612, 618return filter;}else{return stream;}}

[User] public TokenStream create(TokenStream stream) {if (stopTags != null) {final TokenStream filter = new JapanesePartOfSpeechStopFilter(stream, stopTags);return filter;} else {return stream;}}

[Assistant] public override TokenStream Create(TokenStream stream){if (stopTags != null){#pragma warning disable 612, 618TokenStream filter = new JapanesePartOfSpeechStopFilter(m_luceneMatchVersion, enablePositionIncrements, stream, stopTags);#pragma warning restore 612, 618return filter;}else{return stream;}}


public final int[] getBreaks() {int count = getNumBreaks();if (count < 1) {return EMPTY_INT_ARRAY;}int[] result = new int[count];for (int i=0; i<count; i++) {Break breakItem = _breaks.get(i);result[i] = breakItem.main;}return result;}

public int[] GetBreaks(){int count = NumBreaks;if (count < 1){return EMPTY_INT_ARRAY;}int[] result = new int[count];for (int i = 0; i < count; i++){Break breakItem = _breaks[i];result[i] = breakItem.main;}return result;}

[User] public final int[] getBreaks() {int count = getNumBreaks();if (count < 1) {return EMPTY_INT_ARRAY;}int[] result = new int[count];for (int i=0; i<count; i++) {Break breakItem = _breaks.get(i);result[i] = breakItem.main;}return result;}

[Assistant] public int[] GetBreaks(){int count = NumBreaks;if (count < 1){return EMPTY_INT_ARRAY;}int[] result = new int[count];for (int i = 0; i < count; i++){Break breakItem = _breaks[i];result[i] = breakItem.main;}return result;}


public EventSubscription createEventSubscription(CreateEventSubscriptionRequest request) {request = beforeClientExecution(request);return executeCreateEventSubscription(request);}

public virtual CreateEventSubscriptionResponse CreateEventSubscription(CreateEventSubscriptionRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateEventSubscriptionRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateEventSubscriptionResponseUnmarshaller.Instance;return Invoke<CreateEventSubscriptionResponse>(request, options);}

[User] public EventSubscription createEventSubscription(CreateEventSubscriptionRequest request) {request = beforeClientExecution(request);return executeCreateEventSubscription(request);}

[Assistant] public virtual CreateEventSubscriptionResponse CreateEventSubscription(CreateEventSubscriptionRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateEventSubscriptionRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateEventSubscriptionResponseUnmarshaller.Instance;return Invoke<CreateEventSubscriptionResponse>(request, options);}


@Override public V get(Object key) {return isInBounds(key) ? TreeMap.this.get(key) : null;}

public override V get(object key){return this.isInBounds(key) ? this._enclosing.get(key) : default(V);}

[User] @Override public V get(Object key) {return isInBounds(key) ? TreeMap.this.get(key) : null;}

[Assistant] public override V get(object key){return this.isInBounds(key) ? this._enclosing.get(key) : default(V);}


public void setAnchor(int dx1, int dy1, int dx2, int dy2) {setDx1(Math.min(dx1, dx2));setDy1(Math.min(dy1, dy2));setDx2(Math.max(dx1, dx2));setDy2(Math.max(dy1, dy2));}

public void SetAnchor(int dx1, int dy1, int dx2, int dy2){this.Dx1 = Math.Min(dx1, dx2);this.Dy1 = Math.Min(dy1, dy2);this.Dx2 = Math.Max(dx1, dx2);this.Dy2 = Math.Max(dy1, dy2);}

[User] public void setAnchor(int dx1, int dy1, int dx2, int dy2) {setDx1(Math.min(dx1, dx2));setDy1(Math.min(dy1, dy2));setDx2(Math.max(dx1, dx2));setDy2(Math.max(dy1, dy2));}

[Assistant] public void SetAnchor(int dx1, int dy1, int dx2, int dy2){this.Dx1 = Math.Min(dx1, dx2);this.Dy1 = Math.Min(dy1, dy2);this.Dx2 = Math.Max(dx1, dx2);this.Dy2 = Math.Max(dy1, dy2);}


public int next() {if (current == end) {return DONE;} else {return last();}}

public override int Next(){if (current == end){return Done;}else{return Last();}}

[User] public int next() {if (current == end) {return DONE;} else {return last();}}

[Assistant] public override int Next(){if (current == end){return Done;}else{return Last();}}


public UpdateGcmChannelResult updateGcmChannel(UpdateGcmChannelRequest request) {request = beforeClientExecution(request);return executeUpdateGcmChannel(request);}

public virtual UpdateGcmChannelResponse UpdateGcmChannel(UpdateGcmChannelRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateGcmChannelRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateGcmChannelResponseUnmarshaller.Instance;return Invoke<UpdateGcmChannelResponse>(request, options);}

[User] public UpdateGcmChannelResult updateGcmChannel(UpdateGcmChannelRequest request) {request = beforeClientExecution(request);return executeUpdateGcmChannel(request);}

[Assistant] public virtual UpdateGcmChannelResponse UpdateGcmChannel(UpdateGcmChannelRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateGcmChannelRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateGcmChannelResponseUnmarshaller.Instance;return Invoke<UpdateGcmChannelResponse>(request, options);}


public void write(LittleEndianOutput out) {throw new IllegalStateException("XSSF-only Ptg, should not be serialised");}

public override void Write(ILittleEndianOutput out1){throw new InvalidOperationException("XSSF-only Ptg, should not be serialised");}

[User] public void write(LittleEndianOutput out) {throw new IllegalStateException("XSSF-only Ptg, should not be serialised");}

[Assistant] public override void Write(ILittleEndianOutput out1){throw new InvalidOperationException("XSSF-only Ptg, should not be serialised");}


public PlacementGroup(String groupName) {setGroupName(groupName);}

public PlacementGroup(string groupName){_groupName = groupName;}

[User] public PlacementGroup(String groupName) {setGroupName(groupName);}

[Assistant] public PlacementGroup(string groupName){_groupName = groupName;}


public SendCustomVerificationEmailResult sendCustomVerificationEmail(SendCustomVerificationEmailRequest request) {request = beforeClientExecution(request);return executeSendCustomVerificationEmail(request);}

public virtual SendCustomVerificationEmailResponse SendCustomVerificationEmail(SendCustomVerificationEmailRequest request){var options = new InvokeOptions();options.RequestMarshaller = SendCustomVerificationEmailRequestMarshaller.Instance;options.ResponseUnmarshaller = SendCustomVerificationEmailResponseUnmarshaller.Instance;return Invoke<SendCustomVerificationEmailResponse>(request, options);}

[User] public SendCustomVerificationEmailResult sendCustomVerificationEmail(SendCustomVerificationEmailRequest request) {request = beforeClientExecution(request);return executeSendCustomVerificationEmail(request);}

[Assistant] public virtual SendCustomVerificationEmailResponse SendCustomVerificationEmail(SendCustomVerificationEmailRequest request){var options = new InvokeOptions();options.RequestMarshaller = SendCustomVerificationEmailRequestMarshaller.Instance;options.ResponseUnmarshaller = SendCustomVerificationEmailResponseUnmarshaller.Instance;return Invoke<SendCustomVerificationEmailResponse>(request, options);}


public CreateCollectionRequest() {super("cr", "2016-06-07", "CreateCollection", "cr");setUriPattern("/collections");setMethod(MethodType.PUT);}

public CreateCollectionRequest(): base("cr", "2016-06-07", "CreateCollection", "cr", "openAPI"){UriPattern = "/collections";Method = MethodType.PUT;}

[User] public CreateCollectionRequest() {super("cr", "2016-06-07", "CreateCollection", "cr");setUriPattern("/collections");setMethod(MethodType.PUT);}

[Assistant] public CreateCollectionRequest(): base("cr", "2016-06-07", "CreateCollection", "cr", "openAPI"){UriPattern = "/collections";Method = MethodType.PUT;}


public synchronized boolean remove(Object o) {int index = indexOf(o);if (index == -1) {return false;}remove(index);return true;}

public virtual bool remove(object o){lock (this){int index = indexOf(o);if (index == -1){return false;}remove(index);return true;}}

[User] public synchronized boolean remove(Object o) {int index = indexOf(o);if (index == -1) {return false;}remove(index);return true;}

[Assistant] public virtual bool remove(object o){lock (this){int index = indexOf(o);if (index == -1){return false;}remove(index);return true;}}


public final boolean matches(char c) {return Character.isDigit(c);}

public bool Matches(char c){return char.IsDigit(c);}

[User] public final boolean matches(char c) {return Character.isDigit(c);}

[Assistant] public bool Matches(char c){return char.IsDigit(c);}


public void serialize(LittleEndianOutput out) {out.writeByte(getWSBool2());out.writeByte(getWSBool1());}

public override void Serialize(ILittleEndianOutput out1){out1.WriteByte(WSBool1);out1.WriteByte(WSBool2);}

[User] public void serialize(LittleEndianOutput out) {out.writeByte(getWSBool2());out.writeByte(getWSBool1());}

[Assistant] public override void Serialize(ILittleEndianOutput out1){out1.WriteByte(WSBool1);out1.WriteByte(WSBool2);}


public SubmitGenerateTaskRequest() {super("lubancloud", "2018-05-09", "SubmitGenerateTask", "luban");setMethod(MethodType.POST);}

public SubmitGenerateTaskRequest(): base("lubancloud", "2018-05-09", "SubmitGenerateTask", "luban", "openAPI"){Method = MethodType.POST;}

[User] public SubmitGenerateTaskRequest() {super("lubancloud", "2018-05-09", "SubmitGenerateTask", "luban");setMethod(MethodType.POST);}

[Assistant] public SubmitGenerateTaskRequest(): base("lubancloud", "2018-05-09", "SubmitGenerateTask", "luban", "openAPI"){Method = MethodType.POST;}


public E ceiling(E e) {return backingMap.ceilingKey(e);}

public virtual E ceiling(E e){return backingMap.ceilingKey(e);}

[User] public E ceiling(E e) {return backingMap.ceilingKey(e);}

[Assistant] public virtual E ceiling(E e){return backingMap.ceilingKey(e);}


public BatchApplyUpdateActionResult batchApplyUpdateAction(BatchApplyUpdateActionRequest request) {request = beforeClientExecution(request);return executeBatchApplyUpdateAction(request);}

public virtual BatchApplyUpdateActionResponse BatchApplyUpdateAction(BatchApplyUpdateActionRequest request){var options = new InvokeOptions();options.RequestMarshaller = BatchApplyUpdateActionRequestMarshaller.Instance;options.ResponseUnmarshaller = BatchApplyUpdateActionResponseUnmarshaller.Instance;return Invoke<BatchApplyUpdateActionResponse>(request, options);}

[User] public BatchApplyUpdateActionResult batchApplyUpdateAction(BatchApplyUpdateActionRequest request) {request = beforeClientExecution(request);return executeBatchApplyUpdateAction(request);}

[Assistant] public virtual BatchApplyUpdateActionResponse BatchApplyUpdateAction(BatchApplyUpdateActionRequest request){var options = new InvokeOptions();options.RequestMarshaller = BatchApplyUpdateActionRequestMarshaller.Instance;options.ResponseUnmarshaller = BatchApplyUpdateActionResponseUnmarshaller.Instance;return Invoke<BatchApplyUpdateActionResponse>(request, options);}


public Break(RecordInputStream in) {main = in.readUShort() - 1;subFrom = in.readUShort();subTo = in.readUShort();}

public Break(RecordInputStream in1){main = in1.ReadUShort() - 1;subFrom = in1.ReadUShort();subTo = in1.ReadUShort();}

[User] public Break(RecordInputStream in) {main = in.readUShort() - 1;subFrom = in.readUShort();subTo = in.readUShort();}

[Assistant] public Break(RecordInputStream in1){main = in1.ReadUShort() - 1;subFrom = in1.ReadUShort();subTo = in1.ReadUShort();}


public FileNameMatcher createMatcherForSuffix() {final List<Head> copyOfHeads = new ArrayList<>(heads.size());copyOfHeads.addAll(heads);return new FileNameMatcher(copyOfHeads);}

public virtual NGit.Fnmatch.FileNameMatcher CreateMatcherForSuffix(){IList<Head> copyOfHeads = new AList<Head>(heads.Count);Sharpen.Collections.AddAll(copyOfHeads, heads);return new NGit.Fnmatch.FileNameMatcher(copyOfHeads);}

[User] public FileNameMatcher createMatcherForSuffix() {final List<Head> copyOfHeads = new ArrayList<>(heads.size());copyOfHeads.addAll(heads);return new FileNameMatcher(copyOfHeads);}

[Assistant] public virtual NGit.Fnmatch.FileNameMatcher CreateMatcherForSuffix(){IList<Head> copyOfHeads = new AList<Head>(heads.Count);Sharpen.Collections.AddAll(copyOfHeads, heads);return new NGit.Fnmatch.FileNameMatcher(copyOfHeads);}


public static boolean isEmptyOrNull(String stringValue) {return stringValue == null || stringValue.length() == 0;}

public static bool IsEmptyOrNull(string stringValue){return stringValue == null || stringValue.Length == 0;}

[User] public static boolean isEmptyOrNull(String stringValue) {return stringValue == null || stringValue.length() == 0;}

[Assistant] public static bool IsEmptyOrNull(string stringValue){return stringValue == null || stringValue.Length == 0;}


public static char[] grow(char[] array) {return grow(array, 1 + array.length);}

public static short[] Grow(short[] array){return Grow(array, 1 + array.Length);}

[User] public static char[] grow(char[] array) {return grow(array, 1 + array.length);}

[Assistant] public static short[] Grow(short[] array){return Grow(array, 1 + array.Length);}


public ModifySubnetAttributeResult modifySubnetAttribute(ModifySubnetAttributeRequest request) {request = beforeClientExecution(request);return executeModifySubnetAttribute(request);}

public virtual ModifySubnetAttributeResponse ModifySubnetAttribute(ModifySubnetAttributeRequest request){var options = new InvokeOptions();options.RequestMarshaller = ModifySubnetAttributeRequestMarshaller.Instance;options.ResponseUnmarshaller = ModifySubnetAttributeResponseUnmarshaller.Instance;return Invoke<ModifySubnetAttributeResponse>(request, options);}

[User] public ModifySubnetAttributeResult modifySubnetAttribute(ModifySubnetAttributeRequest request) {request = beforeClientExecution(request);return executeModifySubnetAttribute(request);}

[Assistant] public virtual ModifySubnetAttributeResponse ModifySubnetAttribute(ModifySubnetAttributeRequest request){var options = new InvokeOptions();options.RequestMarshaller = ModifySubnetAttributeRequestMarshaller.Instance;options.ResponseUnmarshaller = ModifySubnetAttributeResponseUnmarshaller.Instance;return Invoke<ModifySubnetAttributeResponse>(request, options);}


public GetProxySessionResult getProxySession(GetProxySessionRequest request) {request = beforeClientExecution(request);return executeGetProxySession(request);}

public virtual GetProxySessionResponse GetProxySession(GetProxySessionRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetProxySessionRequestMarshaller.Instance;options.ResponseUnmarshaller = GetProxySessionResponseUnmarshaller.Instance;return Invoke<GetProxySessionResponse>(request, options);}

[User] public GetProxySessionResult getProxySession(GetProxySessionRequest request) {request = beforeClientExecution(request);return executeGetProxySession(request);}

[Assistant] public virtual GetProxySessionResponse GetProxySession(GetProxySessionRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetProxySessionRequestMarshaller.Instance;options.ResponseUnmarshaller = GetProxySessionResponseUnmarshaller.Instance;return Invoke<GetProxySessionResponse>(request, options);}


public String toString() {return "TermStats{" +"decodedTermText='" + decodedTermText + '\'' +", field='" + field + '\'' +", docFreq=" + docFreq +'}';}

public override string ToString(){return ("TermStats: Term=" + termtext.Utf8ToString() + " DocFreq=" + DocFreq + " TotalTermFreq=" + TotalTermFreq);}

[User] public String toString() {return "TermStats{" +"decodedTermText='" + decodedTermText + '\'' +", field='" + field + '\'' +", docFreq=" + docFreq +'}';}

[Assistant] public override string ToString(){return ("TermStats: Term=" + termtext.Utf8ToString() + " DocFreq=" + DocFreq + " TotalTermFreq=" + TotalTermFreq);}


public String getSignificantDecimalDigitsLastDigitRounded() {long wp = _wholePart + 5; StringBuilder sb = new StringBuilder(24);sb.append(wp);sb.setCharAt(sb.length()-1, '0');return sb.toString();}

public String GetSignificantDecimalDigitsLastDigitRounded(){long wp = _wholePart + 5; StringBuilder sb = new StringBuilder(24);sb.Append(wp);sb[sb.Length - 1]= '0';return sb.ToString();}

[User] public String getSignificantDecimalDigitsLastDigitRounded() {long wp = _wholePart + 5; StringBuilder sb = new StringBuilder(24);sb.append(wp);sb.setCharAt(sb.length()-1, '0');return sb.toString();}

[Assistant] public String GetSignificantDecimalDigitsLastDigitRounded(){long wp = _wholePart + 5; StringBuilder sb = new StringBuilder(24);sb.Append(wp);sb[sb.Length - 1]= '0';return sb.ToString();}


public boolean canReuse(IndexInput docIn, FieldInfo fieldInfo) {return docIn == startDocIn &&indexHasFreq == (fieldInfo.getIndexOptions().compareTo(IndexOptions.DOCS_AND_FREQS) >= 0) &&indexHasPos == (fieldInfo.getIndexOptions().compareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0) &&indexHasPayloads == fieldInfo.hasPayloads();}

public bool CanReuse(IndexInput docIn, FieldInfo fieldInfo){return docIn == startDocIn &&indexHasFreq == (fieldInfo.IndexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS) >= 0) &&indexHasPos == (fieldInfo.IndexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0) &&indexHasPayloads == fieldInfo.HasPayloads;}

[User] public boolean canReuse(IndexInput docIn, FieldInfo fieldInfo) {return docIn == startDocIn &&indexHasFreq == (fieldInfo.getIndexOptions().compareTo(IndexOptions.DOCS_AND_FREQS) >= 0) &&indexHasPos == (fieldInfo.getIndexOptions().compareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0) &&indexHasPayloads == fieldInfo.hasPayloads();}

[Assistant] public bool CanReuse(IndexInput docIn, FieldInfo fieldInfo){return docIn == startDocIn &&indexHasFreq == (fieldInfo.IndexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS) >= 0) &&indexHasPos == (fieldInfo.IndexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0) &&indexHasPayloads == fieldInfo.HasPayloads;}


public Sort(SortField field) {setSort(field);}

[User] public Sort(SortField field) {setSort(field);}

[Assistant] public Sort(SortField field){SetSort(field);}


public static byte[] encodeASCII(String s) {final byte[] r = new byte[s.length()];for (int k = r.length - 1; k >= 0; k--) {final char c = s.charAt(k);if (c > 127)throw new IllegalArgumentException(MessageFormat.format(JGitText.get().notASCIIString, s));r[k] = (byte) c;}return r;}

public static byte[] EncodeASCII(string s){byte[] r = new byte[s.Length];for (int k = r.Length - 1; k >= 0; k--){char c = s[k];if (c > 127){throw new ArgumentException(MessageFormat.Format(JGitText.Get().notASCIIString, s));}r[k] = unchecked((byte)c);}return r;}

[User] public static byte[] encodeASCII(String s) {final byte[] r = new byte[s.length()];for (int k = r.length - 1; k >= 0; k--) {final char c = s.charAt(k);if (c > 127)throw new IllegalArgumentException(MessageFormat.format(JGitText.get().notASCIIString, s));r[k] = (byte) c;}return r;}

[Assistant] public static byte[] EncodeASCII(string s){byte[] r = new byte[s.Length];for (int k = r.Length - 1; k >= 0; k--){char c = s[k];if (c > 127){throw new ArgumentException(MessageFormat.Format(JGitText.Get().notASCIIString, s));}r[k] = unchecked((byte)c);}return r;}


public PurgeQueueResult purgeQueue(PurgeQueueRequest request) {request = beforeClientExecution(request);return executePurgeQueue(request);}

public virtual PurgeQueueResponse PurgeQueue(PurgeQueueRequest request){var options = new InvokeOptions();options.RequestMarshaller = PurgeQueueRequestMarshaller.Instance;options.ResponseUnmarshaller = PurgeQueueResponseUnmarshaller.Instance;return Invoke<PurgeQueueResponse>(request, options);}

[User] public PurgeQueueResult purgeQueue(PurgeQueueRequest request) {request = beforeClientExecution(request);return executePurgeQueue(request);}

[Assistant] public virtual PurgeQueueResponse PurgeQueue(PurgeQueueRequest request){var options = new InvokeOptions();options.RequestMarshaller = PurgeQueueRequestMarshaller.Instance;options.ResponseUnmarshaller = PurgeQueueResponseUnmarshaller.Instance;return Invoke<PurgeQueueResponse>(request, options);}


public boolean sempred(RuleContext _localctx, int ruleIndex, int actionIndex) {return true;}

public virtual bool Sempred(RuleContext _localctx, int ruleIndex, int actionIndex){return true;}

[User] public boolean sempred(RuleContext _localctx, int ruleIndex, int actionIndex) {return true;}

[Assistant] public virtual bool Sempred(RuleContext _localctx, int ruleIndex, int actionIndex){return true;}


public ListStreamsResult listStreams() {return listStreams(new ListStreamsRequest());}

public virtual ListStreamsResponse ListStreams(){return ListStreams(new ListStreamsRequest());}

[User] public ListStreamsResult listStreams() {return listStreams(new ListStreamsRequest());}

[Assistant] public virtual ListStreamsResponse ListStreams(){return ListStreams(new ListStreamsRequest());}


public String getSurfaceFormString() {return new String(surfaceForm, offset, length);}

public virtual string GetSurfaceFormString(){return new string(surfaceForm, offset, length);}

[User] public String getSurfaceFormString() {return new String(surfaceForm, offset, length);}

[Assistant] public virtual string GetSurfaceFormString(){return new string(surfaceForm, offset, length);}


public GetVaultNotificationsResult getVaultNotifications(GetVaultNotificationsRequest request) {request = beforeClientExecution(request);return executeGetVaultNotifications(request);}

public virtual GetVaultNotificationsResponse GetVaultNotifications(GetVaultNotificationsRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetVaultNotificationsRequestMarshaller.Instance;options.ResponseUnmarshaller = GetVaultNotificationsResponseUnmarshaller.Instance;return Invoke<GetVaultNotificationsResponse>(request, options);}

[User] public GetVaultNotificationsResult getVaultNotifications(GetVaultNotificationsRequest request) {request = beforeClientExecution(request);return executeGetVaultNotifications(request);}

[Assistant] public virtual GetVaultNotificationsResponse GetVaultNotifications(GetVaultNotificationsRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetVaultNotificationsRequestMarshaller.Instance;options.ResponseUnmarshaller = GetVaultNotificationsResponseUnmarshaller.Instance;return Invoke<GetVaultNotificationsResponse>(request, options);}


public DeleteTypedLinkFacetResult deleteTypedLinkFacet(DeleteTypedLinkFacetRequest request) {request = beforeClientExecution(request);return executeDeleteTypedLinkFacet(request);}

public virtual DeleteTypedLinkFacetResponse DeleteTypedLinkFacet(DeleteTypedLinkFacetRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteTypedLinkFacetRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteTypedLinkFacetResponseUnmarshaller.Instance;return Invoke<DeleteTypedLinkFacetResponse>(request, options);}

[User] public DeleteTypedLinkFacetResult deleteTypedLinkFacet(DeleteTypedLinkFacetRequest request) {request = beforeClientExecution(request);return executeDeleteTypedLinkFacet(request);}

[Assistant] public virtual DeleteTypedLinkFacetResponse DeleteTypedLinkFacet(DeleteTypedLinkFacetRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteTypedLinkFacetRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteTypedLinkFacetResponseUnmarshaller.Instance;return Invoke<DeleteTypedLinkFacetResponse>(request, options);}


public int previousIndex() {return pos;}

public int previousIndex(){return this.pos;}

[User] public int previousIndex() {return pos;}

[Assistant] public int previousIndex(){return this.pos;}


public long ramBytesUsed() {return super.ramBytesUsed()+ offsets.ramBytesUsed()+ lengths.ramBytesUsed()+ RamUsageEstimator.NUM_BYTES_OBJECT_HEADER+ 2 * Integer.BYTES+ 3 * RamUsageEstimator.NUM_BYTES_OBJECT_REF+ values.bytes().length;}

public long RamBytesUsed(){return RamUsageEstimator.AlignObjectSize(3 * RamUsageEstimator.NUM_BYTES_OBJECT_REF) + docIDs.RamBytesUsed() + offsets.RamBytesUsed();}

[User] public long ramBytesUsed() {return super.ramBytesUsed()+ offsets.ramBytesUsed()+ lengths.ramBytesUsed()+ RamUsageEstimator.NUM_BYTES_OBJECT_HEADER+ 2 * Integer.BYTES+ 3 * RamUsageEstimator.NUM_BYTES_OBJECT_REF+ values.bytes().length;}

[Assistant] public long RamBytesUsed(){return RamUsageEstimator.AlignObjectSize(3 * RamUsageEstimator.NUM_BYTES_OBJECT_REF) + docIDs.RamBytesUsed() + offsets.RamBytesUsed();}


public PushCommand push() {return new PushCommand(repo);}

public virtual PushCommand Push(){return new PushCommand(repo);}

[User] public PushCommand push() {return new PushCommand(repo);}

[Assistant] public virtual PushCommand Push(){return new PushCommand(repo);}


public SelectResult select(SelectRequest request) {request = beforeClientExecution(request);return executeSelect(request);}

public virtual SelectResponse Select(SelectRequest request){var options = new InvokeOptions();options.RequestMarshaller = SelectRequestMarshaller.Instance;options.ResponseUnmarshaller = SelectResponseUnmarshaller.Instance;return Invoke<SelectResponse>(request, options);}

[User] public SelectResult select(SelectRequest request) {request = beforeClientExecution(request);return executeSelect(request);}

[Assistant] public virtual SelectResponse Select(SelectRequest request){var options = new InvokeOptions();options.RequestMarshaller = SelectRequestMarshaller.Instance;options.ResponseUnmarshaller = SelectResponseUnmarshaller.Instance;return Invoke<SelectResponse>(request, options);}


public ByteArrayDataOutput(byte[] bytes) {reset(bytes);}

[User] public ByteArrayDataOutput(byte[] bytes) {reset(bytes);}

[Assistant] public ByteArrayDataOutput(byte[] bytes){Reset(bytes);}


public boolean renameTo(String newName) {return directory.renameTo(newName);}

public bool RenameTo(string newName){return directory.RenameTo(newName);}

[User] public boolean renameTo(String newName) {return directory.renameTo(newName);}

[Assistant] public bool RenameTo(string newName){return directory.RenameTo(newName);}


public boolean canReuse(IndexInput docIn, FieldInfo fieldInfo) {return docIn == startDocIn &&indexHasOffsets == (fieldInfo.getIndexOptions().compareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS) >= 0) &&indexHasPayloads == fieldInfo.hasPayloads();}

public bool CanReuse(IndexInput docIn, FieldInfo fieldInfo){return docIn == startDocIn &&indexHasOffsets == (fieldInfo.IndexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS) >= 0) &&indexHasPayloads == fieldInfo.HasPayloads;}

[User] public boolean canReuse(IndexInput docIn, FieldInfo fieldInfo) {return docIn == startDocIn &&indexHasOffsets == (fieldInfo.getIndexOptions().compareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS) >= 0) &&indexHasPayloads == fieldInfo.hasPayloads();}

[Assistant] public bool CanReuse(IndexInput docIn, FieldInfo fieldInfo){return docIn == startDocIn &&indexHasOffsets == (fieldInfo.IndexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS) >= 0) &&indexHasPayloads == fieldInfo.HasPayloads;}


public boolean equals( Object o ) {return o instanceof DanishStemmer;}

public override bool Equals(object o){return o is DanishStemmer;}

[User] public boolean equals( Object o ) {return o instanceof DanishStemmer;}

[Assistant] public override bool Equals(object o){return o is DanishStemmer;}