public ActivityTaskStatus recordActivityTaskHeartbeat(RecordActivityTaskHeartbeatRequest request) {request = beforeClientExecution(request);return executeRecordActivityTaskHeartbeat(request);}

public virtual RecordActivityTaskHeartbeatResponse RecordActivityTaskHeartbeat(RecordActivityTaskHeartbeatRequest request){var options = new InvokeOptions();options.RequestMarshaller = RecordActivityTaskHeartbeatRequestMarshaller.Instance;options.ResponseUnmarshaller = RecordActivityTaskHeartbeatResponseUnmarshaller.Instance;return Invoke<RecordActivityTaskHeartbeatResponse>(request, options);}

[User] public ActivityTaskStatus recordActivityTaskHeartbeat(RecordActivityTaskHeartbeatRequest request) {request = beforeClientExecution(request);return executeRecordActivityTaskHeartbeat(request);}

[Assistant] public virtual RecordActivityTaskHeartbeatResponse RecordActivityTaskHeartbeat(RecordActivityTaskHeartbeatRequest request){var options = new InvokeOptions();options.RequestMarshaller = RecordActivityTaskHeartbeatRequestMarshaller.Instance;options.ResponseUnmarshaller = RecordActivityTaskHeartbeatResponseUnmarshaller.Instance;return Invoke<RecordActivityTaskHeartbeatResponse>(request, options);}


public DescribeStepResult describeStep(DescribeStepRequest request) {request = beforeClientExecution(request);return executeDescribeStep(request);}

public virtual DescribeStepResponse DescribeStep(DescribeStepRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeStepRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeStepResponseUnmarshaller.Instance;return Invoke<DescribeStepResponse>(request, options);}

[User] public DescribeStepResult describeStep(DescribeStepRequest request) {request = beforeClientExecution(request);return executeDescribeStep(request);}

[Assistant] public virtual DescribeStepResponse DescribeStep(DescribeStepRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeStepRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeStepResponseUnmarshaller.Instance;return Invoke<DescribeStepResponse>(request, options);}


public DeleteMessageBatchResult deleteMessageBatch(String queueUrl, java.util.List<DeleteMessageBatchRequestEntry> entries) {return deleteMessageBatch(new DeleteMessageBatchRequest().withQueueUrl(queueUrl).withEntries(entries));}

public virtual DeleteMessageBatchResponse DeleteMessageBatch(string queueUrl, List<DeleteMessageBatchRequestEntry> entries){var request = new DeleteMessageBatchRequest();request.QueueUrl = queueUrl;request.Entries = entries;return DeleteMessageBatch(request);}

[User] public DeleteMessageBatchResult deleteMessageBatch(String queueUrl, java.util.List<DeleteMessageBatchRequestEntry> entries) {return deleteMessageBatch(new DeleteMessageBatchRequest().withQueueUrl(queueUrl).withEntries(entries));}

[Assistant] public virtual DeleteMessageBatchResponse DeleteMessageBatch(string queueUrl, List<DeleteMessageBatchRequestEntry> entries){var request = new DeleteMessageBatchRequest();request.QueueUrl = queueUrl;request.Entries = entries;return DeleteMessageBatch(request);}


public QueryScorer(Query query, IndexReader reader, String field) {init(query, field, reader, true);}

public QueryScorer(Query query, IndexReader reader, string field){Init(query, field, reader, true);}

[User] public QueryScorer(Query query, IndexReader reader, String field) {init(query, field, reader, true);}

[Assistant] public QueryScorer(Query query, IndexReader reader, string field){Init(query, field, reader, true);}


public CreateVpcPeeringAuthorizationResult createVpcPeeringAuthorization(CreateVpcPeeringAuthorizationRequest request) {request = beforeClientExecution(request);return executeCreateVpcPeeringAuthorization(request);}

public virtual CreateVpcPeeringAuthorizationResponse CreateVpcPeeringAuthorization(CreateVpcPeeringAuthorizationRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateVpcPeeringAuthorizationRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateVpcPeeringAuthorizationResponseUnmarshaller.Instance;return Invoke<CreateVpcPeeringAuthorizationResponse>(request, options);}

[User] public CreateVpcPeeringAuthorizationResult createVpcPeeringAuthorization(CreateVpcPeeringAuthorizationRequest request) {request = beforeClientExecution(request);return executeCreateVpcPeeringAuthorization(request);}

[Assistant] public virtual CreateVpcPeeringAuthorizationResponse CreateVpcPeeringAuthorization(CreateVpcPeeringAuthorizationRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateVpcPeeringAuthorizationRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateVpcPeeringAuthorizationResponseUnmarshaller.Instance;return Invoke<CreateVpcPeeringAuthorizationResponse>(request, options);}


public boolean contains(Object object) {if (object != null) {for (E element : a) {if (object.equals(element)) {return true;}}} else {for (E element : a) {if (element == null) {return true;}}}return false;}

public override bool contains(object @object){if (@object != null){foreach (E element in a){if (@object.Equals(element)){return true;}}}else{foreach (E element in a){if ((object)element == null){return true;}}}return false;}

[User] public boolean contains(Object object) {if (object != null) {for (E element : a) {if (object.equals(element)) {return true;}}} else {for (E element : a) {if (element == null) {return true;}}}return false;}

[Assistant] public override bool contains(object @object){if (@object != null){foreach (E element in a){if (@object.Equals(element)){return true;}}}else{foreach (E element in a){if ((object)element == null){return true;}}}return false;}


public DescribeDBSubnetGroupsResult describeDBSubnetGroups(DescribeDBSubnetGroupsRequest request) {request = beforeClientExecution(request);return executeDescribeDBSubnetGroups(request);}

public virtual DescribeDBSubnetGroupsResponse DescribeDBSubnetGroups(DescribeDBSubnetGroupsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeDBSubnetGroupsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeDBSubnetGroupsResponseUnmarshaller.Instance;return Invoke<DescribeDBSubnetGroupsResponse>(request, options);}

[User] public DescribeDBSubnetGroupsResult describeDBSubnetGroups(DescribeDBSubnetGroupsRequest request) {request = beforeClientExecution(request);return executeDescribeDBSubnetGroups(request);}

[Assistant] public virtual DescribeDBSubnetGroupsResponse DescribeDBSubnetGroups(DescribeDBSubnetGroupsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeDBSubnetGroupsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeDBSubnetGroupsResponseUnmarshaller.Instance;return Invoke<DescribeDBSubnetGroupsResponse>(request, options);}


public JobFlowExecutionStatusDetail(JobFlowExecutionState state, java.util.Date creationDateTime) {setState(state.toString());setCreationDateTime(creationDateTime);}

public JobFlowExecutionStatusDetail(JobFlowExecutionState state, DateTime creationDateTime){_state = state;_creationDateTime = creationDateTime;}

[User] public JobFlowExecutionStatusDetail(JobFlowExecutionState state, java.util.Date creationDateTime) {setState(state.toString());setCreationDateTime(creationDateTime);}

[Assistant] public JobFlowExecutionStatusDetail(JobFlowExecutionState state, DateTime creationDateTime){_state = state;_creationDateTime = creationDateTime;}


public String toString() {return "more";}

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

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

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


public KeyValue(String key, String value) {setKey(key);setValue(value);}

public KeyValue(string key, string value){_key = key;_value = value;}

[User] public KeyValue(String key, String value) {setKey(key);setValue(value);}

[Assistant] public KeyValue(string key, string value){_key = key;_value = value;}


public void balancedTree(Object[] tokens, Object[] vals, int lo, int hi,TernaryTreeNode root) {if (lo > hi) return;int mid = (lo + hi) / 2;root = insert(root, (String) tokens[mid], vals[mid], 0);balancedTree(tokens, vals, lo, mid - 1, root);balancedTree(tokens, vals, mid + 1, hi, root);}

public virtual void BalancedTree(object[] tokens, object[] vals, int lo, int hi, TernaryTreeNode root){if (lo > hi){return;}int mid = (lo + hi) / 2;root = Insert(root, (string)tokens[mid], vals[mid], 0);BalancedTree(tokens, vals, lo, mid - 1, root);BalancedTree(tokens, vals, mid + 1, hi, root);}

[User] public void balancedTree(Object[] tokens, Object[] vals, int lo, int hi,TernaryTreeNode root) {if (lo > hi) return;int mid = (lo + hi) / 2;root = insert(root, (String) tokens[mid], vals[mid], 0);balancedTree(tokens, vals, lo, mid - 1, root);balancedTree(tokens, vals, mid + 1, hi, root);}

[Assistant] public virtual void BalancedTree(object[] tokens, object[] vals, int lo, int hi, TernaryTreeNode root){if (lo > hi){return;}int mid = (lo + hi) / 2;root = Insert(root, (string)tokens[mid], vals[mid], 0);BalancedTree(tokens, vals, lo, mid - 1, root);BalancedTree(tokens, vals, mid + 1, hi, root);}


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

public override Object Clone(){PlotAreaRecord rec = new PlotAreaRecord();return rec;}

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

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


public DeleteSecurityConfigurationResult deleteSecurityConfiguration(DeleteSecurityConfigurationRequest request) {request = beforeClientExecution(request);return executeDeleteSecurityConfiguration(request);}

public virtual DeleteSecurityConfigurationResponse DeleteSecurityConfiguration(DeleteSecurityConfigurationRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteSecurityConfigurationRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteSecurityConfigurationResponseUnmarshaller.Instance;return Invoke<DeleteSecurityConfigurationResponse>(request, options);}

[User] public DeleteSecurityConfigurationResult deleteSecurityConfiguration(DeleteSecurityConfigurationRequest request) {request = beforeClientExecution(request);return executeDeleteSecurityConfiguration(request);}

[Assistant] public virtual DeleteSecurityConfigurationResponse DeleteSecurityConfiguration(DeleteSecurityConfigurationRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteSecurityConfigurationRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteSecurityConfigurationResponseUnmarshaller.Instance;return Invoke<DeleteSecurityConfigurationResponse>(request, options);}


@Override public String toString() {return mapEntry.toString();}

public override string ToString(){return mapEntry.ToString();}

[User] @Override public String toString() {return mapEntry.toString();}

[Assistant] public override string ToString(){return mapEntry.ToString();}


public byte[] getCachedBytes(int sizeLimit) throws LargeObjectException,MissingObjectException, IOException {if (!isLarge())return getCachedBytes();try (ObjectStream in = openStream()) {long sz = in.getSize();if (sizeLimit < sz)throw new LargeObjectException.ExceedsLimit(sizeLimit, sz);if (Integer.MAX_VALUE < sz)throw new LargeObjectException.ExceedsByteArrayLimit();byte[] buf;try {buf = new byte[(int) sz];} catch (OutOfMemoryError notEnoughHeap) {throw new LargeObjectException.OutOfMemory(notEnoughHeap);}IO.readFully(in, buf, 0, buf.length);return buf;}}

public virtual byte[] GetCachedBytes(int sizeLimit){if (!IsLarge()){return GetCachedBytes();}ObjectStream @in = OpenStream();try{long sz = @in.GetSize();if (sizeLimit < sz){throw new LargeObjectException.ExceedsLimit(sizeLimit, sz);}if (int.MaxValue < sz){throw new LargeObjectException.ExceedsByteArrayLimit();}byte[] buf;try{buf = new byte[(int)sz];}catch (OutOfMemoryException notEnoughHeap){throw new LargeObjectException.OutOfMemory(notEnoughHeap);}IOUtil.ReadFully(@in, buf, 0, buf.Length);return buf;}finally{@in.Close();}}

[User] public byte[] getCachedBytes(int sizeLimit) throws LargeObjectException,MissingObjectException, IOException {if (!isLarge())return getCachedBytes();try (ObjectStream in = openStream()) {long sz = in.getSize();if (sizeLimit < sz)throw new LargeObjectException.ExceedsLimit(sizeLimit, sz);if (Integer.MAX_VALUE < sz)throw new LargeObjectException.ExceedsByteArrayLimit();byte[] buf;try {buf = new byte[(int) sz];} catch (OutOfMemoryError notEnoughHeap) {throw new LargeObjectException.OutOfMemory(notEnoughHeap);}IO.readFully(in, buf, 0, buf.length);return buf;}}

