public PutVoiceConnectorLoggingConfigurationResult putVoiceConnectorLoggingConfiguration(PutVoiceConnectorLoggingConfigurationRequest request) {request = beforeClientExecution(request);return executePutVoiceConnectorLoggingConfiguration(request);}

public virtual PutVoiceConnectorLoggingConfigurationResponse PutVoiceConnectorLoggingConfiguration(PutVoiceConnectorLoggingConfigurationRequest request){var options = new InvokeOptions();options.RequestMarshaller = PutVoiceConnectorLoggingConfigurationRequestMarshaller.Instance;options.ResponseUnmarshaller = PutVoiceConnectorLoggingConfigurationResponseUnmarshaller.Instance;return Invoke<PutVoiceConnectorLoggingConfigurationResponse>(request, options);}

[User] public PutVoiceConnectorLoggingConfigurationResult putVoiceConnectorLoggingConfiguration(PutVoiceConnectorLoggingConfigurationRequest request) {request = beforeClientExecution(request);return executePutVoiceConnectorLoggingConfiguration(request);}

[Assistant] public virtual PutVoiceConnectorLoggingConfigurationResponse PutVoiceConnectorLoggingConfiguration(PutVoiceConnectorLoggingConfigurationRequest request){var options = new InvokeOptions();options.RequestMarshaller = PutVoiceConnectorLoggingConfigurationRequestMarshaller.Instance;options.ResponseUnmarshaller = PutVoiceConnectorLoggingConfigurationResponseUnmarshaller.Instance;return Invoke<PutVoiceConnectorLoggingConfigurationResponse>(request, options);}


public boolean isAbsolute() {return path.length() > 0 && path.charAt(0) == separatorChar;}

public bool isAbsolute(){return path.Length > 0 && path[0] == separatorChar;}

[User] public boolean isAbsolute() {return path.length() > 0 && path.charAt(0) == separatorChar;}

[Assistant] public bool isAbsolute(){return path.Length > 0 && path[0] == separatorChar;}


public CreateSnapshotRequest(String volumeId, String description) {setVolumeId(volumeId);setDescription(description);}

public CreateSnapshotRequest(string volumeId, string description){_volumeId = volumeId;_description = description;}

[User] public CreateSnapshotRequest(String volumeId, String description) {setVolumeId(volumeId);setDescription(description);}

[Assistant] public CreateSnapshotRequest(string volumeId, string description){_volumeId = volumeId;_description = description;}


public static ReaderIterator getReaderIteratorNoHeader(DataInput in, Format format, int version,int valueCount, int bitsPerValue, int mem) {checkVersion(version);return new PackedReaderIterator(format, version, valueCount, bitsPerValue, in, mem);}

public static IReaderIterator GetReaderIteratorNoHeader(DataInput @in, Format format, int version, int valueCount, int bitsPerValue, int mem){CheckVersion(version);return new PackedReaderIterator(format, version, valueCount, bitsPerValue, @in, mem);}

[User] public static ReaderIterator getReaderIteratorNoHeader(DataInput in, Format format, int version,int valueCount, int bitsPerValue, int mem) {checkVersion(version);return new PackedReaderIterator(format, version, valueCount, bitsPerValue, in, mem);}

[Assistant] public static IReaderIterator GetReaderIteratorNoHeader(DataInput @in, Format format, int version, int valueCount, int bitsPerValue, int mem){CheckVersion(version);return new PackedReaderIterator(format, version, valueCount, bitsPerValue, @in, mem);}


public DoubleBuffer put(int index, double c) {throw new ReadOnlyBufferException();}

public override java.nio.DoubleBuffer put(int index, double c){throw new java.nio.ReadOnlyBufferException();}

[User] public DoubleBuffer put(int index, double c) {throw new ReadOnlyBufferException();}

[Assistant] public override java.nio.DoubleBuffer put(int index, double c){throw new java.nio.ReadOnlyBufferException();}


public StashDropCommand stashDrop() {return new StashDropCommand(repo);}

public virtual StashDropCommand StashDrop(){return new StashDropCommand(repo);}

[User] public StashDropCommand stashDrop() {return new StashDropCommand(repo);}

[Assistant] public virtual StashDropCommand StashDrop(){return new StashDropCommand(repo);}


public boolean isUnmappable() {return this.type == TYPE_UNMAPPABLE_CHAR;}

public virtual bool isUnmappable(){return this.type == TYPE_UNMAPPABLE_CHAR;}

[User] public boolean isUnmappable() {return this.type == TYPE_UNMAPPABLE_CHAR;}

[Assistant] public virtual bool isUnmappable(){return this.type == TYPE_UNMAPPABLE_CHAR;}


public byte readByte() {checkPosition(1);return (byte)read();}

public int ReadByte(){CheckPosition(1);return _buf[_ReadIndex++];}

[User] public byte readByte() {checkPosition(1);return (byte)read();}

[Assistant] public int ReadByte(){CheckPosition(1);return _buf[_ReadIndex++];}


public void decode(long[] blocks, int blocksOffset, int[] values,int valuesOffset, int iterations) {if (bitsPerValue > 32) {throw new UnsupportedOperationException("Cannot decode " + bitsPerValue + "-bits values into an int[]");}for (int i = 0; i < iterations; ++i) {final long block = blocks[blocksOffset++];valuesOffset = decode(block, values, valuesOffset);}}

public override void Decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations){if (bitsPerValue > 32){throw new System.NotSupportedException("Cannot decode " + bitsPerValue + "-bits values into an int[]");}for (int i = 0; i < iterations; ++i){long block = blocks[blocksOffset++];valuesOffset = Decode(block, values, valuesOffset);}}

[User] public void decode(long[] blocks, int blocksOffset, int[] values,int valuesOffset, int iterations) {if (bitsPerValue > 32) {throw new UnsupportedOperationException("Cannot decode " + bitsPerValue + "-bits values into an int[]");}for (int i = 0; i < iterations; ++i) {final long block = blocks[blocksOffset++];valuesOffset = decode(block, values, valuesOffset);}}

[Assistant] public override void Decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations){if (bitsPerValue > 32){throw new System.NotSupportedException("Cannot decode " + bitsPerValue + "-bits values into an int[]");}for (int i = 0; i < iterations; ++i){long block = blocks[blocksOffset++];valuesOffset = Decode(block, values, valuesOffset);}}


public CustomAnalyzerConfig build() {return new CustomAnalyzerConfig(this);}

public CompositeReaderContext Build(){return (CompositeReaderContext)Build(null, reader, 0, 0);}

[User] public CustomAnalyzerConfig build() {return new CustomAnalyzerConfig(this);}

[Assistant] public CompositeReaderContext Build(){return (CompositeReaderContext)Build(null, reader, 0, 0);}


public UpdateAddressBookResult updateAddressBook(UpdateAddressBookRequest request) {request = beforeClientExecution(request);return executeUpdateAddressBook(request);}

public virtual UpdateAddressBookResponse UpdateAddressBook(UpdateAddressBookRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateAddressBookRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateAddressBookResponseUnmarshaller.Instance;return Invoke<UpdateAddressBookResponse>(request, options);}

[User] public UpdateAddressBookResult updateAddressBook(UpdateAddressBookRequest request) {request = beforeClientExecution(request);return executeUpdateAddressBook(request);}

[Assistant] public virtual UpdateAddressBookResponse UpdateAddressBook(UpdateAddressBookRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateAddressBookRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateAddressBookResponseUnmarshaller.Instance;return Invoke<UpdateAddressBookResponse>(request, options);}


public String toString() {return String.format("Point [%dx%d]", x, y);}

public override string ToString(){return "Point(" + x + ", " + y + ")";}

[User] public String toString() {return String.format("Point [%dx%d]", x, y);}

[Assistant] public override string ToString(){return "Point(" + x + ", " + y + ")";}


public DescribeAccountAttributesResult describeAccountAttributes(DescribeAccountAttributesRequest request) {request = beforeClientExecution(request);return executeDescribeAccountAttributes(request);}

public virtual DescribeAccountAttributesResponse DescribeAccountAttributes(DescribeAccountAttributesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeAccountAttributesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeAccountAttributesResponseUnmarshaller.Instance;return Invoke<DescribeAccountAttributesResponse>(request, options);}

[User] public DescribeAccountAttributesResult describeAccountAttributes(DescribeAccountAttributesRequest request) {request = beforeClientExecution(request);return executeDescribeAccountAttributes(request);}

[Assistant] public virtual DescribeAccountAttributesResponse DescribeAccountAttributes(DescribeAccountAttributesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeAccountAttributesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeAccountAttributesResponseUnmarshaller.Instance;return Invoke<DescribeAccountAttributesResponse>(request, options);}


public static final RevFilter before(long ts) {return new Before(ts);}

public static RevFilter Before(long ts){return new CommitTimeRevFilterBefore(ts);}

[User] public static final RevFilter before(long ts) {return new Before(ts);}

[Assistant] public static RevFilter Before(long ts){return new CommitTimeRevFilterBefore(ts);}


public void seekExact(BytesRef target, TermState otherState) {if (!target.equals(term)) {state.copyFrom(otherState);term = BytesRef.deepCopyOf(target);seekPending = true;}}

public override void SeekExact(BytesRef target, TermState otherState){Debug.Assert(otherState != null && otherState is BlockTermState);Debug.Assert(!doOrd || ((BlockTermState)otherState).Ord < outerInstance.numTerms);state.CopyFrom(otherState);seekPending = true;indexIsCurrent = false;term.CopyBytes(target);}

[User] public void seekExact(BytesRef target, TermState otherState) {if (!target.equals(term)) {state.copyFrom(otherState);term = BytesRef.deepCopyOf(target);seekPending = true;}}

[Assistant] public override void SeekExact(BytesRef target, TermState otherState){Debug.Assert(otherState != null && otherState is BlockTermState);Debug.Assert(!doOrd || ((BlockTermState)otherState).Ord < outerInstance.numTerms);state.CopyFrom(otherState);seekPending = true;indexIsCurrent = false;term.CopyBytes(target);}


public DescribeClusterParameterGroupsResult describeClusterParameterGroups(DescribeClusterParameterGroupsRequest request) {request = beforeClientExecution(request);return executeDescribeClusterParameterGroups(request);}

public virtual DescribeClusterParameterGroupsResponse DescribeClusterParameterGroups(DescribeClusterParameterGroupsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeClusterParameterGroupsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeClusterParameterGroupsResponseUnmarshaller.Instance;return Invoke<DescribeClusterParameterGroupsResponse>(request, options);}

[User] public DescribeClusterParameterGroupsResult describeClusterParameterGroups(DescribeClusterParameterGroupsRequest request) {request = beforeClientExecution(request);return executeDescribeClusterParameterGroups(request);}

[Assistant] public virtual DescribeClusterParameterGroupsResponse DescribeClusterParameterGroups(DescribeClusterParameterGroupsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeClusterParameterGroupsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeClusterParameterGroupsResponseUnmarshaller.Instance;return Invoke<DescribeClusterParameterGroupsResponse>(request, options);}


public BatchGetApplicationsResult batchGetApplications(BatchGetApplicationsRequest request) {request = beforeClientExecution(request);return executeBatchGetApplications(request);}

public virtual BatchGetApplicationsResponse BatchGetApplications(BatchGetApplicationsRequest request){var options = new InvokeOptions();options.RequestMarshaller = BatchGetApplicationsRequestMarshaller.Instance;options.ResponseUnmarshaller = BatchGetApplicationsResponseUnmarshaller.Instance;return Invoke<BatchGetApplicationsResponse>(request, options);}

[User] public BatchGetApplicationsResult batchGetApplications(BatchGetApplicationsRequest request) {request = beforeClientExecution(request);return executeBatchGetApplications(request);}

[Assistant] public virtual BatchGetApplicationsResponse BatchGetApplications(BatchGetApplicationsRequest request){var options = new InvokeOptions();options.RequestMarshaller = BatchGetApplicationsRequestMarshaller.Instance;options.ResponseUnmarshaller = BatchGetApplicationsResponseUnmarshaller.Instance;return Invoke<BatchGetApplicationsResponse>(request, options);}


public String toString() {return "dels=" + Arrays.toString(item);}

public override string ToString(){return "dels=" + Arrays.ToString((Term[])item);}

[User] public String toString() {return "dels=" + Arrays.toString(item);}