[Assistant] public virtual byte[] GetCachedBytes(int sizeLimit){if (!IsLarge()){return GetCachedBytes();}ObjectStream @in = OpenStream();try{long sz = @in.GetSize();if (sizeLimit < sz){throw new LargeObjectException.ExceedsLimit(sizeLimit, sz);}if (int.MaxValue < sz){throw new LargeObjectException.ExceedsByteArrayLimit();}byte[] buf;try{buf = new byte[(int)sz];}catch (OutOfMemoryException notEnoughHeap){throw new LargeObjectException.OutOfMemory(notEnoughHeap);}IOUtil.ReadFully(@in, buf, 0, buf.Length);return buf;}finally{@in.Close();}}


public ListJobsByStatusResult listJobsByStatus(ListJobsByStatusRequest request) {request = beforeClientExecution(request);return executeListJobsByStatus(request);}

public virtual ListJobsByStatusResponse ListJobsByStatus(ListJobsByStatusRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListJobsByStatusRequestMarshaller.Instance;options.ResponseUnmarshaller = ListJobsByStatusResponseUnmarshaller.Instance;return Invoke<ListJobsByStatusResponse>(request, options);}

[User] public ListJobsByStatusResult listJobsByStatus(ListJobsByStatusRequest request) {request = beforeClientExecution(request);return executeListJobsByStatus(request);}

[Assistant] public virtual ListJobsByStatusResponse ListJobsByStatus(ListJobsByStatusRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListJobsByStatusRequestMarshaller.Instance;options.ResponseUnmarshaller = ListJobsByStatusResponseUnmarshaller.Instance;return Invoke<ListJobsByStatusResponse>(request, options);}


public UpdateClusterVersionResult updateClusterVersion(UpdateClusterVersionRequest request) {request = beforeClientExecution(request);return executeUpdateClusterVersion(request);}

public virtual UpdateClusterVersionResponse UpdateClusterVersion(UpdateClusterVersionRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateClusterVersionRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateClusterVersionResponseUnmarshaller.Instance;return Invoke<UpdateClusterVersionResponse>(request, options);}

[User] public UpdateClusterVersionResult updateClusterVersion(UpdateClusterVersionRequest request) {request = beforeClientExecution(request);return executeUpdateClusterVersion(request);}

[Assistant] public virtual UpdateClusterVersionResponse UpdateClusterVersion(UpdateClusterVersionRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateClusterVersionRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateClusterVersionResponseUnmarshaller.Instance;return Invoke<UpdateClusterVersionResponse>(request, options);}


public PushCommand setForce(boolean force) {checkCallable();this.force = force;return this;}

public virtual NGit.Api.PushCommand SetForce(bool force){CheckCallable();this.force = force;return this;}

[User] public PushCommand setForce(boolean force) {checkCallable();this.force = force;return this;}

[Assistant] public virtual NGit.Api.PushCommand SetForce(bool force){CheckCallable();this.force = force;return this;}


public ListStreamsResult listStreams(ListStreamsRequest request) {request = beforeClientExecution(request);return executeListStreams(request);}

public virtual ListStreamsResponse ListStreams(ListStreamsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListStreamsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListStreamsResponseUnmarshaller.Instance;return Invoke<ListStreamsResponse>(request, options);}

[User] public ListStreamsResult listStreams(ListStreamsRequest request) {request = beforeClientExecution(request);return executeListStreams(request);}

[Assistant] public virtual ListStreamsResponse ListStreams(ListStreamsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListStreamsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListStreamsResponseUnmarshaller.Instance;return Invoke<ListStreamsResponse>(request, options);}


public boolean wasEscaped(int index) {return this.wasEscaped[index];}

public bool WasEscaped(int index){return this.wasEscaped[index];}

[User] public boolean wasEscaped(int index) {return this.wasEscaped[index];}

[Assistant] public bool WasEscaped(int index){return this.wasEscaped[index];}


public void setNewObjectId(AnyObjectId id) {newValue = id.copy();}

public virtual void SetNewObjectId(AnyObjectId id){newValue = id.Copy();}

[User] public void setNewObjectId(AnyObjectId id) {newValue = id.copy();}

[Assistant] public virtual void SetNewObjectId(AnyObjectId id){newValue = id.Copy();}


public BatchRefUpdate newBatchUpdate() {return new BatchRefUpdate(this);}

public virtual BatchRefUpdate NewBatchUpdate(){return new BatchRefUpdate(this);}

[User] public BatchRefUpdate newBatchUpdate() {return new BatchRefUpdate(this);}

[Assistant] public virtual BatchRefUpdate NewBatchUpdate(){return new BatchRefUpdate(this);}


public String toString() {return getClass().getSimpleName() + "(fields=" + fields.size() + ",delegate=" + postingsReader + ")";}

public override string ToString(){return "arc=" + arc + " state=" + state;}

[User] public String toString() {return getClass().getSimpleName() + "(fields=" + fields.size() + ",delegate=" + postingsReader + ")";}

[Assistant] public override string ToString(){return "arc=" + arc + " state=" + state;}


public CreateTrafficMirrorFilterRuleResult createTrafficMirrorFilterRule(CreateTrafficMirrorFilterRuleRequest request) {request = beforeClientExecution(request);return executeCreateTrafficMirrorFilterRule(request);}

public virtual CreateTrafficMirrorFilterRuleResponse CreateTrafficMirrorFilterRule(CreateTrafficMirrorFilterRuleRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateTrafficMirrorFilterRuleRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateTrafficMirrorFilterRuleResponseUnmarshaller.Instance;return Invoke<CreateTrafficMirrorFilterRuleResponse>(request, options);}

[User] public CreateTrafficMirrorFilterRuleResult createTrafficMirrorFilterRule(CreateTrafficMirrorFilterRuleRequest request) {request = beforeClientExecution(request);return executeCreateTrafficMirrorFilterRule(request);}

[Assistant] public virtual CreateTrafficMirrorFilterRuleResponse CreateTrafficMirrorFilterRule(CreateTrafficMirrorFilterRuleRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateTrafficMirrorFilterRuleRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateTrafficMirrorFilterRuleResponseUnmarshaller.Instance;return Invoke<CreateTrafficMirrorFilterRuleResponse>(request, options);}


public SendEventResult sendEvent(SendEventRequest request) {request = beforeClientExecution(request);return executeSendEvent(request);}

public virtual SendEventResponse SendEvent(SendEventRequest request){var options = new InvokeOptions();options.RequestMarshaller = SendEventRequestMarshaller.Instance;options.ResponseUnmarshaller = SendEventResponseUnmarshaller.Instance;return Invoke<SendEventResponse>(request, options);}

[User] public SendEventResult sendEvent(SendEventRequest request) {request = beforeClientExecution(request);return executeSendEvent(request);}

[Assistant] public virtual SendEventResponse SendEvent(SendEventRequest request){var options = new InvokeOptions();options.RequestMarshaller = SendEventRequestMarshaller.Instance;options.ResponseUnmarshaller = SendEventResponseUnmarshaller.Instance;return Invoke<SendEventResponse>(request, options);}


public MissingRowDummyRecord(int rowNumber) {this.rowNumber = rowNumber;}

public MissingRowDummyRecord(int rowNumber){this.rowNumber = rowNumber;}

[User] public MissingRowDummyRecord(int rowNumber) {this.rowNumber = rowNumber;}

[Assistant] public MissingRowDummyRecord(int rowNumber){this.rowNumber = rowNumber;}


public final int getLengthB() {return endB - beginB;}

public int GetLengthB(){return endB - beginB;}

[User] public final int getLengthB() {return endB - beginB;}

[Assistant] public int GetLengthB(){return endB - beginB;}


public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {for (int i = 0; i < iterations; ++i) {final long block = blocks[blocksOffset++];for (int shift = 63; shift >= 0; shift -= 1) {values[valuesOffset++] = (int) ((block >>> shift) & 1);}}}

public override void Decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations){for (int i = 0; i < iterations; ++i){long block = blocks[blocksOffset++];for (int shift = 63; shift >= 0; shift -= 1){values[valuesOffset++] = (int)(((long)((ulong)block >> shift)) & 1);}}}

[User] public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {for (int i = 0; i < iterations; ++i) {final long block = blocks[blocksOffset++];for (int shift = 63; shift >= 0; shift -= 1) {values[valuesOffset++] = (int) ((block >>> shift) & 1);}}}

[Assistant] public override void Decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations){for (int i = 0; i < iterations; ++i){long block = blocks[blocksOffset++];for (int shift = 63; shift >= 0; shift -= 1){values[valuesOffset++] = (int)(((long)((ulong)block >> shift)) & 1);}}}


public void writeInt(int value) throws IOException {checkWritePrimitiveTypes();primitiveTypes.writeInt(value);}

public virtual void writeInt(int value){throw new System.NotImplementedException();}

[User] public void writeInt(int value) throws IOException {checkWritePrimitiveTypes();primitiveTypes.writeInt(value);}

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


public ByteBuffer putInt(int index, int value) {throw new ReadOnlyBufferException();}

public override java.nio.ByteBuffer putInt(int index, int value){throw new System.NotImplementedException();}

[User] public ByteBuffer putInt(int index, int value) {throw new ReadOnlyBufferException();}

[Assistant] public override java.nio.ByteBuffer putInt(int index, int value){throw new System.NotImplementedException();}


public K next() {return super.nextEntry().getKey();}

public override K next(){return this.nextEntry().key;}

[User] public K next() {return super.nextEntry().getKey();}

[Assistant] public override K next(){return this.nextEntry().key;}


public RenameDetectionType getRenameDetectionType() {return renameDetectionType;}

public virtual DiffConfig.RenameDetectionType GetRenameDetectionType(){return renameDetectionType;}

[User] public RenameDetectionType getRenameDetectionType() {return renameDetectionType;}

[Assistant] public virtual DiffConfig.RenameDetectionType GetRenameDetectionType(){return renameDetectionType;}


public ReplaceNetworkAclAssociationResult replaceNetworkAclAssociation(ReplaceNetworkAclAssociationRequest request) {request = beforeClientExecution(request);return executeReplaceNetworkAclAssociation(request);}

public virtual ReplaceNetworkAclAssociationResponse ReplaceNetworkAclAssociation(ReplaceNetworkAclAssociationRequest request){var options = new InvokeOptions();options.RequestMarshaller = ReplaceNetworkAclAssociationRequestMarshaller.Instance;options.ResponseUnmarshaller = ReplaceNetworkAclAssociationResponseUnmarshaller.Instance;return Invoke<ReplaceNetworkAclAssociationResponse>(request, options);}

[User] public ReplaceNetworkAclAssociationResult replaceNetworkAclAssociation(ReplaceNetworkAclAssociationRequest request) {request = beforeClientExecution(request);return executeReplaceNetworkAclAssociation(request);}

[Assistant] public virtual ReplaceNetworkAclAssociationResponse ReplaceNetworkAclAssociation(ReplaceNetworkAclAssociationRequest request){var options = new InvokeOptions();options.RequestMarshaller = ReplaceNetworkAclAssociationRequestMarshaller.Instance;options.ResponseUnmarshaller = ReplaceNetworkAclAssociationResponseUnmarshaller.Instance;return Invoke<ReplaceNetworkAclAssociationResponse>(request, options);}


public String getFontName(){return _fontName;}

public String GetFontName(){return fontName;}

[User] public String getFontName(){return _fontName;}

[Assistant] public String GetFontName(){return fontName;}


public ViewSourceRecord(RecordInputStream in) {vs = in.readShort();}

public ViewSourceRecord(RecordInputStream in1){vs = in1.ReadShort();}

[User] public ViewSourceRecord(RecordInputStream in) {vs = in.readShort();}

[Assistant] public ViewSourceRecord(RecordInputStream in1){vs = in1.ReadShort();}


public boolean hasTrackingRefUpdate() {return trackingRefUpdate != null;}

public virtual bool HasTrackingRefUpdate(){return trackingRefUpdate != null;}

[User] public boolean hasTrackingRefUpdate() {return trackingRefUpdate != null;}

[Assistant] public virtual bool HasTrackingRefUpdate(){return trackingRefUpdate != null;}


public boolean matches(int symbol, int minVocabSymbol, int maxVocabSymbol) {return set.contains(symbol);}

public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol){return set.Contains(symbol);}

[User] public boolean matches(int symbol, int minVocabSymbol, int maxVocabSymbol) {return set.contains(symbol);}

[Assistant] public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol){return set.Contains(symbol);}


public ValueEval evaluate(EvaluationCell srcCell) {int sheetIndex = getSheetIndex(srcCell.getSheet());return evaluateAny(srcCell, sheetIndex, srcCell.getRowIndex(), srcCell.getColumnIndex(), new EvaluationTracker(_cache));}

public ValueEval Evaluate(IEvaluationCell srcCell){int sheetIndex = GetSheetIndex(srcCell.Sheet);return EvaluateAny(srcCell, sheetIndex, srcCell.RowIndex, srcCell.ColumnIndex, new EvaluationTracker(_cache));}

[User] public ValueEval evaluate(EvaluationCell srcCell) {int sheetIndex = getSheetIndex(srcCell.getSheet());return evaluateAny(srcCell, sheetIndex, srcCell.getRowIndex(), srcCell.getColumnIndex(), new EvaluationTracker(_cache));}

[Assistant] public ValueEval Evaluate(IEvaluationCell srcCell){int sheetIndex = GetSheetIndex(srcCell.Sheet);return EvaluateAny(srcCell, sheetIndex, srcCell.RowIndex, srcCell.ColumnIndex, new EvaluationTracker(_cache));}


public AcceptTransitGatewayVpcAttachmentResult acceptTransitGatewayVpcAttachment(AcceptTransitGatewayVpcAttachmentRequest request) {request = beforeClientExecution(request);return executeAcceptTransitGatewayVpcAttachment(request);}

public virtual AcceptTransitGatewayVpcAttachmentResponse AcceptTransitGatewayVpcAttachment(AcceptTransitGatewayVpcAttachmentRequest request){var options = new InvokeOptions();options.RequestMarshaller = AcceptTransitGatewayVpcAttachmentRequestMarshaller.Instance;options.ResponseUnmarshaller = AcceptTransitGatewayVpcAttachmentResponseUnmarshaller.Instance;return Invoke<AcceptTransitGatewayVpcAttachmentResponse>(request, options);}

[User] public AcceptTransitGatewayVpcAttachmentResult acceptTransitGatewayVpcAttachment(AcceptTransitGatewayVpcAttachmentRequest request) {request = beforeClientExecution(request);return executeAcceptTransitGatewayVpcAttachment(request);}

[Assistant] public virtual AcceptTransitGatewayVpcAttachmentResponse AcceptTransitGatewayVpcAttachment(AcceptTransitGatewayVpcAttachmentRequest request){var options = new InvokeOptions();options.RequestMarshaller = AcceptTransitGatewayVpcAttachmentRequestMarshaller.Instance;options.ResponseUnmarshaller = AcceptTransitGatewayVpcAttachmentResponseUnmarshaller.Instance;return Invoke<AcceptTransitGatewayVpcAttachmentResponse>(request, options);}


public String toString() {return "<opaque schema='" + this.schema + "' value='" + this.value + "'/>";}

public override string ToString(){return "<opaque schema='" + this.schema + "' value='" + this.value + "'/>";}

[User] public String toString() {return "<opaque schema='" + this.schema + "' value='" + this.value + "'/>";}

[Assistant] public override string ToString(){return "<opaque schema='" + this.schema + "' value='" + this.value + "'/>";}


public static FuzzySet createSetBasedOnQuality(int maxNumUniqueValues, float desiredMaxSaturation){int setSize=getNearestSetSize(maxNumUniqueValues,desiredMaxSaturation);return new FuzzySet(new FixedBitSet(setSize+1),setSize, hashFunctionForVersion(VERSION_CURRENT));}

public static FuzzySet CreateSetBasedOnQuality(int maxNumUniqueValues, float desiredMaxSaturation){var setSize = GetNearestSetSize(maxNumUniqueValues, desiredMaxSaturation);return new FuzzySet(new FixedBitSet(setSize + 1), setSize, HashFunctionForVersion(VERSION_CURRENT));}

[User] public static FuzzySet createSetBasedOnQuality(int maxNumUniqueValues, float desiredMaxSaturation){int setSize=getNearestSetSize(maxNumUniqueValues,desiredMaxSaturation);return new FuzzySet(new FixedBitSet(setSize+1),setSize, hashFunctionForVersion(VERSION_CURRENT));}

[Assistant] public static FuzzySet CreateSetBasedOnQuality(int maxNumUniqueValues, float desiredMaxSaturation){var setSize = GetNearestSetSize(maxNumUniqueValues, desiredMaxSaturation);return new FuzzySet(new FixedBitSet(setSize + 1), setSize, HashFunctionForVersion(VERSION_CURRENT));}


public DeregisterInstancesFromLoadBalancerRequest(String loadBalancerName, java.util.List<Instance> instances) {setLoadBalancerName(loadBalancerName);setInstances(instances);}

public DeregisterInstancesFromLoadBalancerRequest(string loadBalancerName, List<Instance> instances){_loadBalancerName = loadBalancerName;_instances = instances;}

[User] public DeregisterInstancesFromLoadBalancerRequest(String loadBalancerName, java.util.List<Instance> instances) {setLoadBalancerName(loadBalancerName);setInstances(instances);}

[Assistant] public DeregisterInstancesFromLoadBalancerRequest(string loadBalancerName, List<Instance> instances){_loadBalancerName = loadBalancerName;_instances = instances;}


public DeleteIntegrationResult deleteIntegration(DeleteIntegrationRequest request) {request = beforeClientExecution(request);return executeDeleteIntegration(request);}

public virtual DeleteIntegrationResponse DeleteIntegration(DeleteIntegrationRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteIntegrationRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteIntegrationResponseUnmarshaller.Instance;return Invoke<DeleteIntegrationResponse>(request, options);}

[User] public DeleteIntegrationResult deleteIntegration(DeleteIntegrationRequest request) {request = beforeClientExecution(request);return executeDeleteIntegration(request);}

[Assistant] public virtual DeleteIntegrationResponse DeleteIntegration(DeleteIntegrationRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteIntegrationRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteIntegrationResponseUnmarshaller.Instance;return Invoke<DeleteIntegrationResponse>(request, options);}


public Ref3DPtg(LittleEndianInput in)  {field_1_index_extern_sheet = in.readShort();readCoordinates(in);}

public Ref3DPtg(ILittleEndianInput in1){field_1_index_extern_sheet = in1.ReadShort();ReadCoordinates(in1);}

[User] public Ref3DPtg(LittleEndianInput in)  {field_1_index_extern_sheet = in.readShort();readCoordinates(in);}

[Assistant] public Ref3DPtg(ILittleEndianInput in1){field_1_index_extern_sheet = in1.ReadShort();ReadCoordinates(in1);}


public synchronized E peek() {try {return (E) elementData[elementCount - 1];} catch (IndexOutOfBoundsException e) {throw new EmptyStackException();}}

public virtual E peek(){lock (this){try{return (E)elementData[elementCount - 1];}catch (System.IndexOutOfRangeException){throw new java.util.EmptyStackException();}}}

[User] public synchronized E peek() {try {return (E) elementData[elementCount - 1];} catch (IndexOutOfBoundsException e) {throw new EmptyStackException();}}

[Assistant] public virtual E peek(){lock (this){try{return (E)elementData[elementCount - 1];}catch (System.IndexOutOfRangeException){throw new java.util.EmptyStackException();}}}


public CheckDomainTransferabilityResult checkDomainTransferability(CheckDomainTransferabilityRequest request) {request = beforeClientExecution(request);return executeCheckDomainTransferability(request);}

public virtual CheckDomainTransferabilityResponse CheckDomainTransferability(CheckDomainTransferabilityRequest request){var options = new InvokeOptions();options.RequestMarshaller = CheckDomainTransferabilityRequestMarshaller.Instance;options.ResponseUnmarshaller = CheckDomainTransferabilityResponseUnmarshaller.Instance;return Invoke<CheckDomainTransferabilityResponse>(request, options);}

[User] public CheckDomainTransferabilityResult checkDomainTransferability(CheckDomainTransferabilityRequest request) {request = beforeClientExecution(request);return executeCheckDomainTransferability(request);}

[Assistant] public virtual CheckDomainTransferabilityResponse CheckDomainTransferability(CheckDomainTransferabilityRequest request){var options = new InvokeOptions();options.RequestMarshaller = CheckDomainTransferabilityRequestMarshaller.Instance;options.ResponseUnmarshaller = CheckDomainTransferabilityResponseUnmarshaller.Instance;return Invoke<CheckDomainTransferabilityResponse>(request, options);}


@Override public Iterator<K> iterator() {return new MultisetKeyIterator();}

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

[User] @Override public Iterator<K> iterator() {return new MultisetKeyIterator();}

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


public InitiateJobResult initiateJob(InitiateJobRequest request) {request = beforeClientExecution(request);return executeInitiateJob(request);}

public virtual InitiateJobResponse InitiateJob(InitiateJobRequest request){var options = new InvokeOptions();options.RequestMarshaller = InitiateJobRequestMarshaller.Instance;options.ResponseUnmarshaller = InitiateJobResponseUnmarshaller.Instance;return Invoke<InitiateJobResponse>(request, options);}

[User] public InitiateJobResult initiateJob(InitiateJobRequest request) {request = beforeClientExecution(request);return executeInitiateJob(request);}

[Assistant] public virtual InitiateJobResponse InitiateJob(InitiateJobRequest request){var options = new InvokeOptions();options.RequestMarshaller = InitiateJobRequestMarshaller.Instance;options.ResponseUnmarshaller = InitiateJobResponseUnmarshaller.Instance;return Invoke<InitiateJobResponse>(request, options);}


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

public StempelPolishStemFilterFactory(IDictionary<string, string> args): base(args){if (args.Any()){throw new ArgumentException("Unknown parameters: " + args);}}

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

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


public void removeLastAuthor() {remove1stProperty(PropertyIDMap.PID_LASTAUTHOR);}

public void RemoveLastAuthor(){MutableSection s = (MutableSection)FirstSection;s.RemoveProperty(PropertyIDMap.PID_LASTAUTHOR);}

[User] public void removeLastAuthor() {remove1stProperty(PropertyIDMap.PID_LASTAUTHOR);}

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


public void decRef() {final int rc = refCount.decrementAndGet();assert rc >= 0: "seg=" + info;}

public virtual void DecRef(){int rc = refCount.DecrementAndGet();Debug.Assert(rc >= 0);}

[User] public void decRef() {final int rc = refCount.decrementAndGet();assert rc >= 0: "seg=" + info;}

[Assistant] public virtual void DecRef(){int rc = refCount.DecrementAndGet();Debug.Assert(rc >= 0);}


public String toString() {return "<fuzzy field='" + this.field + "' similarity='" + this.similarity+ "' term='" + this.text + "'/>";}

public override string ToString(){return "<fuzzy field='" + this.m_field + "' similarity='" + this.similarity+ "' term='" + this.m_text + "'/>";}

[User] public String toString() {return "<fuzzy field='" + this.field + "' similarity='" + this.similarity+ "' term='" + this.text + "'/>";}

[Assistant] public override string ToString(){return "<fuzzy field='" + this.m_field + "' similarity='" + this.similarity+ "' term='" + this.m_text + "'/>";}


public static void putCompressedUnicode(String input, LittleEndianOutput out) {byte[] bytes = input.getBytes(ISO_8859_1);out.write(bytes);}

public static void PutCompressedUnicode(String input, ILittleEndianOutput out1){byte[] bytes = ISO_8859_1.GetBytes(input);out1.Write(bytes);}

[User] public static void putCompressedUnicode(String input, LittleEndianOutput out) {byte[] bytes = input.getBytes(ISO_8859_1);out.write(bytes);}

[Assistant] public static void PutCompressedUnicode(String input, ILittleEndianOutput out1){byte[] bytes = ISO_8859_1.GetBytes(input);out1.Write(bytes);}


public void append(final BytesRef bytes) {int bytesLeft = bytes.length;int offset = bytes.offset;while (bytesLeft > 0) {int bufferLeft = BYTE_BLOCK_SIZE - byteUpto;if (bytesLeft < bufferLeft) {System.arraycopy(bytes.bytes, offset, buffer, byteUpto, bytesLeft);byteUpto += bytesLeft;break;} else {if (bufferLeft > 0) {System.arraycopy(bytes.bytes, offset, buffer, byteUpto, bufferLeft);}nextBuffer();bytesLeft -= bufferLeft;offset += bufferLeft;}}}