[Assistant] public override string ToString(){return "dels=" + Arrays.ToString((Term[])item);}


public FreeRefFunction findFunction(String name) {FreeRefFunction evaluatorForFunction;for (UDFFinder pack : _usedToolPacks) {evaluatorForFunction = pack.findFunction(name);if (evaluatorForFunction != null) {return evaluatorForFunction;}}return null;}

public override FreeRefFunction FindFunction(String name){FreeRefFunction evaluatorForFunction;foreach (UDFFinder pack in _usedToolPacks){evaluatorForFunction = pack.FindFunction(name);if (evaluatorForFunction != null){return evaluatorForFunction;}}return null;}

[User] public FreeRefFunction findFunction(String name) {FreeRefFunction evaluatorForFunction;for (UDFFinder pack : _usedToolPacks) {evaluatorForFunction = pack.findFunction(name);if (evaluatorForFunction != null) {return evaluatorForFunction;}}return null;}

[Assistant] public override FreeRefFunction FindFunction(String name){FreeRefFunction evaluatorForFunction;foreach (UDFFinder pack in _usedToolPacks){evaluatorForFunction = pack.FindFunction(name);if (evaluatorForFunction != null){return evaluatorForFunction;}}return null;}


public String toString(){StringBuilder sb = new StringBuilder();sb.append("[LABEL]\n");sb.append("    .row       = ").append(HexDump.shortToHex(getRow())).append("\n");sb.append("    .column    = ").append(HexDump.shortToHex(getColumn())).append("\n");sb.append("    .xfindex   = ").append(HexDump.shortToHex(getXFIndex())).append("\n");sb.append("    .string_len= ").append(HexDump.shortToHex(field_4_string_len)).append("\n");sb.append("    .unicode_flag= ").append(HexDump.byteToHex(field_5_unicode_flag)).append("\n");sb.append("    .value       = ").append(getValue()).append("\n");sb.append("[/LABEL]\n");return sb.toString();}

public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append("[LABEL]\n");buffer.Append("    .row            = ").Append(StringUtil.ToHexString(Row)).Append("\n");buffer.Append("    .column         = ").Append(StringUtil.ToHexString(Column)).Append("\n");buffer.Append("    .xfindex        = ").Append(StringUtil.ToHexString(XFIndex)).Append("\n");buffer.Append("    .string_len       = ").Append(StringUtil.ToHexString(field_4_string_len)).Append("\n");buffer.Append("    .unicode_flag       = ").Append(StringUtil.ToHexString(field_5_unicode_flag)).Append("\n");buffer.Append("    .value       = ").Append(Value).Append("\n");buffer.Append("[/LABEL]\n");return buffer.ToString();}

[User] public String toString(){StringBuilder sb = new StringBuilder();sb.append("[LABEL]\n");sb.append("    .row       = ").append(HexDump.shortToHex(getRow())).append("\n");sb.append("    .column    = ").append(HexDump.shortToHex(getColumn())).append("\n");sb.append("    .xfindex   = ").append(HexDump.shortToHex(getXFIndex())).append("\n");sb.append("    .string_len= ").append(HexDump.shortToHex(field_4_string_len)).append("\n");sb.append("    .unicode_flag= ").append(HexDump.byteToHex(field_5_unicode_flag)).append("\n");sb.append("    .value       = ").append(getValue()).append("\n");sb.append("[/LABEL]\n");return sb.toString();}

[Assistant] public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append("[LABEL]\n");buffer.Append("    .row            = ").Append(StringUtil.ToHexString(Row)).Append("\n");buffer.Append("    .column         = ").Append(StringUtil.ToHexString(Column)).Append("\n");buffer.Append("    .xfindex        = ").Append(StringUtil.ToHexString(XFIndex)).Append("\n");buffer.Append("    .string_len       = ").Append(StringUtil.ToHexString(field_4_string_len)).Append("\n");buffer.Append("    .unicode_flag       = ").Append(StringUtil.ToHexString(field_5_unicode_flag)).Append("\n");buffer.Append("    .value       = ").Append(Value).Append("\n");buffer.Append("[/LABEL]\n");return buffer.ToString();}


public static void verifyLabel(String label) {if (label == null || label.isEmpty()) {throw new IllegalArgumentException("empty or null components not allowed; got: " + label);}}

public static void VerifyLabel(string label){if (string.IsNullOrEmpty(label)){throw new System.ArgumentException("empty or null components not allowed; got: " + label);}}

[User] public static void verifyLabel(String label) {if (label == null || label.isEmpty()) {throw new IllegalArgumentException("empty or null components not allowed; got: " + label);}}

[Assistant] public static void VerifyLabel(string label){if (string.IsNullOrEmpty(label)){throw new System.ArgumentException("empty or null components not allowed; got: " + label);}}


public boolean setReadOnly() {return setWritable(false, false);}

public bool setReadOnly(){return setWritable(false, false);}

[User] public boolean setReadOnly() {return setWritable(false, false);}

[Assistant] public bool setReadOnly(){return setWritable(false, false);}


public CopyImageResult copyImage(CopyImageRequest request) {request = beforeClientExecution(request);return executeCopyImage(request);}

public virtual CopyImageResponse CopyImage(CopyImageRequest request){var options = new InvokeOptions();options.RequestMarshaller = CopyImageRequestMarshaller.Instance;options.ResponseUnmarshaller = CopyImageResponseUnmarshaller.Instance;return Invoke<CopyImageResponse>(request, options);}

[User] public CopyImageResult copyImage(CopyImageRequest request) {request = beforeClientExecution(request);return executeCopyImage(request);}

[Assistant] public virtual CopyImageResponse CopyImage(CopyImageRequest request){var options = new InvokeOptions();options.RequestMarshaller = CopyImageRequestMarshaller.Instance;options.ResponseUnmarshaller = CopyImageResponseUnmarshaller.Instance;return Invoke<CopyImageResponse>(request, options);}


public CreateTrainingJobResult createTrainingJob(CreateTrainingJobRequest request) {request = beforeClientExecution(request);return executeCreateTrainingJob(request);}

public virtual CreateTrainingJobResponse CreateTrainingJob(CreateTrainingJobRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateTrainingJobRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateTrainingJobResponseUnmarshaller.Instance;return Invoke<CreateTrainingJobResponse>(request, options);}

[User] public CreateTrainingJobResult createTrainingJob(CreateTrainingJobRequest request) {request = beforeClientExecution(request);return executeCreateTrainingJob(request);}

[Assistant] public virtual CreateTrainingJobResponse CreateTrainingJob(CreateTrainingJobRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateTrainingJobRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateTrainingJobResponseUnmarshaller.Instance;return Invoke<CreateTrainingJobResponse>(request, options);}


public DescribeDomainsResult describeDomains(DescribeDomainsRequest request) {request = beforeClientExecution(request);return executeDescribeDomains(request);}

public virtual DescribeDomainsResponse DescribeDomains(DescribeDomainsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeDomainsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeDomainsResponseUnmarshaller.Instance;return Invoke<DescribeDomainsResponse>(request, options);}

[User] public DescribeDomainsResult describeDomains(DescribeDomainsRequest request) {request = beforeClientExecution(request);return executeDescribeDomains(request);}

[Assistant] public virtual DescribeDomainsResponse DescribeDomains(DescribeDomainsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeDomainsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeDomainsResponseUnmarshaller.Instance;return Invoke<DescribeDomainsResponse>(request, options);}


public String toString() {return "ngram(" + n + ")";}

public override string ToString(){return "ngram(" + n + ")";}

[User] public String toString() {return "ngram(" + n + ")";}

[Assistant] public override string ToString(){return "ngram(" + n + ")";}


public boolean formatMatches(ColumnInfoRecord other) {if (_xfIndex != other._xfIndex) {return false;}if (_options != other._options) {return false;}if (_colWidth != other._colWidth) {return false;}return true;}

public bool FormatMatches(ColumnInfoRecord other){if (_xf_index != other._xf_index){return false;}if (_options != other._options){return false;}if (_col_width != other._col_width){return false;}return true;}

[User] public boolean formatMatches(ColumnInfoRecord other) {if (_xfIndex != other._xfIndex) {return false;}if (_options != other._options) {return false;}if (_colWidth != other._colWidth) {return false;}return true;}

[Assistant] public bool FormatMatches(ColumnInfoRecord other){if (_xf_index != other._xf_index){return false;}if (_options != other._options){return false;}if (_col_width != other._col_width){return false;}return true;}


public AddCommand add() {return new AddCommand(repo);}

public virtual AddCommand Add(){return new AddCommand(repo);}

[User] public AddCommand add() {return new AddCommand(repo);}

[Assistant] public virtual AddCommand Add(){return new AddCommand(repo);}


public final int limit() {return limit;}

[User] public final int limit() {return limit;}

[Assistant] public int limit(){return _limit;}


public CharBuffer asReadOnlyBuffer() {return ReadOnlyCharArrayBuffer.copy(this, mark);}

public override java.nio.CharBuffer asReadOnlyBuffer(){return java.nio.ReadOnlyCharArrayBuffer.copy(this, _mark);}

[User] public CharBuffer asReadOnlyBuffer() {return ReadOnlyCharArrayBuffer.copy(this, mark);}

[Assistant] public override java.nio.CharBuffer asReadOnlyBuffer(){return java.nio.ReadOnlyCharArrayBuffer.copy(this, _mark);}


public synchronized boolean add(E object) {if (elementCount == elementData.length) {growByOne();}elementData[elementCount++] = object;modCount++;return true;}

public override bool add(E @object){lock (this){if (elementCount == elementData.Length){growByOne();}elementData[elementCount++] = @object;modCount++;return true;}}

[User] public synchronized boolean add(E object) {if (elementCount == elementData.length) {growByOne();}elementData[elementCount++] = object;modCount++;return true;}

[Assistant] public override bool add(E @object){lock (this){if (elementCount == elementData.Length){growByOne();}elementData[elementCount++] = @object;modCount++;return true;}}


public TSTNode getNode(CharSequence key) {return getNode(key, rootNode);}

public virtual TSTNode GetNode(string key){return GetNode(key, rootNode);}

[User] public TSTNode getNode(CharSequence key) {return getNode(key, rootNode);}

[Assistant] public virtual TSTNode GetNode(string key){return GetNode(key, rootNode);}


public GetEventStreamResult getEventStream(GetEventStreamRequest request) {request = beforeClientExecution(request);return executeGetEventStream(request);}

public virtual GetEventStreamResponse GetEventStream(GetEventStreamRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetEventStreamRequestMarshaller.Instance;options.ResponseUnmarshaller = GetEventStreamResponseUnmarshaller.Instance;return Invoke<GetEventStreamResponse>(request, options);}

[User] public GetEventStreamResult getEventStream(GetEventStreamRequest request) {request = beforeClientExecution(request);return executeGetEventStream(request);}

[Assistant] public virtual GetEventStreamResponse GetEventStream(GetEventStreamRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetEventStreamRequestMarshaller.Instance;options.ResponseUnmarshaller = GetEventStreamResponseUnmarshaller.Instance;return Invoke<GetEventStreamResponse>(request, options);}


public SendMessageBatchResult sendMessageBatch(SendMessageBatchRequest request) {request = beforeClientExecution(request);return executeSendMessageBatch(request);}

public virtual SendMessageBatchResponse SendMessageBatch(SendMessageBatchRequest request){var options = new InvokeOptions();options.RequestMarshaller = SendMessageBatchRequestMarshaller.Instance;options.ResponseUnmarshaller = SendMessageBatchResponseUnmarshaller.Instance;return Invoke<SendMessageBatchResponse>(request, options);}

[User] public SendMessageBatchResult sendMessageBatch(SendMessageBatchRequest request) {request = beforeClientExecution(request);return executeSendMessageBatch(request);}

[Assistant] public virtual SendMessageBatchResponse SendMessageBatch(SendMessageBatchRequest request){var options = new InvokeOptions();options.RequestMarshaller = SendMessageBatchRequestMarshaller.Instance;options.ResponseUnmarshaller = SendMessageBatchResponseUnmarshaller.Instance;return Invoke<SendMessageBatchResponse>(request, options);}


public DescribeDirectConnectGatewayAttachmentsResult describeDirectConnectGatewayAttachments(DescribeDirectConnectGatewayAttachmentsRequest request) {request = beforeClientExecution(request);return executeDescribeDirectConnectGatewayAttachments(request);}