public void Append(BytesRef bytes){var length = bytes.Length;if (length == 0){return;}int offset = bytes.Offset;int overflow = (length + ByteUpto) - BYTE_BLOCK_SIZE;do{if (overflow <= 0){Array.Copy(bytes.Bytes, offset, buffer, ByteUpto, length);ByteUpto += length;break;}else{int bytesToCopy = length - overflow;if (bytesToCopy > 0){Array.Copy(bytes.Bytes, offset, buffer, ByteUpto, bytesToCopy);offset += bytesToCopy;length -= bytesToCopy;}NextBuffer();overflow = overflow - BYTE_BLOCK_SIZE;}} while (true);}

[User] public void append(final BytesRef bytes) {int bytesLeft = bytes.length;int offset = bytes.offset;while (bytesLeft > 0) {int bufferLeft = BYTE_BLOCK_SIZE - byteUpto;if (bytesLeft < bufferLeft) {System.arraycopy(bytes.bytes, offset, buffer, byteUpto, bytesLeft);byteUpto += bytesLeft;break;} else {if (bufferLeft > 0) {System.arraycopy(bytes.bytes, offset, buffer, byteUpto, bufferLeft);}nextBuffer();bytesLeft -= bufferLeft;offset += bufferLeft;}}}

[Assistant] public void Append(BytesRef bytes){var length = bytes.Length;if (length == 0){return;}int offset = bytes.Offset;int overflow = (length + ByteUpto) - BYTE_BLOCK_SIZE;do{if (overflow <= 0){Array.Copy(bytes.Bytes, offset, buffer, ByteUpto, length);ByteUpto += length;break;}else{int bytesToCopy = length - overflow;if (bytesToCopy > 0){Array.Copy(bytes.Bytes, offset, buffer, ByteUpto, bytesToCopy);offset += bytesToCopy;length -= bytesToCopy;}NextBuffer();overflow = overflow - BYTE_BLOCK_SIZE;}} while (true);}


public GetBundlesResult getBundles(GetBundlesRequest request) {request = beforeClientExecution(request);return executeGetBundles(request);}

public virtual GetBundlesResponse GetBundles(GetBundlesRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetBundlesRequestMarshaller.Instance;options.ResponseUnmarshaller = GetBundlesResponseUnmarshaller.Instance;return Invoke<GetBundlesResponse>(request, options);}

[User] public GetBundlesResult getBundles(GetBundlesRequest request) {request = beforeClientExecution(request);return executeGetBundles(request);}

[Assistant] public virtual GetBundlesResponse GetBundles(GetBundlesRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetBundlesRequestMarshaller.Instance;options.ResponseUnmarshaller = GetBundlesResponseUnmarshaller.Instance;return Invoke<GetBundlesResponse>(request, options);}


public StopAssessmentRunResult stopAssessmentRun(StopAssessmentRunRequest request) {request = beforeClientExecution(request);return executeStopAssessmentRun(request);}

public virtual StopAssessmentRunResponse StopAssessmentRun(StopAssessmentRunRequest request){var options = new InvokeOptions();options.RequestMarshaller = StopAssessmentRunRequestMarshaller.Instance;options.ResponseUnmarshaller = StopAssessmentRunResponseUnmarshaller.Instance;return Invoke<StopAssessmentRunResponse>(request, options);}

[User] public StopAssessmentRunResult stopAssessmentRun(StopAssessmentRunRequest request) {request = beforeClientExecution(request);return executeStopAssessmentRun(request);}

[Assistant] public virtual StopAssessmentRunResponse StopAssessmentRun(StopAssessmentRunRequest request){var options = new InvokeOptions();options.RequestMarshaller = StopAssessmentRunRequestMarshaller.Instance;options.ResponseUnmarshaller = StopAssessmentRunResponseUnmarshaller.Instance;return Invoke<StopAssessmentRunResponse>(request, options);}


public CreateFolderResult createFolder(CreateFolderRequest request) {request = beforeClientExecution(request);return executeCreateFolder(request);}

public virtual CreateFolderResponse CreateFolder(CreateFolderRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateFolderRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateFolderResponseUnmarshaller.Instance;return Invoke<CreateFolderResponse>(request, options);}

[User] public CreateFolderResult createFolder(CreateFolderRequest request) {request = beforeClientExecution(request);return executeCreateFolder(request);}

[Assistant] public virtual CreateFolderResponse CreateFolder(CreateFolderRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateFolderRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateFolderResponseUnmarshaller.Instance;return Invoke<CreateFolderResponse>(request, options);}


public ChangeResourceRecordSetsRequest(String hostedZoneId, ChangeBatch changeBatch) {setHostedZoneId(hostedZoneId);setChangeBatch(changeBatch);}

public ChangeResourceRecordSetsRequest(string hostedZoneId, ChangeBatch changeBatch){_hostedZoneId = hostedZoneId;_changeBatch = changeBatch;}

[User] public ChangeResourceRecordSetsRequest(String hostedZoneId, ChangeBatch changeBatch) {setHostedZoneId(hostedZoneId);setChangeBatch(changeBatch);}

[Assistant] public ChangeResourceRecordSetsRequest(string hostedZoneId, ChangeBatch changeBatch){_hostedZoneId = hostedZoneId;_changeBatch = changeBatch;}


public CreateDeploymentStrategyResult createDeploymentStrategy(CreateDeploymentStrategyRequest request) {request = beforeClientExecution(request);return executeCreateDeploymentStrategy(request);}

public virtual CreateDeploymentStrategyResponse CreateDeploymentStrategy(CreateDeploymentStrategyRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateDeploymentStrategyRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateDeploymentStrategyResponseUnmarshaller.Instance;return Invoke<CreateDeploymentStrategyResponse>(request, options);}

[User] public CreateDeploymentStrategyResult createDeploymentStrategy(CreateDeploymentStrategyRequest request) {request = beforeClientExecution(request);return executeCreateDeploymentStrategy(request);}

[Assistant] public virtual CreateDeploymentStrategyResponse CreateDeploymentStrategy(CreateDeploymentStrategyRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateDeploymentStrategyRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateDeploymentStrategyResponseUnmarshaller.Instance;return Invoke<CreateDeploymentStrategyResponse>(request, options);}


public DeleteCacheClusterRequest(String cacheClusterId) {setCacheClusterId(cacheClusterId);}

public DeleteCacheClusterRequest(string cacheClusterId){_cacheClusterId = cacheClusterId;}

[User] public DeleteCacheClusterRequest(String cacheClusterId) {setCacheClusterId(cacheClusterId);}

[Assistant] public DeleteCacheClusterRequest(string cacheClusterId){_cacheClusterId = cacheClusterId;}


public final ValueEval evaluate(ValueEval[] args, int srcRowIndex, int srcColumnIndex) {switch (args.length) {case 2:return evaluate(srcRowIndex, srcColumnIndex, args[0], args[1]);case 3:return evaluate(srcRowIndex, srcColumnIndex, args[0], args[1], args[2]);}return ErrorEval.VALUE_INVALID;}

public ValueEval Evaluate(ValueEval[] args, int srcRowIndex, int srcColumnIndex){switch (args.Length){case 2:return Evaluate(srcRowIndex, srcColumnIndex, args[0], args[1]);case 3:return Evaluate(srcRowIndex, srcColumnIndex, args[0], args[1], args[2]);}return ErrorEval.VALUE_INVALID;}

[User] public final ValueEval evaluate(ValueEval[] args, int srcRowIndex, int srcColumnIndex) {switch (args.length) {case 2:return evaluate(srcRowIndex, srcColumnIndex, args[0], args[1]);case 3:return evaluate(srcRowIndex, srcColumnIndex, args[0], args[1], args[2]);}return ErrorEval.VALUE_INVALID;}

[Assistant] public ValueEval Evaluate(ValueEval[] args, int srcRowIndex, int srcColumnIndex){switch (args.Length){case 2:return Evaluate(srcRowIndex, srcColumnIndex, args[0], args[1]);case 3:return Evaluate(srcRowIndex, srcColumnIndex, args[0], args[1], args[2]);}return ErrorEval.VALUE_INVALID;}


public GroupingSearch setAllGroupHeads(boolean allGroupHeads) {this.allGroupHeads = allGroupHeads;return this;}

public virtual GroupingSearch SetAllGroupHeads(bool allGroupHeads){this.allGroupHeads = allGroupHeads;return this;}

[User] public GroupingSearch setAllGroupHeads(boolean allGroupHeads) {this.allGroupHeads = allGroupHeads;return this;}

[Assistant] public virtual GroupingSearch SetAllGroupHeads(bool allGroupHeads){this.allGroupHeads = allGroupHeads;return this;}


public String dequote(String in) {final byte[] b = Constants.encode(in);return dequote(b, 0, b.length);}

public virtual string Dequote(string @in){byte[] b = Constants.Encode(@in);return Dequote(b, 0, b.Length);}

[User] public String dequote(String in) {final byte[] b = Constants.encode(in);return dequote(b, 0, b.length);}

[Assistant] public virtual string Dequote(string @in){byte[] b = Constants.Encode(@in);return Dequote(b, 0, b.Length);}


public boolean isEmpty() {return entrySet().isEmpty();}

public override bool IsEmpty(){return EntrySet().IsEmpty();}

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

[Assistant] public override bool IsEmpty(){return EntrySet().IsEmpty();}


public Query makeLuceneQueryFieldNoBoost(String fieldName, BasicQueryFactory qf) {return SrndBooleanQuery.makeBooleanQuery( makeLuceneSubQueriesField(fieldName, qf), BooleanClause.Occur.MUST);}

public override Search.Query MakeLuceneQueryFieldNoBoost(string fieldName, BasicQueryFactory qf){return SrndBooleanQuery.MakeBooleanQuery( MakeLuceneSubQueriesField(fieldName, qf), Occur.MUST);}

[User] public Query makeLuceneQueryFieldNoBoost(String fieldName, BasicQueryFactory qf) {return SrndBooleanQuery.makeBooleanQuery( makeLuceneSubQueriesField(fieldName, qf), BooleanClause.Occur.MUST);}

[Assistant] public override Search.Query MakeLuceneQueryFieldNoBoost(string fieldName, BasicQueryFactory qf){return SrndBooleanQuery.MakeBooleanQuery( MakeLuceneSubQueriesField(fieldName, qf), Occur.MUST);}


public long getSize() {return data.length;}

public override long GetSize(){return data.Length;}

[User] public long getSize() {return data.length;}

[Assistant] public override long GetSize(){return data.Length;}


public CreatePhoneNumberOrderResult createPhoneNumberOrder(CreatePhoneNumberOrderRequest request) {request = beforeClientExecution(request);return executeCreatePhoneNumberOrder(request);}

public virtual CreatePhoneNumberOrderResponse CreatePhoneNumberOrder(CreatePhoneNumberOrderRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreatePhoneNumberOrderRequestMarshaller.Instance;options.ResponseUnmarshaller = CreatePhoneNumberOrderResponseUnmarshaller.Instance;return Invoke<CreatePhoneNumberOrderResponse>(request, options);}

[User] public CreatePhoneNumberOrderResult createPhoneNumberOrder(CreatePhoneNumberOrderRequest request) {request = beforeClientExecution(request);return executeCreatePhoneNumberOrder(request);}

[Assistant] public virtual CreatePhoneNumberOrderResponse CreatePhoneNumberOrder(CreatePhoneNumberOrderRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreatePhoneNumberOrderRequestMarshaller.Instance;options.ResponseUnmarshaller = CreatePhoneNumberOrderResponseUnmarshaller.Instance;return Invoke<CreatePhoneNumberOrderResponse>(request, options);}


public ShortBuffer get(short[] dst, int dstOffset, int shortCount) {byteBuffer.limit(limit * SizeOf.SHORT);byteBuffer.position(position * SizeOf.SHORT);if (byteBuffer instanceof DirectByteBuffer) {((DirectByteBuffer) byteBuffer).get(dst, dstOffset, shortCount);} else {((HeapByteBuffer) byteBuffer).get(dst, dstOffset, shortCount);}this.position += shortCount;return this;}