public virtual DescribeDirectConnectGatewayAttachmentsResponse DescribeDirectConnectGatewayAttachments(DescribeDirectConnectGatewayAttachmentsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeDirectConnectGatewayAttachmentsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeDirectConnectGatewayAttachmentsResponseUnmarshaller.Instance;return Invoke<DescribeDirectConnectGatewayAttachmentsResponse>(request, options);}

[User] public DescribeDirectConnectGatewayAttachmentsResult describeDirectConnectGatewayAttachments(DescribeDirectConnectGatewayAttachmentsRequest request) {request = beforeClientExecution(request);return executeDescribeDirectConnectGatewayAttachments(request);}

[Assistant] public virtual DescribeDirectConnectGatewayAttachmentsResponse DescribeDirectConnectGatewayAttachments(DescribeDirectConnectGatewayAttachmentsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeDirectConnectGatewayAttachmentsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeDirectConnectGatewayAttachmentsResponseUnmarshaller.Instance;return Invoke<DescribeDirectConnectGatewayAttachmentsResponse>(request, options);}


public Object add(Object prefix, Object output) {assert !(prefix instanceof List);if (!(output instanceof List)) {return outputs.add((T) prefix, (T) output);} else {List<T> outputList = (List<T>) output;List<T> addedList = new ArrayList<>(outputList.size());for(T _output : outputList) {addedList.add(outputs.add((T) prefix, _output));}return addedList;}}

public override object Add(object prefix, object output){Debug.Assert(!(prefix is IList));if (!(output is IList)){return outputs.Add((T)prefix, (T)output);}else{IList outputList = (IList)output;IList<T> addedList = new JCG.List<T>(outputList.Count);foreach (object _output in outputList){addedList.Add(outputs.Add((T)prefix, (T)_output));}return addedList;}}

[User] public Object add(Object prefix, Object output) {assert !(prefix instanceof List);if (!(output instanceof List)) {return outputs.add((T) prefix, (T) output);} else {List<T> outputList = (List<T>) output;List<T> addedList = new ArrayList<>(outputList.size());for(T _output : outputList) {addedList.add(outputs.add((T) prefix, _output));}return addedList;}}

[Assistant] public override object Add(object prefix, object output){Debug.Assert(!(prefix is IList));if (!(output is IList)){return outputs.Add((T)prefix, (T)output);}else{IList outputList = (IList)output;IList<T> addedList = new JCG.List<T>(outputList.Count);foreach (object _output in outputList){addedList.Add(outputs.Add((T)prefix, (T)_output));}return addedList;}}


public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1,ValueEval arg2, ValueEval arg3) {return evaluate(srcRowIndex, srcColumnIndex, arg0, arg1, arg2, arg3, DEFAULT_ARG4);}

public ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1,ValueEval arg2, ValueEval arg3){return Evaluate(srcRowIndex, srcColumnIndex, arg0, arg1, arg2, arg3, DEFAULT_ARG4);}

[User] public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1,ValueEval arg2, ValueEval arg3) {return evaluate(srcRowIndex, srcColumnIndex, arg0, arg1, arg2, arg3, DEFAULT_ARG4);}

[Assistant] public ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1,ValueEval arg2, ValueEval arg3){return Evaluate(srcRowIndex, srcColumnIndex, arg0, arg1, arg2, arg3, DEFAULT_ARG4);}


public static List<ParseTree> findAllNodes(ParseTree t, int index, boolean findTokens) {List<ParseTree> nodes = new ArrayList<ParseTree>();_findAllNodes(t, index, findTokens, nodes);return nodes;}

public static IList<IParseTree> FindAllNodes(IParseTree t, int index, bool findTokens){IList<IParseTree> nodes = new List<IParseTree>();_findAllNodes(t, index, findTokens, nodes);return nodes;}

[User] public static List<ParseTree> findAllNodes(ParseTree t, int index, boolean findTokens) {List<ParseTree> nodes = new ArrayList<ParseTree>();_findAllNodes(t, index, findTokens, nodes);return nodes;}

[Assistant] public static IList<IParseTree> FindAllNodes(IParseTree t, int index, bool findTokens){IList<IParseTree> nodes = new List<IParseTree>();_findAllNodes(t, index, findTokens, nodes);return nodes;}


public boolean containsChart() {EscherOptRecord optRecord = (EscherOptRecord)_boundAggregate.findFirstWithId(EscherOptRecord.RECORD_ID);if (optRecord == null) {return false;}for (EscherProperty prop : optRecord.getEscherProperties()) {if (prop.getPropertyNumber() == 896 && prop.isComplex()) {EscherComplexProperty cp = (EscherComplexProperty) prop;String str = StringUtil.getFromUnicodeLE(cp.getComplexData());if (str.equals("Chart 1\0")) {return true;}}}return false;}

public bool ContainsChart(){EscherOptRecord optRecord = (EscherOptRecord)_boundAggregate.FindFirstWithId(EscherOptRecord.RECORD_ID);if (optRecord == null){return false;}for (IEnumerator it = optRecord.EscherProperties.GetEnumerator(); it.MoveNext(); ){EscherProperty prop = (EscherProperty)it.Current;if (prop.PropertyNumber == 896 && prop.IsComplex){EscherComplexProperty cp = (EscherComplexProperty)prop;String str = StringUtil.GetFromUnicodeLE(cp.ComplexData);if (str.Equals("Chart 1\0")){return true;}}}return false;}

[User] public boolean containsChart() {EscherOptRecord optRecord = (EscherOptRecord)_boundAggregate.findFirstWithId(EscherOptRecord.RECORD_ID);if (optRecord == null) {return false;}for (EscherProperty prop : optRecord.getEscherProperties()) {if (prop.getPropertyNumber() == 896 && prop.isComplex()) {EscherComplexProperty cp = (EscherComplexProperty) prop;String str = StringUtil.getFromUnicodeLE(cp.getComplexData());if (str.equals("Chart 1\0")) {return true;}}}return false;}

[Assistant] public bool ContainsChart(){EscherOptRecord optRecord = (EscherOptRecord)_boundAggregate.FindFirstWithId(EscherOptRecord.RECORD_ID);if (optRecord == null){return false;}for (IEnumerator it = optRecord.EscherProperties.GetEnumerator(); it.MoveNext(); ){EscherProperty prop = (EscherProperty)it.Current;if (prop.PropertyNumber == 896 && prop.IsComplex){EscherComplexProperty cp = (EscherComplexProperty)prop;String str = StringUtil.GetFromUnicodeLE(cp.ComplexData);if (str.Equals("Chart 1\0")){return true;}}}return false;}


public virtual int getWidth(){return w;}

[User] public int getWidth() {return w;}

[Assistant] public virtual int getWidth(){return w;}


public StopInstanceResult stopInstance(StopInstanceRequest request) {request = beforeClientExecution(request);return executeStopInstance(request);}

public virtual StopInstanceResponse StopInstance(StopInstanceRequest request){var options = new InvokeOptions();options.RequestMarshaller = StopInstanceRequestMarshaller.Instance;options.ResponseUnmarshaller = StopInstanceResponseUnmarshaller.Instance;return Invoke<StopInstanceResponse>(request, options);}

[User] public StopInstanceResult stopInstance(StopInstanceRequest request) {request = beforeClientExecution(request);return executeStopInstance(request);}

[Assistant] public virtual StopInstanceResponse StopInstance(StopInstanceRequest request){var options = new InvokeOptions();options.RequestMarshaller = StopInstanceRequestMarshaller.Instance;options.ResponseUnmarshaller = StopInstanceResponseUnmarshaller.Instance;return Invoke<StopInstanceResponse>(request, options);}


public String toString() {StringBuilder buffer = new StringBuilder();buffer.append("[TABLE]\n");buffer.append("    .range    = ").append(getRange()).append("\n");buffer.append("    .flags    = ") .append(HexDump.byteToHex(field_5_flags)).append("\n");buffer.append("    .alwaysClc= ").append(isAlwaysCalc()).append("\n");buffer.append("    .reserved = ").append(HexDump.intToHex(field_6_res)).append("\n");CellReference crRowInput = cr(field_7_rowInputRow, field_8_colInputRow);CellReference crColInput = cr(field_9_rowInputCol, field_10_colInputCol);buffer.append("    .rowInput = ").append(crRowInput.formatAsString()).append("\n");buffer.append("    .colInput = ").append(crColInput.formatAsString()).append("\n");buffer.append("[/TABLE]\n");return buffer.toString();}

public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append("[TABLE]\n");buffer.Append("    .range    = ").Append(Range.ToString()).Append("\n");buffer.Append("    .flags    = ").Append(HexDump.ByteToHex(field_5_flags)).Append("\n");buffer.Append("    .alwaysClc= ").Append(IsAlwaysCalc).Append("\n");buffer.Append("    .reserved = ").Append(HexDump.IntToHex(field_6_res)).Append("\n");CellReference crRowInput = cr(field_7_rowInputRow, field_8_colInputRow);CellReference crColInput = cr(field_9_rowInputCol, field_10_colInputCol);buffer.Append("    .rowInput = ").Append(crRowInput.FormatAsString()).Append("\n");buffer.Append("    .colInput = ").Append(crColInput.FormatAsString()).Append("\n");buffer.Append("[/TABLE]\n");return buffer.ToString();}

[User] public String toString() {StringBuilder buffer = new StringBuilder();buffer.append("[TABLE]\n");buffer.append("    .range    = ").append(getRange()).append("\n");buffer.append("    .flags    = ") .append(HexDump.byteToHex(field_5_flags)).append("\n");buffer.append("    .alwaysClc= ").append(isAlwaysCalc()).append("\n");buffer.append("    .reserved = ").append(HexDump.intToHex(field_6_res)).append("\n");CellReference crRowInput = cr(field_7_rowInputRow, field_8_colInputRow);CellReference crColInput = cr(field_9_rowInputCol, field_10_colInputCol);buffer.append("    .rowInput = ").append(crRowInput.formatAsString()).append("\n");buffer.append("    .colInput = ").append(crColInput.formatAsString()).append("\n");buffer.append("[/TABLE]\n");return buffer.toString();}

[Assistant] public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append("[TABLE]\n");buffer.Append("    .range    = ").Append(Range.ToString()).Append("\n");buffer.Append("    .flags    = ").Append(HexDump.ByteToHex(field_5_flags)).Append("\n");buffer.Append("    .alwaysClc= ").Append(IsAlwaysCalc).Append("\n");buffer.Append("    .reserved = ").Append(HexDump.IntToHex(field_6_res)).Append("\n");CellReference crRowInput = cr(field_7_rowInputRow, field_8_colInputRow);CellReference crColInput = cr(field_9_rowInputCol, field_10_colInputCol);buffer.Append("    .rowInput = ").Append(crRowInput.FormatAsString()).Append("\n");buffer.Append("    .colInput = ").Append(crColInput.FormatAsString()).Append("\n");buffer.Append("[/TABLE]\n");return buffer.ToString();}


public RemoveTagsResult removeTags(RemoveTagsRequest request) {request = beforeClientExecution(request);return executeRemoveTags(request);}

public virtual RemoveTagsResponse RemoveTags(RemoveTagsRequest request){var options = new InvokeOptions();options.RequestMarshaller = RemoveTagsRequestMarshaller.Instance;options.ResponseUnmarshaller = RemoveTagsResponseUnmarshaller.Instance;return Invoke<RemoveTagsResponse>(request, options);}

[User] public RemoveTagsResult removeTags(RemoveTagsRequest request) {request = beforeClientExecution(request);return executeRemoveTags(request);}

[Assistant] public virtual RemoveTagsResponse RemoveTags(RemoveTagsRequest request){var options = new InvokeOptions();options.RequestMarshaller = RemoveTagsRequestMarshaller.Instance;options.ResponseUnmarshaller = RemoveTagsResponseUnmarshaller.Instance;return Invoke<RemoveTagsResponse>(request, options);}


public boolean hasNext() {if (next == null)next = peek();return next != null;}

public override bool HasNext(){if (this.next == null){this.next = this.Peek();}return this.next != null;}

[User] public boolean hasNext() {if (next == null)next = peek();return next != null;}

[Assistant] public override bool HasNext(){if (this.next == null){this.next = this.Peek();}return this.next != null;}


public long byteCount(int packedIntsVersion, int valueCount, int bitsPerValue) {return (long) Math.ceil((double) valueCount * bitsPerValue / 8);}

public virtual long ByteCount(int packedIntsVersion, int valueCount, int bitsPerValue){return 8L * Int64Count(packedIntsVersion, valueCount, bitsPerValue);}

[User] public long byteCount(int packedIntsVersion, int valueCount, int bitsPerValue) {return (long) Math.ceil((double) valueCount * bitsPerValue / 8);}

[Assistant] public virtual long ByteCount(int packedIntsVersion, int valueCount, int bitsPerValue){return 8L * Int64Count(packedIntsVersion, valueCount, bitsPerValue);}


public GetQueueUrlRequest(String queueName) {setQueueName(queueName);}

public GetQueueUrlRequest(string queueName){_queueName = queueName;}

[User] public GetQueueUrlRequest(String queueName) {setQueueName(queueName);}

[Assistant] public GetQueueUrlRequest(string queueName){_queueName = queueName;}


public void addEscherRecord(int index, EscherRecord element){escherRecords.add( index, element );}

public void AddEscherRecord(int index, EscherRecord element){escherRecords.Insert(index, element);}

[User] public void addEscherRecord(int index, EscherRecord element){escherRecords.add( index, element );}

[Assistant] public void AddEscherRecord(int index, EscherRecord element){escherRecords.Insert(index, element);}


public ListInstanceGroupsResult listInstanceGroups(ListInstanceGroupsRequest request) {request = beforeClientExecution(request);return executeListInstanceGroups(request);}

public virtual ListInstanceGroupsResponse ListInstanceGroups(ListInstanceGroupsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListInstanceGroupsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListInstanceGroupsResponseUnmarshaller.Instance;return Invoke<ListInstanceGroupsResponse>(request, options);}

[User] public ListInstanceGroupsResult listInstanceGroups(ListInstanceGroupsRequest request) {request = beforeClientExecution(request);return executeListInstanceGroups(request);}

[Assistant] public virtual ListInstanceGroupsResponse ListInstanceGroups(ListInstanceGroupsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListInstanceGroupsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListInstanceGroupsResponseUnmarshaller.Instance;return Invoke<ListInstanceGroupsResponse>(request, options);}