public override java.nio.ShortBuffer get(short[] dst, int dstOffset, int shortCount){byteBuffer.limit(_limit * libcore.io.SizeOf.SHORT);byteBuffer.position(_position * libcore.io.SizeOf.SHORT);if (byteBuffer is java.nio.DirectByteBuffer){((java.nio.DirectByteBuffer)byteBuffer).get(dst, dstOffset, shortCount);}else{((java.nio.HeapByteBuffer)byteBuffer).get(dst, dstOffset, shortCount);}this._position += shortCount;return this;}

[User] public ShortBuffer get(short[] dst, int dstOffset, int shortCount) {byteBuffer.limit(limit * SizeOf.SHORT);byteBuffer.position(position * SizeOf.SHORT);if (byteBuffer instanceof DirectByteBuffer) {((DirectByteBuffer) byteBuffer).get(dst, dstOffset, shortCount);} else {((HeapByteBuffer) byteBuffer).get(dst, dstOffset, shortCount);}this.position += shortCount;return this;}

[Assistant] public override java.nio.ShortBuffer get(short[] dst, int dstOffset, int shortCount){byteBuffer.limit(_limit * libcore.io.SizeOf.SHORT);byteBuffer.position(_position * libcore.io.SizeOf.SHORT);if (byteBuffer is java.nio.DirectByteBuffer){((java.nio.DirectByteBuffer)byteBuffer).get(dst, dstOffset, shortCount);}else{((java.nio.HeapByteBuffer)byteBuffer).get(dst, dstOffset, shortCount);}this._position += shortCount;return this;}


public DetectModerationLabelsResult detectModerationLabels(DetectModerationLabelsRequest request) {request = beforeClientExecution(request);return executeDetectModerationLabels(request);}

public virtual DetectModerationLabelsResponse DetectModerationLabels(DetectModerationLabelsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DetectModerationLabelsRequestMarshaller.Instance;options.ResponseUnmarshaller = DetectModerationLabelsResponseUnmarshaller.Instance;return Invoke<DetectModerationLabelsResponse>(request, options);}

[User] public DetectModerationLabelsResult detectModerationLabels(DetectModerationLabelsRequest request) {request = beforeClientExecution(request);return executeDetectModerationLabels(request);}

[Assistant] public virtual DetectModerationLabelsResponse DetectModerationLabels(DetectModerationLabelsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DetectModerationLabelsRequestMarshaller.Instance;options.ResponseUnmarshaller = DetectModerationLabelsResponseUnmarshaller.Instance;return Invoke<DetectModerationLabelsResponse>(request, options);}


public UncalcedRecord(RecordInputStream in) {_reserved = in.readShort(); }

public UncalcedRecord(RecordInputStream in1){_reserved = in1.ReadShort();}

[User] public UncalcedRecord(RecordInputStream in) {_reserved = in.readShort(); }

[Assistant] public UncalcedRecord(RecordInputStream in1){_reserved = in1.ReadShort();}


public String handlePart(Matcher m, String part, CellFormatType type,StringBuffer desc) {int pos = desc.length();char firstCh = part.charAt(0);switch (firstCh) {case '[':if (part.length() < 3)break;if (topmost != null)throw new IllegalArgumentException("Duplicate '[' times in format");part = part.toLowerCase(Locale.ROOT);int specLen = part.length() - 2;topmost = assignSpec(part.charAt(1), pos, specLen);return part.substring(1, 1 + specLen);case 'h':case 'm':case 's':case '0':part = part.toLowerCase(Locale.ROOT);assignSpec(part.charAt(0), pos, part.length());return part;case '\n':return "%n";case '\"':part = part.substring(1, part.length() - 1);break;case '\\':part = part.substring(1);break;case '*':if (part.length() > 1)part = CellFormatPart.expandChar(part);break;case '_':return null;}return PERCENTS.matcher(part).replaceAll("%%");}

public String HandlePart(Match m, String part, CellFormatType type,StringBuilder desc){int pos = desc.Length;char firstCh = part[0];switch (firstCh){case '[':if (part.Length < 3)break;if (_formatter.topmost != null)throw new ArgumentException("Duplicate '[' times in format");part = part.ToLower();int specLen = part.Length - 2;_formatter.topmost = _formatter.AssignSpec(part[1], pos, specLen);return part.Substring(1, specLen);case 'h':case 'm':case 's':case '0':part = part.ToLower();_formatter.AssignSpec(part[0], pos, part.Length);return part;case '\n':return "%n";case '\"':part = part.Substring(1, part.Length - 2);break;case '\\':part = part.Substring(1);break;case '*':if (part.Length > 1)part = CellFormatPart.ExpandChar(part);break;case '_':return null;}return part;}

[User] public String handlePart(Matcher m, String part, CellFormatType type,StringBuffer desc) {int pos = desc.length();char firstCh = part.charAt(0);switch (firstCh) {case '[':if (part.length() < 3)break;if (topmost != null)throw new IllegalArgumentException("Duplicate '[' times in format");part = part.toLowerCase(Locale.ROOT);int specLen = part.length() - 2;topmost = assignSpec(part.charAt(1), pos, specLen);return part.substring(1, 1 + specLen);case 'h':case 'm':case 's':case '0':part = part.toLowerCase(Locale.ROOT);assignSpec(part.charAt(0), pos, part.length());return part;case '\n':return "%n";case '\"':part = part.substring(1, part.length() - 1);break;case '\\':part = part.substring(1);break;case '*':if (part.length() > 1)part = CellFormatPart.expandChar(part);break;case '_':return null;}return PERCENTS.matcher(part).replaceAll("%%");}

[Assistant] public String HandlePart(Match m, String part, CellFormatType type,StringBuilder desc){int pos = desc.Length;char firstCh = part[0];switch (firstCh){case '[':if (part.Length < 3)break;if (_formatter.topmost != null)throw new ArgumentException("Duplicate '[' times in format");part = part.ToLower();int specLen = part.Length - 2;_formatter.topmost = _formatter.AssignSpec(part[1], pos, specLen);return part.Substring(1, specLen);case 'h':case 'm':case 's':case '0':part = part.ToLower();_formatter.AssignSpec(part[0], pos, part.Length);return part;case '\n':return "%n";case '\"':part = part.Substring(1, part.Length - 2);break;case '\\':part = part.Substring(1);break;case '*':if (part.Length > 1)part = CellFormatPart.ExpandChar(part);break;case '_':return null;}return part;}


public long ramBytesUsed() {long sizeInBytes =  ((delegateFieldsProducer!=null) ? delegateFieldsProducer.ramBytesUsed() : 0);for(Map.Entry<String,FuzzySet> entry: bloomsByFieldName.entrySet()) {sizeInBytes += entry.getKey().length() * Character.BYTES;sizeInBytes += entry.getValue().ramBytesUsed();}return sizeInBytes;}

public override long RamBytesUsed(){var sizeInBytes = ((_delegateFieldsProducer != null) ? _delegateFieldsProducer.RamBytesUsed() : 0);foreach (var entry in _bloomsByFieldName){sizeInBytes += entry.Key.Length * RamUsageEstimator.NUM_BYTES_CHAR;sizeInBytes += entry.Value.RamBytesUsed();}return sizeInBytes;}

[User] public long ramBytesUsed() {long sizeInBytes =  ((delegateFieldsProducer!=null) ? delegateFieldsProducer.ramBytesUsed() : 0);for(Map.Entry<String,FuzzySet> entry: bloomsByFieldName.entrySet()) {sizeInBytes += entry.getKey().length() * Character.BYTES;sizeInBytes += entry.getValue().ramBytesUsed();}return sizeInBytes;}

[Assistant] public override long RamBytesUsed(){var sizeInBytes = ((_delegateFieldsProducer != null) ? _delegateFieldsProducer.RamBytesUsed() : 0);foreach (var entry in _bloomsByFieldName){sizeInBytes += entry.Key.Length * RamUsageEstimator.NUM_BYTES_CHAR;sizeInBytes += entry.Value.RamBytesUsed();}return sizeInBytes;}


public CreateImageRequest(String instanceId, String name) {setInstanceId(instanceId);setName(name);}

public CreateImageRequest(string instanceId, string name){_instanceId = instanceId;_name = name;}

[User] public CreateImageRequest(String instanceId, String name) {setInstanceId(instanceId);setName(name);}

[Assistant] public CreateImageRequest(string instanceId, string name){_instanceId = instanceId;_name = name;}


public SendDiagnosticInterruptResult sendDiagnosticInterrupt(SendDiagnosticInterruptRequest request) {request = beforeClientExecution(request);return executeSendDiagnosticInterrupt(request);}

public virtual SendDiagnosticInterruptResponse SendDiagnosticInterrupt(SendDiagnosticInterruptRequest request){var options = new InvokeOptions();options.RequestMarshaller = SendDiagnosticInterruptRequestMarshaller.Instance;options.ResponseUnmarshaller = SendDiagnosticInterruptResponseUnmarshaller.Instance;return Invoke<SendDiagnosticInterruptResponse>(request, options);}

[User] public SendDiagnosticInterruptResult sendDiagnosticInterrupt(SendDiagnosticInterruptRequest request) {request = beforeClientExecution(request);return executeSendDiagnosticInterrupt(request);}

[Assistant] public virtual SendDiagnosticInterruptResponse SendDiagnosticInterrupt(SendDiagnosticInterruptRequest request){var options = new InvokeOptions();options.RequestMarshaller = SendDiagnosticInterruptRequestMarshaller.Instance;options.ResponseUnmarshaller = SendDiagnosticInterruptResponseUnmarshaller.Instance;return Invoke<SendDiagnosticInterruptResponse>(request, options);}


public int lastIndexOf(Object object) {Object[] snapshot = elements;return lastIndexOf(object, snapshot, 0, snapshot.length);}

public virtual int lastIndexOf(object @object){object[] snapshot = elements;return lastIndexOf(@object, snapshot, 0, snapshot.Length);}

[User] public int lastIndexOf(Object object) {Object[] snapshot = elements;return lastIndexOf(object, snapshot, 0, snapshot.length);}

[Assistant] public virtual int lastIndexOf(object @object){object[] snapshot = elements;return lastIndexOf(@object, snapshot, 0, snapshot.Length);}


public AbortDocumentVersionUploadResult abortDocumentVersionUpload(AbortDocumentVersionUploadRequest request) {request = beforeClientExecution(request);return executeAbortDocumentVersionUpload(request);}

public virtual AbortDocumentVersionUploadResponse AbortDocumentVersionUpload(AbortDocumentVersionUploadRequest request){var options = new InvokeOptions();options.RequestMarshaller = AbortDocumentVersionUploadRequestMarshaller.Instance;options.ResponseUnmarshaller = AbortDocumentVersionUploadResponseUnmarshaller.Instance;return Invoke<AbortDocumentVersionUploadResponse>(request, options);}

[User] public AbortDocumentVersionUploadResult abortDocumentVersionUpload(AbortDocumentVersionUploadRequest request) {request = beforeClientExecution(request);return executeAbortDocumentVersionUpload(request);}

[Assistant] public virtual AbortDocumentVersionUploadResponse AbortDocumentVersionUpload(AbortDocumentVersionUploadRequest request){var options = new InvokeOptions();options.RequestMarshaller = AbortDocumentVersionUploadRequestMarshaller.Instance;options.ResponseUnmarshaller = AbortDocumentVersionUploadResponseUnmarshaller.Instance;return Invoke<AbortDocumentVersionUploadResponse>(request, options);}


public PaneInformation(short x, short y, short top, short left, byte active, boolean frozen) {this.x = x;this.y = y;this.topRow = top;this.leftColumn = left;this.activePane = active;this.frozen = frozen;}

public PaneInformation(short x, short y, short top, short left, byte active, bool frozen){this.x = x;this.y = y;this.topRow = top;this.leftColumn = left;this.activePane = active;this.frozen = frozen;}

[User] public PaneInformation(short x, short y, short top, short left, byte active, boolean frozen) {this.x = x;this.y = y;this.topRow = top;this.leftColumn = left;this.activePane = active;this.frozen = frozen;}