public TruncateTokenFilterFactory(Map<String, String> args) {super(args);prefixLength = Byte.parseByte(get(args, PREFIX_LENGTH_KEY, "5"));if (prefixLength < 1)throw new IllegalArgumentException(PREFIX_LENGTH_KEY + " parameter must be a positive number: " + prefixLength);if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameter(s): " + args);}}

public TruncateTokenFilterFactory(IDictionary<string, string> args): base(args){var prefixLengthString = Get(args, PREFIX_LENGTH_KEY, "5");prefixLength = sbyte.Parse(prefixLengthString, NumberStyles.Integer, CultureInfo.InvariantCulture);if (prefixLength < 1){throw new System.ArgumentException(PREFIX_LENGTH_KEY + " parameter must be a positive number: " + prefixLengthString);}if (args.Count > 0){throw new System.ArgumentException("Unknown parameter(s): " + args);}}

[User] public TruncateTokenFilterFactory(Map<String, String> args) {super(args);prefixLength = Byte.parseByte(get(args, PREFIX_LENGTH_KEY, "5"));if (prefixLength < 1)throw new IllegalArgumentException(PREFIX_LENGTH_KEY + " parameter must be a positive number: " + prefixLength);if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameter(s): " + args);}}

[Assistant] public TruncateTokenFilterFactory(IDictionary<string, string> args): base(args){var prefixLengthString = Get(args, PREFIX_LENGTH_KEY, "5");prefixLength = sbyte.Parse(prefixLengthString, NumberStyles.Integer, CultureInfo.InvariantCulture);if (prefixLength < 1){throw new System.ArgumentException(PREFIX_LENGTH_KEY + " parameter must be a positive number: " + prefixLengthString);}if (args.Count > 0){throw new System.ArgumentException("Unknown parameter(s): " + args);}}


public GetDetectorResult getDetector(GetDetectorRequest request) {request = beforeClientExecution(request);return executeGetDetector(request);}

public virtual GetDetectorResponse GetDetector(GetDetectorRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetDetectorRequestMarshaller.Instance;options.ResponseUnmarshaller = GetDetectorResponseUnmarshaller.Instance;return Invoke<GetDetectorResponse>(request, options);}

[User] public GetDetectorResult getDetector(GetDetectorRequest request) {request = beforeClientExecution(request);return executeGetDetector(request);}

[Assistant] public virtual GetDetectorResponse GetDetector(GetDetectorRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetDetectorRequestMarshaller.Instance;options.ResponseUnmarshaller = GetDetectorResponseUnmarshaller.Instance;return Invoke<GetDetectorResponse>(request, options);}


public void set(int index, int n) {if (count < index)throw new ArrayIndexOutOfBoundsException(index);else if (count == index)add(n);elseentries[index] = n;}

public virtual void Set(int index, int n){if (count < index){throw Sharpen.Extensions.CreateIndexOutOfRangeException(index);}else{if (count == index){Add(n);}else{entries[index] = n;}}}

[User] public void set(int index, int n) {if (count < index)throw new ArrayIndexOutOfBoundsException(index);else if (count == index)add(n);elseentries[index] = n;}

[Assistant] public virtual void Set(int index, int n){if (count < index){throw Sharpen.Extensions.CreateIndexOutOfRangeException(index);}else{if (count == index){Add(n);}else{entries[index] = n;}}}


public StatePair(int s1, int s2) {this.s1 = s1;this.s2 = s2;this.s = -1;}

public StatePair(State s1, State s2){this.S1 = s1;this.S2 = s2;}

[User] public StatePair(int s1, int s2) {this.s1 = s1;this.s2 = s2;this.s = -1;}

[Assistant] public StatePair(State s1, State s2){this.S1 = s1;this.S2 = s2;}


public DetachDiskResult detachDisk(DetachDiskRequest request) {request = beforeClientExecution(request);return executeDetachDisk(request);}

public virtual DetachDiskResponse DetachDisk(DetachDiskRequest request){var options = new InvokeOptions();options.RequestMarshaller = DetachDiskRequestMarshaller.Instance;options.ResponseUnmarshaller = DetachDiskResponseUnmarshaller.Instance;return Invoke<DetachDiskResponse>(request, options);}

[User] public DetachDiskResult detachDisk(DetachDiskRequest request) {request = beforeClientExecution(request);return executeDetachDisk(request);}

[Assistant] public virtual DetachDiskResponse DetachDisk(DetachDiskRequest request){var options = new InvokeOptions();options.RequestMarshaller = DetachDiskRequestMarshaller.Instance;options.ResponseUnmarshaller = DetachDiskResponseUnmarshaller.Instance;return Invoke<DetachDiskResponse>(request, options);}


[User] public void clear() {count = 0;}

[Assistant] public virtual void Clear(){count = 0;}


public ListIterator<E> listIterator() {return delegate().listIterator(); }

public virtual java.util.ListIterator<E> listIterator(){lock (mutex){return list.listIterator();}}

[User] public ListIterator<E> listIterator() {return delegate().listIterator(); }

[Assistant] public virtual java.util.ListIterator<E> listIterator(){lock (mutex){return list.listIterator();}}


public FieldDoc(int doc, float score, Object[] fields, int shardIndex) {super(doc, score, shardIndex);this.fields = fields;}

public FieldDoc(int doc, float score, object[] fields, int shardIndex): base(doc, score, shardIndex){this.fields = fields;}

[User] public FieldDoc(int doc, float score, Object[] fields, int shardIndex) {super(doc, score, shardIndex);this.fields = fields;}

[Assistant] public FieldDoc(int doc, float score, object[] fields, int shardIndex): base(doc, score, shardIndex){this.fields = fields;}


public ResourceRecord(String value) {setValue(value);}

public ResourceRecord(string value){_value = value;}

[User] public ResourceRecord(String value) {setValue(value);}

[Assistant] public ResourceRecord(string value){_value = value;}


public String getAuthority() {return decode(authority);}

public string getAuthority(){return decode(authority);}

[User] public String getAuthority() {return decode(authority);}

[Assistant] public string getAuthority(){return decode(authority);}


public void flush() throws IOException {drain();output.flush();}

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

[User] public void flush() throws IOException {drain();output.flush();}

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


public ListMultipartUploadsRequest(String accountId, String vaultName) {setAccountId(accountId);setVaultName(vaultName);}

public ListMultipartUploadsRequest(string accountId, string vaultName){_accountId = accountId;_vaultName = vaultName;}

[User] public ListMultipartUploadsRequest(String accountId, String vaultName) {setAccountId(accountId);setVaultName(vaultName);}

[Assistant] public ListMultipartUploadsRequest(string accountId, string vaultName){_accountId = accountId;_vaultName = vaultName;}


public UpdateRouteResponseResult updateRouteResponse(UpdateRouteResponseRequest request) {request = beforeClientExecution(request);return executeUpdateRouteResponse(request);}

public virtual UpdateRouteResponseResponse UpdateRouteResponse(UpdateRouteResponseRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateRouteResponseRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateRouteResponseResponseUnmarshaller.Instance;return Invoke<UpdateRouteResponseResponse>(request, options);}

[User] public UpdateRouteResponseResult updateRouteResponse(UpdateRouteResponseRequest request) {request = beforeClientExecution(request);return executeUpdateRouteResponse(request);}

[Assistant] public virtual UpdateRouteResponseResponse UpdateRouteResponse(UpdateRouteResponseRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateRouteResponseRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateRouteResponseResponseUnmarshaller.Instance;return Invoke<UpdateRouteResponseResponse>(request, options);}


public boolean containsKey(Object name) {return get(name) != null;}

public override bool ContainsKey(object name){return Get(name) != null;}

[User] public boolean containsKey(Object name) {return get(name) != null;}

[Assistant] public override bool ContainsKey(object name){return Get(name) != null;}


public SimpleRateLimiter(double mbPerSec) {setMBPerSec(mbPerSec);lastNS = System.nanoTime();}

[User] public SimpleRateLimiter(double mbPerSec) {setMBPerSec(mbPerSec);lastNS = System.nanoTime();}

[Assistant] public SimpleRateLimiter(double mbPerSec){SetMbPerSec(mbPerSec);}


public void releaseSession(RemoteSession session) {session.disconnect();}

public virtual void ReleaseSession(RemoteSession session){session.Disconnect();}

[User] public void releaseSession(RemoteSession session) {session.disconnect();}

[Assistant] public virtual void ReleaseSession(RemoteSession session){session.Disconnect();}


public SetQuotaRequest() {super("CloudPhoto", "2017-07-11", "SetQuota", "cloudphoto");setProtocol(ProtocolType.HTTPS);}

public SetQuotaRequest(): base("CloudPhoto", "2017-07-11", "SetQuota", "cloudphoto", "openAPI"){Protocol = ProtocolType.HTTPS;}

[User] public SetQuotaRequest() {super("CloudPhoto", "2017-07-11", "SetQuota", "cloudphoto");setProtocol(ProtocolType.HTTPS);}

[Assistant] public SetQuotaRequest(): base("CloudPhoto", "2017-07-11", "SetQuota", "cloudphoto", "openAPI"){Protocol = ProtocolType.HTTPS;}


public ParserATNSimulator(Parser parser, ATN atn,DFA[] decisionToDFA,PredictionContextCache sharedContextCache){super(atn, sharedContextCache);this.parser = parser;this.decisionToDFA = decisionToDFA;}

public ParserATNSimulator(Parser parser, ATN atn,DFA[] decisionToDFA,PredictionContextCache sharedContextCache): base(atn, sharedContextCache){this.parser = parser;this.decisionToDFA = decisionToDFA;}

[User] public ParserATNSimulator(Parser parser, ATN atn,DFA[] decisionToDFA,PredictionContextCache sharedContextCache){super(atn, sharedContextCache);this.parser = parser;this.decisionToDFA = decisionToDFA;}

[Assistant] public ParserATNSimulator(Parser parser, ATN atn,DFA[] decisionToDFA,PredictionContextCache sharedContextCache): base(atn, sharedContextCache){this.parser = parser;this.decisionToDFA = decisionToDFA;}


public void remove() {Object[] a = array;int removalIdx = removalIndex;if (modCount != expectedModCount) {throw new ConcurrentModificationException();}if (removalIdx < 0) {throw new IllegalStateException();}System.arraycopy(a, removalIdx + 1, a, removalIdx, remaining);a[--size] = null;  removalIndex = -1;expectedModCount = ++modCount;}

public virtual void remove(){object[] a = this._enclosing.array;int removalIdx = this.removalIndex;if (this._enclosing.modCount != this.expectedModCount){throw new java.util.ConcurrentModificationException();}if (removalIdx < 0){throw new System.InvalidOperationException();}System.Array.Copy(a, removalIdx + 1, a, removalIdx, this.remaining);a[--this._enclosing._size] = null;this.removalIndex = -1;this.expectedModCount = ++this._enclosing.modCount;}

[User] public void remove() {Object[] a = array;int removalIdx = removalIndex;if (modCount != expectedModCount) {throw new ConcurrentModificationException();}if (removalIdx < 0) {throw new IllegalStateException();}System.arraycopy(a, removalIdx + 1, a, removalIdx, remaining);a[--size] = null;  removalIndex = -1;expectedModCount = ++modCount;}

[Assistant] public virtual void remove(){object[] a = this._enclosing.array;int removalIdx = this.removalIndex;if (this._enclosing.modCount != this.expectedModCount){throw new java.util.ConcurrentModificationException();}if (removalIdx < 0){throw new System.InvalidOperationException();}System.Array.Copy(a, removalIdx + 1, a, removalIdx, this.remaining);a[--this._enclosing._size] = null;this.removalIndex = -1;this.expectedModCount = ++this._enclosing.modCount;}


public T getPointAt(int index) {return elements[index];}

public T GetPointAt(int index) {return elements[index];}

[User] public T getPointAt(int index) {return elements[index];}

[Assistant] public T GetPointAt(int index) {return elements[index];}


public StatusCommand setWorkingTreeIt(WorkingTreeIterator workingTreeIt) {this.workingTreeIt = workingTreeIt;return this;}

public virtual NGit.Api.StatusCommand SetWorkingTreeIt(WorkingTreeIterator workingTreeIt){this.workingTreeIt = workingTreeIt;return this;}

[User] public StatusCommand setWorkingTreeIt(WorkingTreeIterator workingTreeIt) {this.workingTreeIt = workingTreeIt;return this;}

[Assistant] public virtual NGit.Api.StatusCommand SetWorkingTreeIt(WorkingTreeIterator workingTreeIt){this.workingTreeIt = workingTreeIt;return this;}


public CharBlockArray append(CharSequence chars) {return append(chars, 0, chars.length());}

public virtual CharBlockArray Append(ICharSequence chars){return Append(chars, 0, chars.Length);}

[User] public CharBlockArray append(CharSequence chars) {return append(chars, 0, chars.length());}

[Assistant] public virtual CharBlockArray Append(ICharSequence chars){return Append(chars, 0, chars.Length);}


public override void Clear(){current.Clear();}

[User] public void clear() {current.clear();}

[Assistant] public override void Clear(){current.Clear();}


public String toFormulaString() {return FormulaError.forInt(field_1_error_code).getString();}

public override String ToFormulaString(){return HSSFErrorConstants.GetText(field_1_error_code);}

[User] public String toFormulaString() {return FormulaError.forInt(field_1_error_code).getString();}

[Assistant] public override String ToFormulaString(){return HSSFErrorConstants.GetText(field_1_error_code);}


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

public override Object Clone(){FtPioGrbitSubRecord rec = new FtPioGrbitSubRecord();rec.flags = this.flags;return rec;}

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

[Assistant] public override Object Clone(){FtPioGrbitSubRecord rec = new FtPioGrbitSubRecord();rec.flags = this.flags;return rec;}


public PositionSpan(int start, int end) {this.start = start;this.end = end;}

public PositionSpan(int start, int end){this.Start = start;this.End = end;}

[User] public PositionSpan(int start, int end) {this.start = start;this.end = end;}

[Assistant] public PositionSpan(int start, int end){this.Start = start;this.End = end;}


public void setParams(String params) {super.setParams(params);StringTokenizer st = new StringTokenizer(params, ",");while (st.hasMoreTokens()) {String param = st.nextToken();StringTokenizer expr = new StringTokenizer(param, ":");String key = expr.nextToken();String value = expr.nextToken();if (key.equals("impl")) {if (value.equalsIgnoreCase("icu"))impl = Implementation.ICU;else if (value.equalsIgnoreCase("jdk"))impl = Implementation.JDK;elsethrow new RuntimeException("Unknown parameter " + param);} else {throw new RuntimeException("Unknown parameter " + param);}}}

public override void SetParams(string @params){base.SetParams(@params);StringTokenizer st = new StringTokenizer(@params, ",");while (st.MoveNext()){string param = st.Current;StringTokenizer expr = new StringTokenizer(param, ":");string key = expr.MoveNext() ? expr.Current : string.Empty;string value = expr.MoveNext() ? expr.Current : string.Empty;if (key.Equals("impl", StringComparison.Ordinal)){if (value.Equals("icu", StringComparison.OrdinalIgnoreCase))impl = Implementation.ICU;elsethrow new Exception("Unknown parameter " + param);}else{throw new Exception("Unknown parameter " + param);}}}

[User] public void setParams(String params) {super.setParams(params);StringTokenizer st = new StringTokenizer(params, ",");while (st.hasMoreTokens()) {String param = st.nextToken();StringTokenizer expr = new StringTokenizer(param, ":");String key = expr.nextToken();String value = expr.nextToken();if (key.equals("impl")) {if (value.equalsIgnoreCase("icu"))impl = Implementation.ICU;else if (value.equalsIgnoreCase("jdk"))impl = Implementation.JDK;elsethrow new RuntimeException("Unknown parameter " + param);} else {throw new RuntimeException("Unknown parameter " + param);}}}

[Assistant] public override void SetParams(string @params){base.SetParams(@params);StringTokenizer st = new StringTokenizer(@params, ",");while (st.MoveNext()){string param = st.Current;StringTokenizer expr = new StringTokenizer(param, ":");string key = expr.MoveNext() ? expr.Current : string.Empty;string value = expr.MoveNext() ? expr.Current : string.Empty;if (key.Equals("impl", StringComparison.Ordinal)){if (value.Equals("icu", StringComparison.OrdinalIgnoreCase))impl = Implementation.ICU;elsethrow new Exception("Unknown parameter " + param);}else{throw new Exception("Unknown parameter " + param);}}}


public DeleteBuildResult deleteBuild(DeleteBuildRequest request) {request = beforeClientExecution(request);return executeDeleteBuild(request);}

public virtual DeleteBuildResponse DeleteBuild(DeleteBuildRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteBuildRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteBuildResponseUnmarshaller.Instance;return Invoke<DeleteBuildResponse>(request, options);}

[User] public DeleteBuildResult deleteBuild(DeleteBuildRequest request) {request = beforeClientExecution(request);return executeDeleteBuild(request);}

[Assistant] public virtual DeleteBuildResponse DeleteBuild(DeleteBuildRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteBuildRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteBuildResponseUnmarshaller.Instance;return Invoke<DeleteBuildResponse>(request, options);}


public DescribeVolumeStatusResult describeVolumeStatus() {return describeVolumeStatus(new DescribeVolumeStatusRequest());}

public virtual DescribeVolumeStatusResponse DescribeVolumeStatus(){return DescribeVolumeStatus(new DescribeVolumeStatusRequest());}

[User] public DescribeVolumeStatusResult describeVolumeStatus() {return describeVolumeStatus(new DescribeVolumeStatusRequest());}

[Assistant] public virtual DescribeVolumeStatusResponse DescribeVolumeStatus(){return DescribeVolumeStatus(new DescribeVolumeStatusRequest());}


public virtual string getFlags(){return f;}

[User] public String getFlags() {return f;}

[Assistant] public virtual string getFlags(){return f;}


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

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

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

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


public PatternReplaceFilter create(TokenStream input) {return new PatternReplaceFilter(input, pattern, replacement, replaceAll);}

public override TokenStream Create(TokenStream input){return new PatternReplaceFilter(input, pattern, replacement, replaceAll);}

[User] public PatternReplaceFilter create(TokenStream input) {return new PatternReplaceFilter(input, pattern, replacement, replaceAll);}

[Assistant] public override TokenStream Create(TokenStream input){return new PatternReplaceFilter(input, pattern, replacement, replaceAll);}


public void reset() throws IOException {drain();output.writeByte(TC_RESET);resetState();}

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

[User] public void reset() throws IOException {drain();output.writeByte(TC_RESET);resetState();}

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


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

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

[User] public Ptg get3DReferencePtg(CellReference cr, SheetIdentifier sheet) {int extIx = getSheetExtIx(sheet);return new Ref3DPtg(cr, extIx);}

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


public static void fill(boolean[] array, int start, int end, boolean value) {Arrays.checkStartAndEnd(array.length, start, end);for (int i = start; i < end; i++) {array[i] = value;}}

public static void fill(bool[] array, int start, int end, bool value){java.util.Arrays.checkStartAndEnd(array.Length, start, end);{for (int i = start; i < end; i++){array[i] = value;}}}

[User] public static void fill(boolean[] array, int start, int end, boolean value) {Arrays.checkStartAndEnd(array.length, start, end);for (int i = start; i < end; i++) {array[i] = value;}}

[Assistant] public static void fill(bool[] array, int start, int end, bool value){java.util.Arrays.checkStartAndEnd(array.Length, start, end);{for (int i = start; i < end; i++){array[i] = value;}}}


public TokenStream create(TokenStream input) {return new ICUFoldingFilter(input, normalizer);}

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

[User] public TokenStream create(TokenStream input) {return new ICUFoldingFilter(input, normalizer);}

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


public CharSequence toQueryString(EscapeQuerySyntax escaper) {return "[NTF]";}

public override string ToQueryString(IEscapeQuerySyntax escaper){return "[NTF]";}

[User] public CharSequence toQueryString(EscapeQuerySyntax escaper) {return "[NTF]";}

[Assistant] public override string ToQueryString(IEscapeQuerySyntax escaper){return "[NTF]";}


public StashCreateCommand setWorkingDirectoryMessage(String message) {workingDirectoryMessage = message;return this;}

public virtual NGit.Api.StashCreateCommand SetWorkingDirectoryMessage(string message){workingDirectoryMessage = message;return this;}

[User] public StashCreateCommand setWorkingDirectoryMessage(String message) {workingDirectoryMessage = message;return this;}

[Assistant] public virtual NGit.Api.StashCreateCommand SetWorkingDirectoryMessage(string message){workingDirectoryMessage = message;return this;}


public SheetRangeEvaluator(int onlySheetIndex, SheetRefEvaluator sheetEvaluator) {this(onlySheetIndex, onlySheetIndex, new SheetRefEvaluator[] {sheetEvaluator});}

public SheetRangeEvaluator(int onlySheetIndex, SheetRefEvaluator sheetEvaluator): this(onlySheetIndex, onlySheetIndex, new SheetRefEvaluator[] { sheetEvaluator }

[User] public SheetRangeEvaluator(int onlySheetIndex, SheetRefEvaluator sheetEvaluator) {this(onlySheetIndex, onlySheetIndex, new SheetRefEvaluator[] {sheetEvaluator});}

[Assistant] public SheetRangeEvaluator(int onlySheetIndex, SheetRefEvaluator sheetEvaluator): this(onlySheetIndex, onlySheetIndex, new SheetRefEvaluator[] { sheetEvaluator }


public static long[] grow(long[] array, int minSize) {assert minSize >= 0: "size must be positive (got " + minSize + "): likely integer overflow?";if (array.length < minSize) {return growExact(array, oversize(minSize, Long.BYTES));} elsereturn array;}

public static int[] Grow(int[] array, int minSize){Debug.Assert(minSize >= 0, "size must be positive (got " + minSize + "): likely integer overflow?");if (array.Length < minSize){int[] newArray = new int[Oversize(minSize, RamUsageEstimator.NUM_BYTES_INT32)];Array.Copy(array, 0, newArray, 0, array.Length);return newArray;}else{return array;}}

[User] public static long[] grow(long[] array, int minSize) {assert minSize >= 0: "size must be positive (got " + minSize + "): likely integer overflow?";if (array.length < minSize) {return growExact(array, oversize(minSize, Long.BYTES));} elsereturn array;}

[Assistant] public static int[] Grow(int[] array, int minSize){Debug.Assert(minSize >= 0, "size must be positive (got " + minSize + "): likely integer overflow?");if (array.Length < minSize){int[] newArray = new int[Oversize(minSize, RamUsageEstimator.NUM_BYTES_INT32)];Array.Copy(array, 0, newArray, 0, array.Length);return newArray;}else{return array;}}


public static RevFilter create(Collection<RevFilter> list) {if (list.size() < 2)throw new IllegalArgumentException(JGitText.get().atLeastTwoFiltersNeeded);final RevFilter[] subfilters = new RevFilter[list.size()];list.toArray(subfilters);if (subfilters.length == 2)return create(subfilters[0], subfilters[1]);return new List(subfilters);}

public static RevFilter Create(ICollection<RevFilter> list){if (list.Count < 2){throw new ArgumentException(JGitText.Get().atLeastTwoFiltersNeeded);}RevFilter[] subfilters = new RevFilter[list.Count];Sharpen.Collections.ToArray(list, subfilters);if (subfilters.Length == 2){return Create(subfilters[0], subfilters[1]);}return new OrRevFilter.List(subfilters);}

[User] public static RevFilter create(Collection<RevFilter> list) {if (list.size() < 2)throw new IllegalArgumentException(JGitText.get().atLeastTwoFiltersNeeded);final RevFilter[] subfilters = new RevFilter[list.size()];list.toArray(subfilters);if (subfilters.length == 2)return create(subfilters[0], subfilters[1]);return new List(subfilters);}

[Assistant] public static RevFilter Create(ICollection<RevFilter> list){if (list.Count < 2){throw new ArgumentException(JGitText.Get().atLeastTwoFiltersNeeded);}RevFilter[] subfilters = new RevFilter[list.Count];Sharpen.Collections.ToArray(list, subfilters);if (subfilters.Length == 2){return Create(subfilters[0], subfilters[1]);}return new OrRevFilter.List(subfilters);}


public DeregisterOnPremisesInstanceResult deregisterOnPremisesInstance(DeregisterOnPremisesInstanceRequest request) {request = beforeClientExecution(request);return executeDeregisterOnPremisesInstance(request);}

public virtual DeregisterOnPremisesInstanceResponse DeregisterOnPremisesInstance(DeregisterOnPremisesInstanceRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeregisterOnPremisesInstanceRequestMarshaller.Instance;options.ResponseUnmarshaller = DeregisterOnPremisesInstanceResponseUnmarshaller.Instance;return Invoke<DeregisterOnPremisesInstanceResponse>(request, options);}

[User] public DeregisterOnPremisesInstanceResult deregisterOnPremisesInstance(DeregisterOnPremisesInstanceRequest request) {request = beforeClientExecution(request);return executeDeregisterOnPremisesInstance(request);}

[Assistant] public virtual DeregisterOnPremisesInstanceResponse DeregisterOnPremisesInstance(DeregisterOnPremisesInstanceRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeregisterOnPremisesInstanceRequestMarshaller.Instance;options.ResponseUnmarshaller = DeregisterOnPremisesInstanceResponseUnmarshaller.Instance;return Invoke<DeregisterOnPremisesInstanceResponse>(request, options);}


public ListDeliverabilityTestReportsResult listDeliverabilityTestReports(ListDeliverabilityTestReportsRequest request) {request = beforeClientExecution(request);return executeListDeliverabilityTestReports(request);}

public virtual ListDeliverabilityTestReportsResponse ListDeliverabilityTestReports(ListDeliverabilityTestReportsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListDeliverabilityTestReportsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListDeliverabilityTestReportsResponseUnmarshaller.Instance;return Invoke<ListDeliverabilityTestReportsResponse>(request, options);}

[User] public ListDeliverabilityTestReportsResult listDeliverabilityTestReports(ListDeliverabilityTestReportsRequest request) {request = beforeClientExecution(request);return executeListDeliverabilityTestReports(request);}

[Assistant] public virtual ListDeliverabilityTestReportsResponse ListDeliverabilityTestReports(ListDeliverabilityTestReportsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListDeliverabilityTestReportsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListDeliverabilityTestReportsResponseUnmarshaller.Instance;return Invoke<ListDeliverabilityTestReportsResponse>(request, options);}


public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0,ValueEval arg1) {double dn;try {ValueEval ve1 = OperandResolver.getSingleValue(arg1, srcRowIndex, srcColumnIndex);dn = OperandResolver.coerceValueToDouble(ve1);} catch (EvaluationException e1) {return ErrorEval.VALUE_INVALID;}if (dn < 1.0) {return ErrorEval.NUM_ERROR;}int k = (int) Math.ceil(dn);double result;try {double[] ds = ValueCollector.collectValues(arg0);if (k > ds.length) {return ErrorEval.NUM_ERROR;}result = _isLarge ? StatsLib.kthLargest(ds, k) : StatsLib.kthSmallest(ds, k);NumericFunction.checkValue(result);} catch (EvaluationException e) {return e.getErrorEval();}return new NumberEval(result);}

public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0,ValueEval arg1){double dn;try{ValueEval ve1 = OperandResolver.GetSingleValue(arg1, srcRowIndex, srcColumnIndex);dn = OperandResolver.CoerceValueToDouble(ve1);}catch (EvaluationException){return ErrorEval.VALUE_INVALID;}if (dn < 1.0){return ErrorEval.NUM_ERROR;}int k = (int)Math.Ceiling(dn);double result;try{double[] ds = NPOI.SS.Formula.Functions.AggregateFunction.ValueCollector.CollectValues(arg0);if (k > ds.Length){return ErrorEval.NUM_ERROR;}result = _isLarge ? StatsLib.kthLargest(ds, k) : StatsLib.kthSmallest(ds, k);NumericFunction.CheckValue(result);}catch (EvaluationException e){return e.GetErrorEval();}return new NumberEval(result);}

[User] public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0,ValueEval arg1) {double dn;try {ValueEval ve1 = OperandResolver.getSingleValue(arg1, srcRowIndex, srcColumnIndex);dn = OperandResolver.coerceValueToDouble(ve1);} catch (EvaluationException e1) {return ErrorEval.VALUE_INVALID;}if (dn < 1.0) {return ErrorEval.NUM_ERROR;}int k = (int) Math.ceil(dn);double result;try {double[] ds = ValueCollector.collectValues(arg0);if (k > ds.length) {return ErrorEval.NUM_ERROR;}result = _isLarge ? StatsLib.kthLargest(ds, k) : StatsLib.kthSmallest(ds, k);NumericFunction.checkValue(result);} catch (EvaluationException e) {return e.getErrorEval();}return new NumberEval(result);}

[Assistant] public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0,ValueEval arg1){double dn;try{ValueEval ve1 = OperandResolver.GetSingleValue(arg1, srcRowIndex, srcColumnIndex);dn = OperandResolver.CoerceValueToDouble(ve1);}catch (EvaluationException){return ErrorEval.VALUE_INVALID;}if (dn < 1.0){return ErrorEval.NUM_ERROR;}int k = (int)Math.Ceiling(dn);double result;try{double[] ds = NPOI.SS.Formula.Functions.AggregateFunction.ValueCollector.CollectValues(arg0);if (k > ds.Length){return ErrorEval.NUM_ERROR;}result = _isLarge ? StatsLib.kthLargest(ds, k) : StatsLib.kthSmallest(ds, k);NumericFunction.CheckValue(result);}catch (EvaluationException e){return e.GetErrorEval();}return new NumberEval(result);}


[User] public ByteArrayDataInput() {reset(BytesRef.EMPTY_BYTES);}

[Assistant] public ByteArrayDataInput(){Reset(BytesRef.EMPTY_BYTES);}


public ByteBuffer putDouble(double value) {throw new ReadOnlyBufferException();}

public override java.nio.ByteBuffer putDouble(double value){throw new System.NotImplementedException();}

[User] public ByteBuffer putDouble(double value) {throw new ReadOnlyBufferException();}

[Assistant] public override java.nio.ByteBuffer putDouble(double value){throw new System.NotImplementedException();}


public ChangeMessageVisibilityResult changeMessageVisibility(ChangeMessageVisibilityRequest request) {request = beforeClientExecution(request);return executeChangeMessageVisibility(request);}

public virtual ChangeMessageVisibilityResponse ChangeMessageVisibility(ChangeMessageVisibilityRequest request){var options = new InvokeOptions();options.RequestMarshaller = ChangeMessageVisibilityRequestMarshaller.Instance;options.ResponseUnmarshaller = ChangeMessageVisibilityResponseUnmarshaller.Instance;return Invoke<ChangeMessageVisibilityResponse>(request, options);}

[User] public ChangeMessageVisibilityResult changeMessageVisibility(ChangeMessageVisibilityRequest request) {request = beforeClientExecution(request);return executeChangeMessageVisibility(request);}

[Assistant] public virtual ChangeMessageVisibilityResponse ChangeMessageVisibility(ChangeMessageVisibilityRequest request){var options = new InvokeOptions();options.RequestMarshaller = ChangeMessageVisibilityRequestMarshaller.Instance;options.ResponseUnmarshaller = ChangeMessageVisibilityResponseUnmarshaller.Instance;return Invoke<ChangeMessageVisibilityResponse>(request, options);}


public UpdateWorkGroupResult updateWorkGroup(UpdateWorkGroupRequest request) {request = beforeClientExecution(request);return executeUpdateWorkGroup(request);}

public virtual UpdateWorkGroupResponse UpdateWorkGroup(UpdateWorkGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateWorkGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateWorkGroupResponseUnmarshaller.Instance;return Invoke<UpdateWorkGroupResponse>(request, options);}

[User] public UpdateWorkGroupResult updateWorkGroup(UpdateWorkGroupRequest request) {request = beforeClientExecution(request);return executeUpdateWorkGroup(request);}

[Assistant] public virtual UpdateWorkGroupResponse UpdateWorkGroup(UpdateWorkGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateWorkGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateWorkGroupResponseUnmarshaller.Instance;return Invoke<UpdateWorkGroupResponse>(request, options);}


public NavigableMap<K, V> tailMap(K fromInclusive) {return subMap(fromInclusive, INCLUSIVE, null, NO_BOUND);}

public java.util.NavigableMap<K, V> tailMap(K fromInclusive){return this.subMap(fromInclusive, java.util.TreeMap.Bound.INCLUSIVE, default(K),java.util.TreeMap.Bound.NO_BOUND);}

[User] public NavigableMap<K, V> tailMap(K fromInclusive) {return subMap(fromInclusive, INCLUSIVE, null, NO_BOUND);}

[Assistant] public java.util.NavigableMap<K, V> tailMap(K fromInclusive){return this.subMap(fromInclusive, java.util.TreeMap.Bound.INCLUSIVE, default(K),java.util.TreeMap.Bound.NO_BOUND);}


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

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

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


public BlameCommand setStartCommit(AnyObjectId commit) {this.startCommit = commit.toObjectId();return this;}

public virtual NGit.Api.BlameCommand SetStartCommit(AnyObjectId commit){this.startCommit = commit.ToObjectId();return this;}

[User] public BlameCommand setStartCommit(AnyObjectId commit) {this.startCommit = commit.toObjectId();return this;}

[Assistant] public virtual NGit.Api.BlameCommand SetStartCommit(AnyObjectId commit){this.startCommit = commit.ToObjectId();return this;}


public ModifyEbsDefaultKmsKeyIdResult modifyEbsDefaultKmsKeyId(ModifyEbsDefaultKmsKeyIdRequest request) {request = beforeClientExecution(request);return executeModifyEbsDefaultKmsKeyId(request);}

public virtual ModifyEbsDefaultKmsKeyIdResponse ModifyEbsDefaultKmsKeyId(ModifyEbsDefaultKmsKeyIdRequest request){var options = new InvokeOptions();options.RequestMarshaller = ModifyEbsDefaultKmsKeyIdRequestMarshaller.Instance;options.ResponseUnmarshaller = ModifyEbsDefaultKmsKeyIdResponseUnmarshaller.Instance;return Invoke<ModifyEbsDefaultKmsKeyIdResponse>(request, options);}

[User] public ModifyEbsDefaultKmsKeyIdResult modifyEbsDefaultKmsKeyId(ModifyEbsDefaultKmsKeyIdRequest request) {request = beforeClientExecution(request);return executeModifyEbsDefaultKmsKeyId(request);}