[Assistant] public PaneInformation(short x, short y, short top, short left, byte active, bool frozen){this.x = x;this.y = y;this.topRow = top;this.leftColumn = left;this.activePane = active;this.frozen = frozen;}


public DescribeScalingProcessTypesResult describeScalingProcessTypes(DescribeScalingProcessTypesRequest request) {request = beforeClientExecution(request);return executeDescribeScalingProcessTypes(request);}

public virtual DescribeScalingProcessTypesResponse DescribeScalingProcessTypes(DescribeScalingProcessTypesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeScalingProcessTypesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeScalingProcessTypesResponseUnmarshaller.Instance;return Invoke<DescribeScalingProcessTypesResponse>(request, options);}

[User] public DescribeScalingProcessTypesResult describeScalingProcessTypes(DescribeScalingProcessTypesRequest request) {request = beforeClientExecution(request);return executeDescribeScalingProcessTypes(request);}

[Assistant] public virtual DescribeScalingProcessTypesResponse DescribeScalingProcessTypes(DescribeScalingProcessTypesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeScalingProcessTypesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeScalingProcessTypesResponseUnmarshaller.Instance;return Invoke<DescribeScalingProcessTypesResponse>(request, options);}


public static boolean endsWith(char s[], int len, char suffix[]) {final int suffixLen = suffix.length;if (suffixLen > len)return false;for (int i = suffixLen - 1; i >= 0; i--)if (s[len -(suffixLen - i)] != suffix[i])return false;return true;}

public static bool EndsWith(char[] s, int len, char[] suffix){int suffixLen = suffix.Length;if (suffixLen > len){return false;}for (int i = suffixLen - 1; i >= 0; i--){if (s[len - (suffixLen - i)] != suffix[i]){return false;}}return true;}

[User] public static boolean endsWith(char s[], int len, char suffix[]) {final int suffixLen = suffix.length;if (suffixLen > len)return false;for (int i = suffixLen - 1; i >= 0; i--)if (s[len -(suffixLen - i)] != suffix[i])return false;return true;}

[Assistant] public static bool EndsWith(char[] s, int len, char[] suffix){int suffixLen = suffix.Length;if (suffixLen > len){return false;}for (int i = suffixLen - 1; i >= 0; i--){if (s[len - (suffixLen - i)] != suffix[i]){return false;}}return true;}


public void warnIfOpen() {if (allocationSite == null || !ENABLED) {return;}String message =("A resource was acquired at attached stack trace but never released. "+ "See java.io.Closeable for information on avoiding resource leaks.");REPORTER.report(message, allocationSite);}

public void warnIfOpen(){if (allocationSite == null || !ENABLED){return;}string message = ("A resource was acquired at attached stack trace but never released. "+ "See java.io.Closeable for information on avoiding resource leaks.");REPORTER.report(message, allocationSite);}

[User] public void warnIfOpen() {if (allocationSite == null || !ENABLED) {return;}String message =("A resource was acquired at attached stack trace but never released. "+ "See java.io.Closeable for information on avoiding resource leaks.");REPORTER.report(message, allocationSite);}

[Assistant] public void warnIfOpen(){if (allocationSite == null || !ENABLED){return;}string message = ("A resource was acquired at attached stack trace but never released. "+ "See java.io.Closeable for information on avoiding resource leaks.");REPORTER.report(message, allocationSite);}


public GetImageScanRequest() {super("cr", "2016-06-07", "GetImageScan", "cr");setUriPattern("/repos/[RepoNamespace]/[RepoName]/tags/[Tag]/scan");setMethod(MethodType.GET);}

public GetImageScanRequest(): base("cr", "2016-06-07", "GetImageScan", "cr", "openAPI"){UriPattern = "/repos/[RepoNamespace]/[RepoName]/tags/[Tag]/scan";Method = MethodType.GET;}

[User] public GetImageScanRequest() {super("cr", "2016-06-07", "GetImageScan", "cr");setUriPattern("/repos/[RepoNamespace]/[RepoName]/tags/[Tag]/scan");setMethod(MethodType.GET);}

[Assistant] public GetImageScanRequest(): base("cr", "2016-06-07", "GetImageScan", "cr", "openAPI"){UriPattern = "/repos/[RepoNamespace]/[RepoName]/tags/[Tag]/scan";Method = MethodType.GET;}


public ListSkillsStoreCategoriesResult listSkillsStoreCategories(ListSkillsStoreCategoriesRequest request) {request = beforeClientExecution(request);return executeListSkillsStoreCategories(request);}

public virtual ListSkillsStoreCategoriesResponse ListSkillsStoreCategories(ListSkillsStoreCategoriesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListSkillsStoreCategoriesRequestMarshaller.Instance;options.ResponseUnmarshaller = ListSkillsStoreCategoriesResponseUnmarshaller.Instance;return Invoke<ListSkillsStoreCategoriesResponse>(request, options);}

[User] public ListSkillsStoreCategoriesResult listSkillsStoreCategories(ListSkillsStoreCategoriesRequest request) {request = beforeClientExecution(request);return executeListSkillsStoreCategories(request);}

[Assistant] public virtual ListSkillsStoreCategoriesResponse ListSkillsStoreCategories(ListSkillsStoreCategoriesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListSkillsStoreCategoriesRequestMarshaller.Instance;options.ResponseUnmarshaller = ListSkillsStoreCategoriesResponseUnmarshaller.Instance;return Invoke<ListSkillsStoreCategoriesResponse>(request, options);}


public int getHeight() {return mImage.getHeight();}

public virtual int getHeight(){return mBitmap.getHeight();}

[User] public int getHeight() {return mImage.getHeight();}

[Assistant] public virtual int getHeight(){return mBitmap.getHeight();}


public void applyFont(Font font) {applyFont(0, _string.getCharCount(), font);}

public void ApplyFont(short fontIndex){ApplyFont(0, _string.CharCount, fontIndex);}

[User] public void applyFont(Font font) {applyFont(0, _string.getCharCount(), font);}

[Assistant] public void ApplyFont(short fontIndex){ApplyFont(0, _string.CharCount, fontIndex);}


public DetectEntitiesResult detectEntities(DetectEntitiesRequest request) {request = beforeClientExecution(request);return executeDetectEntities(request);}

public virtual DetectEntitiesResponse DetectEntities(DetectEntitiesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DetectEntitiesRequestMarshaller.Instance;options.ResponseUnmarshaller = DetectEntitiesResponseUnmarshaller.Instance;return Invoke<DetectEntitiesResponse>(request, options);}

[User] public DetectEntitiesResult detectEntities(DetectEntitiesRequest request) {request = beforeClientExecution(request);return executeDetectEntities(request);}

[Assistant] public virtual DetectEntitiesResponse DetectEntities(DetectEntitiesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DetectEntitiesRequestMarshaller.Instance;options.ResponseUnmarshaller = DetectEntitiesResponseUnmarshaller.Instance;return Invoke<DetectEntitiesResponse>(request, options);}


public void copyRawTo(ByteBuffer w) {w.putInt(w1);w.putInt(w2);w.putInt(w3);w.putInt(w4);w.putInt(w5);}

public virtual void CopyRawTo(ByteBuffer w){w.PutInt(w1);w.PutInt(w2);w.PutInt(w3);w.PutInt(w4);w.PutInt(w5);}

[User] public void copyRawTo(ByteBuffer w) {w.putInt(w1);w.putInt(w2);w.putInt(w3);w.putInt(w4);w.putInt(w5);}

[Assistant] public virtual void CopyRawTo(ByteBuffer w){w.PutInt(w1);w.PutInt(w2);w.PutInt(w3);w.PutInt(w4);w.PutInt(w5);}


public final char[] array() {return protectedArray();}

public sealed override object array(){return protectedArray();}

[User] public final char[] array() {return protectedArray();}

[Assistant] public sealed override object array(){return protectedArray();}


public void seekExact(long ord) throws IOException {if (indexEnum == null) {throw new IllegalStateException("terms index was not loaded");}assert ord < numTerms;in.seek(indexEnum.seek(ord));boolean result = nextBlock();assert result;indexIsCurrent = true;didIndexNext = false;seekPending = false;state.ord = indexEnum.ord()-1;assert state.ord >= -1: "ord=" + state.ord;term.copyBytes(indexEnum.term());int left = (int) (ord - state.ord);while(left > 0) {final BytesRef term = _next();assert term != null;left--;assert indexIsCurrent;}}

public override void SeekExact(long ord){if (indexEnum == null){throw new InvalidOperationException("terms index was not loaded");}Debug.Assert(ord < outerInstance.numTerms);input.Seek(indexEnum.Seek(ord));bool result = NextBlock();Debug.Assert(result);indexIsCurrent = true;didIndexNext = false;blocksSinceSeek = 0;seekPending = false;state.Ord = indexEnum.Ord - 1;Debug.Assert(state.Ord >= -1, "Ord=" + state.Ord);term.CopyBytes(indexEnum.Term);int left = (int)(ord - state.Ord);while (left > 0){BytesRef term = _next();Debug.Assert(term != null);left--;Debug.Assert(indexIsCurrent);}}

[User] public void seekExact(long ord) throws IOException {if (indexEnum == null) {throw new IllegalStateException("terms index was not loaded");}assert ord < numTerms;in.seek(indexEnum.seek(ord));boolean result = nextBlock();assert result;indexIsCurrent = true;didIndexNext = false;seekPending = false;state.ord = indexEnum.ord()-1;assert state.ord >= -1: "ord=" + state.ord;term.copyBytes(indexEnum.term());int left = (int) (ord - state.ord);while(left > 0) {final BytesRef term = _next();assert term != null;left--;assert indexIsCurrent;}}

[Assistant] public override void SeekExact(long ord){if (indexEnum == null){throw new InvalidOperationException("terms index was not loaded");}Debug.Assert(ord < outerInstance.numTerms);input.Seek(indexEnum.Seek(ord));bool result = NextBlock();Debug.Assert(result);indexIsCurrent = true;didIndexNext = false;blocksSinceSeek = 0;seekPending = false;state.Ord = indexEnum.Ord - 1;Debug.Assert(state.Ord >= -1, "Ord=" + state.Ord);term.CopyBytes(indexEnum.Term);int left = (int)(ord - state.Ord);while (left > 0){BytesRef term = _next();Debug.Assert(term != null);left--;Debug.Assert(indexIsCurrent);}}


public String toString() {StringBuilder sb = new StringBuilder();sb.append('[');final int end = offset + length;for(int i=offset;i<end;i++) {if (i > offset) {sb.append(' ');}sb.append(Integer.toHexString(bytes[i]&0xff));}sb.append(']');return sb.toString();}

public override string ToString(){StringBuilder sb = new StringBuilder();sb.Append('[');int end = Offset + Length;for (int i = Offset; i < end; i++){if (i > Offset){sb.Append(' ');}sb.Append((bytes[i] & 0xff).ToString("x"));}sb.Append(']');return sb.ToString();}

[User] public String toString() {StringBuilder sb = new StringBuilder();sb.append('[');final int end = offset + length;for(int i=offset;i<end;i++) {if (i > offset) {sb.append(' ');}sb.append(Integer.toHexString(bytes[i]&0xff));}sb.append(']');return sb.toString();}

[Assistant] public override string ToString(){StringBuilder sb = new StringBuilder();sb.Append('[');int end = Offset + Length;for (int i = Offset; i < end; i++){if (i > Offset){sb.Append(' ');}sb.Append((bytes[i] & 0xff).ToString("x"));}sb.Append(']');return sb.ToString();}


public String toString() {StringBuilder buffer = new StringBuilder();buffer.append(" [FEATURE PROTECTION]\n");buffer.append("   Self Relative = " + fSD);buffer.append("   Password Verifier = " + passwordVerifier);buffer.append("   Title = " + title);buffer.append("   Security Descriptor Size = " + securityDescriptor.length);buffer.append(" [/FEATURE PROTECTION]\n");return buffer.toString();}

public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append(" [FEATURE PROTECTION]\n");buffer.Append("   Self Relative = " + fSD);buffer.Append("   Password Verifier = " + passwordVerifier);buffer.Append("   Title = " + title);buffer.Append("   Security Descriptor Size = " + securityDescriptor.Length);buffer.Append(" [/FEATURE PROTECTION]\n");return buffer.ToString();}

[User] public String toString() {StringBuilder buffer = new StringBuilder();buffer.append(" [FEATURE PROTECTION]\n");buffer.append("   Self Relative = " + fSD);buffer.append("   Password Verifier = " + passwordVerifier);buffer.append("   Title = " + title);buffer.append("   Security Descriptor Size = " + securityDescriptor.length);buffer.append(" [/FEATURE PROTECTION]\n");return buffer.toString();}

[Assistant] public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append(" [FEATURE PROTECTION]\n");buffer.Append("   Self Relative = " + fSD);buffer.Append("   Password Verifier = " + passwordVerifier);buffer.Append("   Title = " + title);buffer.Append("   Security Descriptor Size = " + securityDescriptor.Length);buffer.Append(" [/FEATURE PROTECTION]\n");return buffer.ToString();}


public void setCRC(int crc32) {crc = crc32;}

public virtual void SetCRC(int crc32){crc = crc32;}

[User] public void setCRC(int crc32) {crc = crc32;}

[Assistant] public virtual void SetCRC(int crc32){crc = crc32;}


public DoubleRange(String label, double minIn, boolean minInclusive, double maxIn, boolean maxInclusive) {super(label);if (Double.isNaN(minIn)) {throw new IllegalArgumentException("min cannot be NaN");}if (!minInclusive) {minIn = Math.nextUp(minIn);}if (Double.isNaN(maxIn)) {throw new IllegalArgumentException("max cannot be NaN");}if (!maxInclusive) {maxIn = Math.nextAfter(maxIn, Double.NEGATIVE_INFINITY);}if (minIn > maxIn) {failNoMatch();}this.min = minIn;this.max = maxIn;}

public DoubleRange(string label, double minIn, bool minInclusive, double maxIn, bool maxInclusive): base(label){this.Min = minIn;this.Max = maxIn;this.MinInclusive = minInclusive;this.MaxInclusive = maxInclusive;if (double.IsNaN(Min)){throw new System.ArgumentException("min cannot be NaN");}if (!minInclusive){minIn += EPSILON;}if (double.IsNaN(Max)){throw new System.ArgumentException("max cannot be NaN");}if (!maxInclusive){maxIn = maxIn -= EPSILON;}if (minIn > maxIn){FailNoMatch();}this.minIncl = minIn;this.maxIncl = maxIn;}

[User] public DoubleRange(String label, double minIn, boolean minInclusive, double maxIn, boolean maxInclusive) {super(label);if (Double.isNaN(minIn)) {throw new IllegalArgumentException("min cannot be NaN");}if (!minInclusive) {minIn = Math.nextUp(minIn);}if (Double.isNaN(maxIn)) {throw new IllegalArgumentException("max cannot be NaN");}if (!maxInclusive) {maxIn = Math.nextAfter(maxIn, Double.NEGATIVE_INFINITY);}if (minIn > maxIn) {failNoMatch();}this.min = minIn;this.max = maxIn;}

[Assistant] public DoubleRange(string label, double minIn, bool minInclusive, double maxIn, bool maxInclusive): base(label){this.Min = minIn;this.Max = maxIn;this.MinInclusive = minInclusive;this.MaxInclusive = maxInclusive;if (double.IsNaN(Min)){throw new System.ArgumentException("min cannot be NaN");}if (!minInclusive){minIn += EPSILON;}if (double.IsNaN(Max)){throw new System.ArgumentException("max cannot be NaN");}if (!maxInclusive){maxIn = maxIn -= EPSILON;}if (minIn > maxIn){FailNoMatch();}this.minIncl = minIn;this.maxIncl = maxIn;}


public int getBATEntriesPerBlock() {return bigBlockSize / LittleEndianConsts.INT_SIZE;}

public int GetBATEntriesPerBlock(){return bigBlockSize / LittleEndianConsts.INT_SIZE;}

[User] public int getBATEntriesPerBlock() {return bigBlockSize / LittleEndianConsts.INT_SIZE;}

[Assistant] public int GetBATEntriesPerBlock(){return bigBlockSize / LittleEndianConsts.INT_SIZE;}


public CreatePublishingDestinationResult createPublishingDestination(CreatePublishingDestinationRequest request) {request = beforeClientExecution(request);return executeCreatePublishingDestination(request);}

public virtual CreatePublishingDestinationResponse CreatePublishingDestination(CreatePublishingDestinationRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreatePublishingDestinationRequestMarshaller.Instance;options.ResponseUnmarshaller = CreatePublishingDestinationResponseUnmarshaller.Instance;return Invoke<CreatePublishingDestinationResponse>(request, options);}

[User] public CreatePublishingDestinationResult createPublishingDestination(CreatePublishingDestinationRequest request) {request = beforeClientExecution(request);return executeCreatePublishingDestination(request);}

[Assistant] public virtual CreatePublishingDestinationResponse CreatePublishingDestination(CreatePublishingDestinationRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreatePublishingDestinationRequestMarshaller.Instance;options.ResponseUnmarshaller = CreatePublishingDestinationResponseUnmarshaller.Instance;return Invoke<CreatePublishingDestinationResponse>(request, options);}


public void skipBytes(long count) {pos += count;}

public override void SkipBytes(long count){pos += (int)count;}

[User] public void skipBytes(long count) {pos += count;}

[Assistant] public override void SkipBytes(long count){pos += (int)count;}


public String toString() {return "jarowinkler(" + threshold + ")";}

public override string ToString(){return "jarowinkler(" + threshold + ")";}

[User] public String toString() {return "jarowinkler(" + threshold + ")";}

[Assistant] public override string ToString(){return "jarowinkler(" + threshold + ")";}


public DeleteInvitationsResult deleteInvitations(DeleteInvitationsRequest request) {request = beforeClientExecution(request);return executeDeleteInvitations(request);}

public virtual DeleteInvitationsResponse DeleteInvitations(DeleteInvitationsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteInvitationsRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteInvitationsResponseUnmarshaller.Instance;return Invoke<DeleteInvitationsResponse>(request, options);}

[User] public DeleteInvitationsResult deleteInvitations(DeleteInvitationsRequest request) {request = beforeClientExecution(request);return executeDeleteInvitations(request);}

[Assistant] public virtual DeleteInvitationsResponse DeleteInvitations(DeleteInvitationsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteInvitationsRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteInvitationsResponseUnmarshaller.Instance;return Invoke<DeleteInvitationsResponse>(request, options);}