[Assistant] public virtual ModifyEbsDefaultKmsKeyIdResponse ModifyEbsDefaultKmsKeyId(ModifyEbsDefaultKmsKeyIdRequest request){var options = new InvokeOptions();options.RequestMarshaller = ModifyEbsDefaultKmsKeyIdRequestMarshaller.Instance;options.ResponseUnmarshaller = ModifyEbsDefaultKmsKeyIdResponseUnmarshaller.Instance;return Invoke<ModifyEbsDefaultKmsKeyIdResponse>(request, options);}


public void removeAuthor() {remove1stProperty(PropertyIDMap.PID_AUTHOR);}

public void RemoveAuthor(){MutableSection s = (MutableSection)FirstSection;s.RemoveProperty(PropertyIDMap.PID_AUTHOR);}

[User] public void removeAuthor() {remove1stProperty(PropertyIDMap.PID_AUTHOR);}

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


public Ref get(Object key) {String name = toRefName((String) key);Ref ref = resolved.get(name);if (ref == null)ref = loose.get(name);if (ref == null)ref = packed.get(name);return ref;}

public override Ref Get(object key){string name = ToRefName((string)key);Ref @ref = resolved.Get(name);if (@ref == null){@ref = loose.Get(name);}if (@ref == null){@ref = packed.Get(name);}return @ref;}

[User] public Ref get(Object key) {String name = toRefName((String) key);Ref ref = resolved.get(name);if (ref == null)ref = loose.get(name);if (ref == null)ref = packed.get(name);return ref;}

[Assistant] public override Ref Get(object key){string name = ToRefName((string)key);Ref @ref = resolved.Get(name);if (@ref == null){@ref = loose.Get(name);}if (@ref == null){@ref = packed.Get(name);}return @ref;}


public int addConditionalFormatting( HSSFConditionalFormatting cf ) {CFRecordsAggregate cfraClone = cf.getCFRecordsAggregate().cloneCFAggregate();return _conditionalFormattingTable.add(cfraClone);}

public int AddConditionalFormatting(IConditionalFormatting cf){CFRecordsAggregate cfraClone = ((HSSFConditionalFormatting)cf).CFRecordsAggregate.CloneCFAggregate();return _conditionalFormattingTable.Add(cfraClone);}

[User] public int addConditionalFormatting( HSSFConditionalFormatting cf ) {CFRecordsAggregate cfraClone = cf.getCFRecordsAggregate().cloneCFAggregate();return _conditionalFormattingTable.add(cfraClone);}

[Assistant] public int AddConditionalFormatting(IConditionalFormatting cf){CFRecordsAggregate cfraClone = ((HSSFConditionalFormatting)cf).CFRecordsAggregate.CloneCFAggregate();return _conditionalFormattingTable.Add(cfraClone);}


public final String toString() {return getClass().getName() + "[" + this.canonicalName + "]";}

public sealed override string ToString(){return GetType().FullName + "[" + this.canonicalName + "]";}

[User] public final String toString() {return getClass().getName() + "[" + this.canonicalName + "]";}

[Assistant] public sealed override string ToString(){return GetType().FullName + "[" + this.canonicalName + "]";}


public void serialize(LittleEndianOutput out) {out.writeShort(getIterations());}

public override void Serialize(ILittleEndianOutput out1){out1.WriteShort(Iterations);}

[User] public void serialize(LittleEndianOutput out) {out.writeShort(getIterations());}

[Assistant] public override void Serialize(ILittleEndianOutput out1){out1.WriteShort(Iterations);}


public MatchAllDocsQuery build(QueryNode queryNode) throws QueryNodeException {if (!(queryNode instanceof MatchAllDocsQueryNode)) {throw new QueryNodeException(new MessageImpl(QueryParserMessages.LUCENE_QUERY_CONVERSION_ERROR, queryNode.toQueryString(new EscapeQuerySyntaxImpl()), queryNode.getClass().getName()));}return new MatchAllDocsQuery();}

public virtual Query Build(IQueryNode queryNode){if (!(queryNode is MatchAllDocsQueryNode)){throw new QueryNodeException(new Message(QueryParserMessages.LUCENE_QUERY_CONVERSION_ERROR, queryNode.ToQueryString(new EscapeQuerySyntax()), queryNode.GetType().Name));}return new MatchAllDocsQuery();}

[User] public MatchAllDocsQuery build(QueryNode queryNode) throws QueryNodeException {if (!(queryNode instanceof MatchAllDocsQueryNode)) {throw new QueryNodeException(new MessageImpl(QueryParserMessages.LUCENE_QUERY_CONVERSION_ERROR, queryNode.toQueryString(new EscapeQuerySyntaxImpl()), queryNode.getClass().getName()));}return new MatchAllDocsQuery();}

[Assistant] public virtual Query Build(IQueryNode queryNode){if (!(queryNode is MatchAllDocsQueryNode)){throw new QueryNodeException(new Message(QueryParserMessages.LUCENE_QUERY_CONVERSION_ERROR, queryNode.ToQueryString(new EscapeQuerySyntax()), queryNode.GetType().Name));}return new MatchAllDocsQuery();}


public LongBuffer get(long[] dst) {return get(dst, 0, dst.length);}

public virtual java.nio.LongBuffer get(long[] dst){return get(dst, 0, dst.Length);}

[User] public LongBuffer get(long[] dst) {return get(dst, 0, dst.length);}

[Assistant] public virtual java.nio.LongBuffer get(long[] dst){return get(dst, 0, dst.Length);}


public String toFormulaString(String[] operands) {StringBuilder buffer = new StringBuilder();buffer.append(operands[ 0 ]);buffer.append("/");buffer.append(operands[ 1 ]);return buffer.toString();}

public override String ToFormulaString(String[] operands){StringBuilder buffer = new StringBuilder();buffer.Append(operands[0]);buffer.Append("/");buffer.Append(operands[1]);return buffer.ToString();}

[User] public String toFormulaString(String[] operands) {StringBuilder buffer = new StringBuilder();buffer.append(operands[ 0 ]);buffer.append("/");buffer.append(operands[ 1 ]);return buffer.toString();}

[Assistant] public override String ToFormulaString(String[] operands){StringBuilder buffer = new StringBuilder();buffer.Append(operands[0]);buffer.Append("/");buffer.Append(operands[1]);return buffer.ToString();}


@Override public void clear() {countMap.clear();}

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

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

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


public SpatialArgs(SpatialOperation operation, Shape shape) {if (operation == null || shape == null)throw new NullPointerException("operation and shape are required");this.operation = operation;this.shape = shape;}

public SpatialArgs(SpatialOperation operation, IShape shape){if (operation == null || shape == null)throw new ArgumentException("operation and shape are required");this.Operation = operation;this.Shape = shape;}

[User] public SpatialArgs(SpatialOperation operation, Shape shape) {if (operation == null || shape == null)throw new NullPointerException("operation and shape are required");this.operation = operation;this.shape = shape;}

[Assistant] public SpatialArgs(SpatialOperation operation, IShape shape){if (operation == null || shape == null)throw new ArgumentException("operation and shape are required");this.Operation = operation;this.Shape = shape;}


public int compareTo(Completion o) {return this.utf8.compareTo(o.utf8);}

public int CompareTo(Completion o){return this.Utf8.CompareTo(o.Utf8);}

[User] public int compareTo(Completion o) {return this.utf8.compareTo(o.utf8);}

[Assistant] public int CompareTo(Completion o){return this.Utf8.CompareTo(o.Utf8);}


public GetInstancesResult getInstances(GetInstancesRequest request) {request = beforeClientExecution(request);return executeGetInstances(request);}

public virtual GetInstancesResponse GetInstances(GetInstancesRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetInstancesRequestMarshaller.Instance;options.ResponseUnmarshaller = GetInstancesResponseUnmarshaller.Instance;return Invoke<GetInstancesResponse>(request, options);}

[User] public GetInstancesResult getInstances(GetInstancesRequest request) {request = beforeClientExecution(request);return executeGetInstances(request);}

[Assistant] public virtual GetInstancesResponse GetInstances(GetInstancesRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetInstancesRequestMarshaller.Instance;options.ResponseUnmarshaller = GetInstancesResponseUnmarshaller.Instance;return Invoke<GetInstancesResponse>(request, options);}


public int next() {if (text.getIndex() == text.getEndIndex() || 0 == sentenceStarts.length) {return DONE;} else if (currentSentence < sentenceStarts.length - 1) {text.setIndex(sentenceStarts[++currentSentence]);return current();} else {return last();}}

public override int Next(){if (text.Index == text.EndIndex || 0 == sentenceStarts.Length){return Done;}else if (currentSentence < sentenceStarts.Length - 1){text.SetIndex(sentenceStarts[++currentSentence]);return Current;}else{return Last();}}

[User] public int next() {if (text.getIndex() == text.getEndIndex() || 0 == sentenceStarts.length) {return DONE;} else if (currentSentence < sentenceStarts.length - 1) {text.setIndex(sentenceStarts[++currentSentence]);return current();} else {return last();}}

[Assistant] public override int Next(){if (text.Index == text.EndIndex || 0 == sentenceStarts.Length){return Done;}else if (currentSentence < sentenceStarts.Length - 1){text.SetIndex(sentenceStarts[++currentSentence]);return Current;}else{return Last();}}


public HSSFClientAnchor getPreferredSize(double scaleX, double scaleY){ImageUtils.setPreferredSize(this, scaleX, scaleY);return getClientAnchor();}

public IClientAnchor GetPreferredSize(double scaleX, double scaleY){ImageUtils.SetPreferredSize(this, scaleX, scaleY);return ClientAnchor;}

[User] public HSSFClientAnchor getPreferredSize(double scaleX, double scaleY){ImageUtils.setPreferredSize(this, scaleX, scaleY);return getClientAnchor();}

[Assistant] public IClientAnchor GetPreferredSize(double scaleX, double scaleY){ImageUtils.SetPreferredSize(this, scaleX, scaleY);return ClientAnchor;}


public CreateTaskSetResult createTaskSet(CreateTaskSetRequest request) {request = beforeClientExecution(request);return executeCreateTaskSet(request);}

public virtual CreateTaskSetResponse CreateTaskSet(CreateTaskSetRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateTaskSetRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateTaskSetResponseUnmarshaller.Instance;return Invoke<CreateTaskSetResponse>(request, options);}

[User] public CreateTaskSetResult createTaskSet(CreateTaskSetRequest request) {request = beforeClientExecution(request);return executeCreateTaskSet(request);}

[Assistant] public virtual CreateTaskSetResponse CreateTaskSet(CreateTaskSetRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateTaskSetRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateTaskSetResponseUnmarshaller.Instance;return Invoke<CreateTaskSetResponse>(request, options);}


public ByteBuffer putFloat(int index, float value) {return putInt(index, Float.floatToRawIntBits(value));}

public override java.nio.ByteBuffer putFloat(int index, float value){return putInt(index, Sharpen.Util.FloatToRawIntBits(value));}

[User] public ByteBuffer putFloat(int index, float value) {return putInt(index, Float.floatToRawIntBits(value));}

[Assistant] public override java.nio.ByteBuffer putFloat(int index, float value){return putInt(index, Sharpen.Util.FloatToRawIntBits(value));}


public static void main(String[] args) throws Exception {String field = null;int numTerms = DEFAULT_NUMTERMS;if (args.length == 0 || args.length > 4) {usage();System.exit(1);}Directory dir = FSDirectory.open(Paths.get(args[0]));Comparator<TermStats> comparator = new DocFreqComparator();for (int i = 1; i < args.length; i++) {if (args[i].equals("-t")) {comparator = new TotalTermFreqComparator();}else{try {numTerms = Integer.parseInt(args[i]);} catch (NumberFormatException e) {field=args[i];}}}IndexReader reader = DirectoryReader.open(dir);TermStats[] terms = getHighFreqTerms(reader, numTerms, field, comparator);for (int i = 0; i < terms.length; i++) {System.out.printf(Locale.ROOT, "%s:%s \t totalTF = %,d \t docFreq = %,d \n",terms[i].field, terms[i].termtext.utf8ToString(), terms[i].totalTermFreq, terms[i].docFreq);}reader.close();}

public static void Main(string[] args){string field = null;int numTerms = DEFAULT_NUMTERMS;if (args.Length == 0 || args.Length > 4){throw new ArgumentException();}Store.Directory dir = FSDirectory.Open(new DirectoryInfo(args[0]));IComparer<TermStats> comparer = new DocFreqComparer();for (int i = 1; i < args.Length; i++){if (args[i].Equals("-t", StringComparison.Ordinal)){comparer = new TotalTermFreqComparer();}else{if (!int.TryParse(args[i], NumberStyles.Integer, CultureInfo.InvariantCulture, out numTerms))field = args[i];}}using (IndexReader reader = DirectoryReader.Open(dir)){TermStats[] terms = GetHighFreqTerms(reader, numTerms, field, comparer);for (int i = 0; i < terms.Length; i++){Console.WriteLine("{0}:{1} \t totalTF = {2:#,##0} \t doc freq = {3:#,##0} \n", terms[i].Field, terms[i].GetTermText(), terms[i].TotalTermFreq, terms[i].DocFreq);}}}

[User] public static void main(String[] args) throws Exception {String field = null;int numTerms = DEFAULT_NUMTERMS;if (args.length == 0 || args.length > 4) {usage();System.exit(1);}Directory dir = FSDirectory.open(Paths.get(args[0]));Comparator<TermStats> comparator = new DocFreqComparator();for (int i = 1; i < args.length; i++) {if (args[i].equals("-t")) {comparator = new TotalTermFreqComparator();}else{try {numTerms = Integer.parseInt(args[i]);} catch (NumberFormatException e) {field=args[i];}}}IndexReader reader = DirectoryReader.open(dir);TermStats[] terms = getHighFreqTerms(reader, numTerms, field, comparator);for (int i = 0; i < terms.length; i++) {System.out.printf(Locale.ROOT, "%s:%s \t totalTF = %,d \t docFreq = %,d \n",terms[i].field, terms[i].termtext.utf8ToString(), terms[i].totalTermFreq, terms[i].docFreq);}reader.close();}

[Assistant] public static void Main(string[] args){string field = null;int numTerms = DEFAULT_NUMTERMS;if (args.Length == 0 || args.Length > 4){throw new ArgumentException();}Store.Directory dir = FSDirectory.Open(new DirectoryInfo(args[0]));IComparer<TermStats> comparer = new DocFreqComparer();for (int i = 1; i < args.Length; i++){if (args[i].Equals("-t", StringComparison.Ordinal)){comparer = new TotalTermFreqComparer();}else{if (!int.TryParse(args[i], NumberStyles.Integer, CultureInfo.InvariantCulture, out numTerms))field = args[i];}}using (IndexReader reader = DirectoryReader.Open(dir)){TermStats[] terms = GetHighFreqTerms(reader, numTerms, field, comparer);for (int i = 0; i < terms.Length; i++){Console.WriteLine("{0}:{1} \t totalTF = {2:#,##0} \t doc freq = {3:#,##0} \n", terms[i].Field, terms[i].GetTermText(), terms[i].TotalTermFreq, terms[i].DocFreq);}}}


public static Collection<String> getNotSupportedFunctionNames(){Collection<String> lst = new TreeSet<>();lst.addAll(FunctionEval.getNotSupportedFunctionNames());lst.addAll(AnalysisToolPak.getNotSupportedFunctionNames());return Collections.unmodifiableCollection(lst);}

public static List<String> GetNotSupportedFunctionNames(){List<String> lst = new List<String>();lst.AddRange(FunctionEval.GetNotSupportedFunctionNames());lst.AddRange(AnalysisToolPak.GetNotSupportedFunctionNames());return lst;}

[User] public static Collection<String> getNotSupportedFunctionNames(){Collection<String> lst = new TreeSet<>();lst.addAll(FunctionEval.getNotSupportedFunctionNames());lst.addAll(AnalysisToolPak.getNotSupportedFunctionNames());return Collections.unmodifiableCollection(lst);}

[Assistant] public static List<String> GetNotSupportedFunctionNames(){List<String> lst = new List<String>();lst.AddRange(FunctionEval.GetNotSupportedFunctionNames());lst.AddRange(AnalysisToolPak.GetNotSupportedFunctionNames());return lst;}


public CreateMeetingResult createMeeting(CreateMeetingRequest request) {request = beforeClientExecution(request);return executeCreateMeeting(request);}

public virtual CreateMeetingResponse CreateMeeting(CreateMeetingRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateMeetingRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateMeetingResponseUnmarshaller.Instance;return Invoke<CreateMeetingResponse>(request, options);}

[User] public CreateMeetingResult createMeeting(CreateMeetingRequest request) {request = beforeClientExecution(request);return executeCreateMeeting(request);}

[Assistant] public virtual CreateMeetingResponse CreateMeeting(CreateMeetingRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateMeetingRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateMeetingResponseUnmarshaller.Instance;return Invoke<CreateMeetingResponse>(request, options);}


public char get(int index) {checkIndex(index);return byteBuffer.getChar(index * SizeOf.CHAR);}

public override char get(int index){checkIndex(index);return byteBuffer.getChar(index * libcore.io.SizeOf.CHAR);}

[User] public char get(int index) {checkIndex(index);return byteBuffer.getChar(index * SizeOf.CHAR);}

[Assistant] public override char get(int index){checkIndex(index);return byteBuffer.getChar(index * libcore.io.SizeOf.CHAR);}


public GetInstanceSnapshotResult getInstanceSnapshot(GetInstanceSnapshotRequest request) {request = beforeClientExecution(request);return executeGetInstanceSnapshot(request);}

public virtual GetInstanceSnapshotResponse GetInstanceSnapshot(GetInstanceSnapshotRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetInstanceSnapshotRequestMarshaller.Instance;options.ResponseUnmarshaller = GetInstanceSnapshotResponseUnmarshaller.Instance;return Invoke<GetInstanceSnapshotResponse>(request, options);}

[User] public GetInstanceSnapshotResult getInstanceSnapshot(GetInstanceSnapshotRequest request) {request = beforeClientExecution(request);return executeGetInstanceSnapshot(request);}

[Assistant] public virtual GetInstanceSnapshotResponse GetInstanceSnapshot(GetInstanceSnapshotRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetInstanceSnapshotRequestMarshaller.Instance;options.ResponseUnmarshaller = GetInstanceSnapshotResponseUnmarshaller.Instance;return Invoke<GetInstanceSnapshotResponse>(request, options);}


public static Map<String, Integer> toMap(String[] keys) {Map<String, Integer> m = new HashMap<String, Integer>();for (int i=0; i<keys.length; i++) {m.put(keys[i], i);}return m;}

public static IDictionary<string, int> ToMap(string[] keys){IDictionary<string, int> m = new Dictionary<string, int>();for (int i = 0; i < keys.Length; i++){m[keys[i]] = i;}return m;}

[User] public static Map<String, Integer> toMap(String[] keys) {Map<String, Integer> m = new HashMap<String, Integer>();for (int i=0; i<keys.length; i++) {m.put(keys[i], i);}return m;}

[Assistant] public static IDictionary<string, int> ToMap(string[] keys){IDictionary<string, int> m = new Dictionary<string, int>();for (int i = 0; i < keys.Length; i++){m[keys[i]] = i;}return m;}


public GetHealthCheckStatusResult getHealthCheckStatus(GetHealthCheckStatusRequest request) {request = beforeClientExecution(request);return executeGetHealthCheckStatus(request);}

public virtual GetHealthCheckStatusResponse GetHealthCheckStatus(GetHealthCheckStatusRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetHealthCheckStatusRequestMarshaller.Instance;options.ResponseUnmarshaller = GetHealthCheckStatusResponseUnmarshaller.Instance;return Invoke<GetHealthCheckStatusResponse>(request, options);}

[User] public GetHealthCheckStatusResult getHealthCheckStatus(GetHealthCheckStatusRequest request) {request = beforeClientExecution(request);return executeGetHealthCheckStatus(request);}

[Assistant] public virtual GetHealthCheckStatusResponse GetHealthCheckStatus(GetHealthCheckStatusRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetHealthCheckStatusRequestMarshaller.Instance;options.ResponseUnmarshaller = GetHealthCheckStatusResponseUnmarshaller.Instance;return Invoke<GetHealthCheckStatusResponse>(request, options);}


public GetReusableDelegationSetResult getReusableDelegationSet(GetReusableDelegationSetRequest request) {request = beforeClientExecution(request);return executeGetReusableDelegationSet(request);}

public virtual GetReusableDelegationSetResponse GetReusableDelegationSet(GetReusableDelegationSetRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetReusableDelegationSetRequestMarshaller.Instance;options.ResponseUnmarshaller = GetReusableDelegationSetResponseUnmarshaller.Instance;return Invoke<GetReusableDelegationSetResponse>(request, options);}

[User] public GetReusableDelegationSetResult getReusableDelegationSet(GetReusableDelegationSetRequest request) {request = beforeClientExecution(request);return executeGetReusableDelegationSet(request);}

[Assistant] public virtual GetReusableDelegationSetResponse GetReusableDelegationSet(GetReusableDelegationSetRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetReusableDelegationSetRequestMarshaller.Instance;options.ResponseUnmarshaller = GetReusableDelegationSetResponseUnmarshaller.Instance;return Invoke<GetReusableDelegationSetResponse>(request, options);}


public final ValueEval getAbsoluteValue(int row, int col) {int rowOffsetIx = row - _firstRow;int colOffsetIx = col - _firstColumn;if(rowOffsetIx < 0 || rowOffsetIx >= _nRows) {throw new IllegalArgumentException("Specified row index (" + row+ ") is outside the allowed range (" + _firstRow + ".." + _lastRow + ")");}if(colOffsetIx < 0 || colOffsetIx >= _nColumns) {throw new IllegalArgumentException("Specified column index (" + col+ ") is outside the allowed range (" + _firstColumn + ".." + col + ")");}return getRelativeValue(rowOffsetIx, colOffsetIx);}

public ValueEval GetAbsoluteValue(int row, int col){int rowOffsetIx = row - _firstRow;int colOffsetIx = col - _firstColumn;if (rowOffsetIx < 0 || rowOffsetIx >= _nRows){throw new ArgumentException("Specified row index (" + row+ ") is outside the allowed range (" + _firstRow + ".." + _lastRow + ")");}if (colOffsetIx < 0 || colOffsetIx >= _nColumns){throw new ArgumentException("Specified column index (" + col+ ") is outside the allowed range (" + _firstColumn + ".." + col + ")");}return GetRelativeValue(rowOffsetIx, colOffsetIx);}

[User] public final ValueEval getAbsoluteValue(int row, int col) {int rowOffsetIx = row - _firstRow;int colOffsetIx = col - _firstColumn;if(rowOffsetIx < 0 || rowOffsetIx >= _nRows) {throw new IllegalArgumentException("Specified row index (" + row+ ") is outside the allowed range (" + _firstRow + ".." + _lastRow + ")");}if(colOffsetIx < 0 || colOffsetIx >= _nColumns) {throw new IllegalArgumentException("Specified column index (" + col+ ") is outside the allowed range (" + _firstColumn + ".." + col + ")");}return getRelativeValue(rowOffsetIx, colOffsetIx);}

[Assistant] public ValueEval GetAbsoluteValue(int row, int col){int rowOffsetIx = row - _firstRow;int colOffsetIx = col - _firstColumn;if (rowOffsetIx < 0 || rowOffsetIx >= _nRows){throw new ArgumentException("Specified row index (" + row+ ") is outside the allowed range (" + _firstRow + ".." + _lastRow + ")");}if (colOffsetIx < 0 || colOffsetIx >= _nColumns){throw new ArgumentException("Specified column index (" + col+ ") is outside the allowed range (" + _firstColumn + ".." + col + ")");}return GetRelativeValue(rowOffsetIx, colOffsetIx);}


public final LongBuffer put(long[] src, int srcOffset, int longCount) {throw new ReadOnlyBufferException();}

public sealed override java.nio.LongBuffer put(long[] src, int srcOffset, int longCount){throw new java.nio.ReadOnlyBufferException();}

[User] public final LongBuffer put(long[] src, int srcOffset, int longCount) {throw new ReadOnlyBufferException();}

[Assistant] public sealed override java.nio.LongBuffer put(long[] src, int srcOffset, int longCount){throw new java.nio.ReadOnlyBufferException();}