public DelimitedPayloadTokenFilterFactory(Map<String, String> args) {super(args);encoderClass = require(args, ENCODER_ATTR);delimiter = getChar(args, DELIMITER_ATTR, '|');if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

public DelimitedPayloadTokenFilterFactory(IDictionary<string, string> args): base(args){encoderClass = Require(args, ENCODER_ATTR);delimiter = GetChar(args, DELIMITER_ATTR, '|');if (args.Count > 0){throw new System.ArgumentException("Unknown parameters: " + args);}}

[User] public DelimitedPayloadTokenFilterFactory(Map<String, String> args) {super(args);encoderClass = require(args, ENCODER_ATTR);delimiter = getChar(args, DELIMITER_ATTR, '|');if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

[Assistant] public DelimitedPayloadTokenFilterFactory(IDictionary<string, string> args): base(args){encoderClass = Require(args, ENCODER_ATTR);delimiter = GetChar(args, DELIMITER_ATTR, '|');if (args.Count > 0){throw new System.ArgumentException("Unknown parameters: " + args);}}


public ListSmartHomeAppliancesResult listSmartHomeAppliances(ListSmartHomeAppliancesRequest request) {request = beforeClientExecution(request);return executeListSmartHomeAppliances(request);}

public virtual ListSmartHomeAppliancesResponse ListSmartHomeAppliances(ListSmartHomeAppliancesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListSmartHomeAppliancesRequestMarshaller.Instance;options.ResponseUnmarshaller = ListSmartHomeAppliancesResponseUnmarshaller.Instance;return Invoke<ListSmartHomeAppliancesResponse>(request, options);}

[User] public ListSmartHomeAppliancesResult listSmartHomeAppliances(ListSmartHomeAppliancesRequest request) {request = beforeClientExecution(request);return executeListSmartHomeAppliances(request);}

[Assistant] public virtual ListSmartHomeAppliancesResponse ListSmartHomeAppliances(ListSmartHomeAppliancesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListSmartHomeAppliancesRequestMarshaller.Instance;options.ResponseUnmarshaller = ListSmartHomeAppliancesResponseUnmarshaller.Instance;return Invoke<ListSmartHomeAppliancesResponse>(request, options);}


public void dispatch(ConfigChangedListener listener) {listener.onConfigChanged(this);}

public override void Dispatch(ConfigChangedListener listener){listener.OnConfigChanged(this);}

[User] public void dispatch(ConfigChangedListener listener) {listener.onConfigChanged(this);}

[Assistant] public override void Dispatch(ConfigChangedListener listener){listener.OnConfigChanged(this);}


public File[] listFiles() {return filenamesToFiles(list());}

public java.io.File[] listFiles(){return filenamesToFiles(list());}

[User] public File[] listFiles() {return filenamesToFiles(list());}

[Assistant] public java.io.File[] listFiles(){return filenamesToFiles(list());}


public DedicatedCapacityInner getByResourceGroup(String resourceGroupName, String dedicatedCapacityName) {return getByResourceGroupWithServiceResponseAsync(resourceGroupName, dedicatedCapacityName).toBlocking().single().body();}

public async Task<AzureOperationResponse<DedicatedCapacity>> GetDetailsWithHttpMessagesAsync(string resourceGroupName, string dedicatedCapacityName, Dictionary<string, List<string>> customHeaders = null, CancellationToken cancellationToken = default(CancellationToken)){return await innerCapacityOperations.GetDetailsWithHttpMessagesAsync(resourceGroupName, dedicatedCapacityName, customHeaders, cancellationToken).ConfigureAwait(false);}

[User] public DedicatedCapacityInner getByResourceGroup(String resourceGroupName, String dedicatedCapacityName) {return getByResourceGroupWithServiceResponseAsync(resourceGroupName, dedicatedCapacityName).toBlocking().single().body();}

[Assistant] public async Task<AzureOperationResponse<DedicatedCapacity>> GetDetailsWithHttpMessagesAsync(string resourceGroupName, string dedicatedCapacityName, Dictionary<string, List<string>> customHeaders = null, CancellationToken cancellationToken = default(CancellationToken)){return await innerCapacityOperations.GetDetailsWithHttpMessagesAsync(resourceGroupName, dedicatedCapacityName, customHeaders, cancellationToken).ConfigureAwait(false);}


public void seekExact(long ord) {assert ord < info.terms.size();termUpto = (int) ord;info.terms.get(info.sortedTerms[termUpto], br);}

public override void SeekExact(long ord){Debug.Assert(ord < info.terms.Count);termUpto = (int)ord;}

[User] public void seekExact(long ord) {assert ord < info.terms.size();termUpto = (int) ord;info.terms.get(info.sortedTerms[termUpto], br);}

[Assistant] public override void SeekExact(long ord){Debug.Assert(ord < info.terms.Count);termUpto = (int)ord;}


public CreateTrialComponentResult createTrialComponent(CreateTrialComponentRequest request) {request = beforeClientExecution(request);return executeCreateTrialComponent(request);}

public virtual CreateTrialComponentResponse CreateTrialComponent(CreateTrialComponentRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateTrialComponentRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateTrialComponentResponseUnmarshaller.Instance;return Invoke<CreateTrialComponentResponse>(request, options);}

[User] public CreateTrialComponentResult createTrialComponent(CreateTrialComponentRequest request) {request = beforeClientExecution(request);return executeCreateTrialComponent(request);}

[Assistant] public virtual CreateTrialComponentResponse CreateTrialComponent(CreateTrialComponentRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateTrialComponentRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateTrialComponentResponseUnmarshaller.Instance;return Invoke<CreateTrialComponentResponse>(request, options);}


public UpdateResourceResult updateResource(UpdateResourceRequest request) {request = beforeClientExecution(request);return executeUpdateResource(request);}

public virtual UpdateResourceResponse UpdateResource(UpdateResourceRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateResourceRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateResourceResponseUnmarshaller.Instance;return Invoke<UpdateResourceResponse>(request, options);}

[User] public UpdateResourceResult updateResource(UpdateResourceRequest request) {request = beforeClientExecution(request);return executeUpdateResource(request);}

[Assistant] public virtual UpdateResourceResponse UpdateResource(UpdateResourceRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateResourceRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateResourceResponseUnmarshaller.Instance;return Invoke<UpdateResourceResponse>(request, options);}


public long length() {try {return channel.size();} catch (IOException ioe) {throw new RuntimeException("IOException during length(): " + this, ioe);}}

public long length(){try{return channel.size();}catch (IOException ioe){throw new Exception("IOException during length(): " + this, ioe);}}

[User] public long length() {try {return channel.size();} catch (IOException ioe) {throw new RuntimeException("IOException during length(): " + this, ioe);}}

[Assistant] public long length(){try{return channel.size();}catch (IOException ioe){throw new Exception("IOException during length(): " + this, ioe);}}


public char setIndex(int position) {if (position < getBeginIndex() || position > getEndIndex())throw new IllegalArgumentException("Illegal Position: " + position);index = start + position;return current();}

public override char SetIndex(int position){if (position < BeginIndex || position > EndIndex){throw new ArgumentException("Illegal Position: " + position);}index = start + position;return Current;}

[User] public char setIndex(int position) {if (position < getBeginIndex() || position > getEndIndex())throw new IllegalArgumentException("Illegal Position: " + position);index = start + position;return current();}

[Assistant] public override char SetIndex(int position){if (position < BeginIndex || position > EndIndex){throw new ArgumentException("Illegal Position: " + position);}index = start + position;return Current;}


public static boolean isContainer(short options, short recordId){if(recordId >= EscherContainerRecord.DGG_CONTAINER &&  recordId<= EscherContainerRecord.SOLVER_CONTAINER){return true;} else {if (recordId == EscherTextboxRecord.RECORD_ID) {return false;} else {return ( options & (short) 0x000F ) == (short) 0x000F;}}}

public static bool IsContainer(short options, short recordId){if (recordId >= EscherContainerRecord.DGG_CONTAINER && recordId<= EscherContainerRecord.SOLVER_CONTAINER){return true;}else{if (recordId == EscherTextboxRecord.RECORD_ID){return false;}else{return (options & (short)0x000F) == (short)0x000F;}}}

[User] public static boolean isContainer(short options, short recordId){if(recordId >= EscherContainerRecord.DGG_CONTAINER &&  recordId<= EscherContainerRecord.SOLVER_CONTAINER){return true;} else {if (recordId == EscherTextboxRecord.RECORD_ID) {return false;} else {return ( options & (short) 0x000F ) == (short) 0x000F;}}}

[Assistant] public static bool IsContainer(short options, short recordId){if (recordId >= EscherContainerRecord.DGG_CONTAINER && recordId<= EscherContainerRecord.SOLVER_CONTAINER){return true;}else{if (recordId == EscherTextboxRecord.RECORD_ID){return false;}else{return (options & (short)0x000F) == (short)0x000F;}}}


public boolean exists(String fileName) {assert locked();if (!refCounts.containsKey(fileName)) {return false;} else {return getRefCount(fileName).count > 0;}}

public bool Exists(string fileName){Debug.Assert(IsLocked);return refCounts.TryGetValue(fileName, out RefCount value) ? value.count > 0 : false;}

[User] public boolean exists(String fileName) {assert locked();if (!refCounts.containsKey(fileName)) {return false;} else {return getRefCount(fileName).count > 0;}}

[Assistant] public bool Exists(string fileName){Debug.Assert(IsLocked);return refCounts.TryGetValue(fileName, out RefCount value) ? value.count > 0 : false;}


public STSAssumeRoleSessionCredentialsProvider withSTSClient(IAcsClient client) {this.stsClient = client;return this;}

public void WithSTSClient(IAcsClient client){stsClient = client;}

[User] public STSAssumeRoleSessionCredentialsProvider withSTSClient(IAcsClient client) {this.stsClient = client;return this;}

[Assistant] public void WithSTSClient(IAcsClient client){stsClient = client;}


public AcceptMatchResult acceptMatch(AcceptMatchRequest request) {request = beforeClientExecution(request);return executeAcceptMatch(request);}

public virtual AcceptMatchResponse AcceptMatch(AcceptMatchRequest request){var options = new InvokeOptions();options.RequestMarshaller = AcceptMatchRequestMarshaller.Instance;options.ResponseUnmarshaller = AcceptMatchResponseUnmarshaller.Instance;return Invoke<AcceptMatchResponse>(request, options);}

[User] public AcceptMatchResult acceptMatch(AcceptMatchRequest request) {request = beforeClientExecution(request);return executeAcceptMatch(request);}

[Assistant] public virtual AcceptMatchResponse AcceptMatch(AcceptMatchRequest request){var options = new InvokeOptions();options.RequestMarshaller = AcceptMatchRequestMarshaller.Instance;options.ResponseUnmarshaller = AcceptMatchResponseUnmarshaller.Instance;return Invoke<AcceptMatchResponse>(request, options);}


public static RevFilter create(int skip) {if (skip < 0)throw new IllegalArgumentException(JGitText.get().skipMustBeNonNegative);return new SkipRevFilter(skip);}

public static RevFilter Create(int skip){if (skip < 0){throw new ArgumentException(JGitText.Get().skipMustBeNonNegative);}return new NGit.Revwalk.Filter.SkipRevFilter(skip);}

[User] public static RevFilter create(int skip) {if (skip < 0)throw new IllegalArgumentException(JGitText.get().skipMustBeNonNegative);return new SkipRevFilter(skip);}

[Assistant] public static RevFilter Create(int skip){if (skip < 0){throw new ArgumentException(JGitText.Get().skipMustBeNonNegative);}return new NGit.Revwalk.Filter.SkipRevFilter(skip);}


public GetHITResult getHIT(GetHITRequest request) {request = beforeClientExecution(request);return executeGetHIT(request);}

public virtual GetHITResponse GetHIT(GetHITRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetHITRequestMarshaller.Instance;options.ResponseUnmarshaller = GetHITResponseUnmarshaller.Instance;return Invoke<GetHITResponse>(request, options);}

[User] public GetHITResult getHIT(GetHITRequest request) {request = beforeClientExecution(request);return executeGetHIT(request);}

[Assistant] public virtual GetHITResponse GetHIT(GetHITRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetHITRequestMarshaller.Instance;options.ResponseUnmarshaller = GetHITResponseUnmarshaller.Instance;return Invoke<GetHITResponse>(request, options);}


public StopStreamProcessorResult stopStreamProcessor(StopStreamProcessorRequest request) {request = beforeClientExecution(request);return executeStopStreamProcessor(request);}

public virtual StopStreamProcessorResponse StopStreamProcessor(StopStreamProcessorRequest request){var options = new InvokeOptions();options.RequestMarshaller = StopStreamProcessorRequestMarshaller.Instance;options.ResponseUnmarshaller = StopStreamProcessorResponseUnmarshaller.Instance;return Invoke<StopStreamProcessorResponse>(request, options);}

[User] public StopStreamProcessorResult stopStreamProcessor(StopStreamProcessorRequest request) {request = beforeClientExecution(request);return executeStopStreamProcessor(request);}

[Assistant] public virtual StopStreamProcessorResponse StopStreamProcessor(StopStreamProcessorRequest request){var options = new InvokeOptions();options.RequestMarshaller = StopStreamProcessorRequestMarshaller.Instance;options.ResponseUnmarshaller = StopStreamProcessorResponseUnmarshaller.Instance;return Invoke<StopStreamProcessorResponse>(request, options);}


public static AttrPtg createIf(int dist) {return new AttrPtg(optiIf.set(0), dist, null, -1);}

public static AttrPtg CreateIf(int dist){return new AttrPtg(optiIf.Set(0), dist, null, -1);}

[User] public static AttrPtg createIf(int dist) {return new AttrPtg(optiIf.set(0), dist, null, -1);}

[Assistant] public static AttrPtg CreateIf(int dist){return new AttrPtg(optiIf.Set(0), dist, null, -1);}


public DeleteIAMPolicyAssignmentResult deleteIAMPolicyAssignment(DeleteIAMPolicyAssignmentRequest request) {request = beforeClientExecution(request);return executeDeleteIAMPolicyAssignment(request);}

public virtual DeleteIAMPolicyAssignmentResponse DeleteIAMPolicyAssignment(DeleteIAMPolicyAssignmentRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteIAMPolicyAssignmentRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteIAMPolicyAssignmentResponseUnmarshaller.Instance;return Invoke<DeleteIAMPolicyAssignmentResponse>(request, options);}

[User] public DeleteIAMPolicyAssignmentResult deleteIAMPolicyAssignment(DeleteIAMPolicyAssignmentRequest request) {request = beforeClientExecution(request);return executeDeleteIAMPolicyAssignment(request);}

[Assistant] public virtual DeleteIAMPolicyAssignmentResponse DeleteIAMPolicyAssignment(DeleteIAMPolicyAssignmentRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteIAMPolicyAssignmentRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteIAMPolicyAssignmentResponseUnmarshaller.Instance;return Invoke<DeleteIAMPolicyAssignmentResponse>(request, options);}


public UpdateCampaignResult updateCampaign(UpdateCampaignRequest request) {request = beforeClientExecution(request);return executeUpdateCampaign(request);}

public virtual UpdateCampaignResponse UpdateCampaign(UpdateCampaignRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateCampaignRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateCampaignResponseUnmarshaller.Instance;return Invoke<UpdateCampaignResponse>(request, options);}

[User] public UpdateCampaignResult updateCampaign(UpdateCampaignRequest request) {request = beforeClientExecution(request);return executeUpdateCampaign(request);}

[Assistant] public virtual UpdateCampaignResponse UpdateCampaign(UpdateCampaignRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateCampaignRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateCampaignResponseUnmarshaller.Instance;return Invoke<UpdateCampaignResponse>(request, options);}


public LexerActionExecutor fixOffsetBeforeMatch(int offset) {LexerAction[] updatedLexerActions = null;for (int i = 0; i < lexerActions.length; i++) {if (lexerActions[i].isPositionDependent() && !(lexerActions[i] instanceof LexerIndexedCustomAction)) {if (updatedLexerActions == null) {updatedLexerActions = lexerActions.clone();}updatedLexerActions[i] = new LexerIndexedCustomAction(offset, lexerActions[i]);}}if (updatedLexerActions == null) {return this;}return new LexerActionExecutor(updatedLexerActions);}

public virtual Antlr4.Runtime.Atn.LexerActionExecutor FixOffsetBeforeMatch(int offset){ILexerAction[] updatedLexerActions = null;for (int i = 0; i < lexerActions.Length; i++){if (lexerActions[i].IsPositionDependent && !(lexerActions[i] is LexerIndexedCustomAction)){if (updatedLexerActions == null){updatedLexerActions = (ILexerAction[])lexerActions.Clone();}updatedLexerActions[i] = new LexerIndexedCustomAction(offset, lexerActions[i]);}}if (updatedLexerActions == null){return this;}return new Antlr4.Runtime.Atn.LexerActionExecutor(updatedLexerActions);}

[User] public LexerActionExecutor fixOffsetBeforeMatch(int offset) {LexerAction[] updatedLexerActions = null;for (int i = 0; i < lexerActions.length; i++) {if (lexerActions[i].isPositionDependent() && !(lexerActions[i] instanceof LexerIndexedCustomAction)) {if (updatedLexerActions == null) {updatedLexerActions = lexerActions.clone();}updatedLexerActions[i] = new LexerIndexedCustomAction(offset, lexerActions[i]);}}if (updatedLexerActions == null) {return this;}return new LexerActionExecutor(updatedLexerActions);}

[Assistant] public virtual Antlr4.Runtime.Atn.LexerActionExecutor FixOffsetBeforeMatch(int offset){ILexerAction[] updatedLexerActions = null;for (int i = 0; i < lexerActions.Length; i++){if (lexerActions[i].IsPositionDependent && !(lexerActions[i] is LexerIndexedCustomAction)){if (updatedLexerActions == null){updatedLexerActions = (ILexerAction[])lexerActions.Clone();}updatedLexerActions[i] = new LexerIndexedCustomAction(offset, lexerActions[i]);}}if (updatedLexerActions == null){return this;}return new Antlr4.Runtime.Atn.LexerActionExecutor(updatedLexerActions);}