yijunyu/c-to-rust huggingface dataset:
// Original:
public DescribeReservedInstancesResult describeReservedInstances(DescribeReservedInstancesRequest request) {request = beforeClientExecution(request);return executeDescribeReservedInstances(request);}

// Translation:
public virtual DescribeReservedInstancesResponse DescribeReservedInstances(DescribeReservedInstancesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeReservedInstancesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeReservedInstancesResponseUnmarshaller.Instance;return Invoke<DescribeReservedInstancesResponse>(request, options);}
// Original:
public PostRealTimeDeviceDataRequest() {super("industry-brain", "2018-07-12", "PostRealTimeDeviceData");setProtocol(ProtocolType.HTTPS);setMethod(MethodType.POST);}

// Translation:
public PostRealTimeDeviceDataRequest(): base("industry-brain", "2018-07-12", "PostRealTimeDeviceData"){Protocol = ProtocolType.HTTPS;Method = MethodType.POST;}
// Original:
public ScandinavianFoldingFilter(TokenStream input) {super(input);}

// Translation:
public ScandinavianFoldingFilter(TokenStream input): base(input){charTermAttribute = AddAttribute<ICharTermAttribute>();}
// Original:
public SetLoadBalancerPoliciesForBackendServerResult setLoadBalancerPoliciesForBackendServer(SetLoadBalancerPoliciesForBackendServerRequest request) {request = beforeClientExecution(request);return executeSetLoadBalancerPoliciesForBackendServer(request);}

// Translation:
public virtual SetLoadBalancerPoliciesForBackendServerResponse SetLoadBalancerPoliciesForBackendServer(SetLoadBalancerPoliciesForBackendServerRequest request){var options = new InvokeOptions();options.RequestMarshaller = SetLoadBalancerPoliciesForBackendServerRequestMarshaller.Instance;options.ResponseUnmarshaller = SetLoadBalancerPoliciesForBackendServerResponseUnmarshaller.Instance;return Invoke<SetLoadBalancerPoliciesForBackendServerResponse>(request, options);}
// Original:
public ImportSnapshotResult importSnapshot(ImportSnapshotRequest request) {request = beforeClientExecution(request);return executeImportSnapshot(request);}

// Translation:
public virtual ImportSnapshotResponse ImportSnapshot(ImportSnapshotRequest request){var options = new InvokeOptions();options.RequestMarshaller = ImportSnapshotRequestMarshaller.Instance;options.ResponseUnmarshaller = ImportSnapshotResponseUnmarshaller.Instance;return Invoke<ImportSnapshotResponse>(request, options);}
// Original:
public void addCellRangeAddress(CellRangeAddress cra) {_list.add(cra);}

// Translation:
public void AddCellRangeAddress(CellRangeAddress cra){_list.Add(cra);}
// Original:
public IntBuffer put(int[] src, int srcOffset, int intCount) {byteBuffer.limit(limit * SizeOf.INT);byteBuffer.position(position * SizeOf.INT);if (byteBuffer instanceof ReadWriteDirectByteBuffer) {((ReadWriteDirectByteBuffer) byteBuffer).put(src, srcOffset, intCount);} else {((ReadWriteHeapByteBuffer) byteBuffer).put(src, srcOffset, intCount);}this.position += intCount;return this;}

// Translation:
public override java.nio.IntBuffer put(int[] src, int srcOffset, int intCount){byteBuffer.limit(_limit * libcore.io.SizeOf.INT);byteBuffer.position(_position * libcore.io.SizeOf.INT);if (byteBuffer is java.nio.ReadWriteDirectByteBuffer){((java.nio.ReadWriteDirectByteBuffer)byteBuffer).put(src, srcOffset, intCount);}else{((java.nio.ReadWriteHeapByteBuffer)byteBuffer).put(src, srcOffset, intCount);}this._position += intCount;return this;}
// Original:
public DeleteInsightRulesResult deleteInsightRules(DeleteInsightRulesRequest request) {request = beforeClientExecution(request);return executeDeleteInsightRules(request);}

// Translation:
public virtual DeleteInsightRulesResponse DeleteInsightRules(DeleteInsightRulesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteInsightRulesRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteInsightRulesResponseUnmarshaller.Instance;return Invoke<DeleteInsightRulesResponse>(request, options);}
// Original:
public void setStorageId(int storageId) {field_5_stream_id = storageId;}

// Translation:
public void SetStorageId(int storageId){field_5_stream_id = storageId;}
// Original:
public StartVpcEndpointServicePrivateDnsVerificationResult startVpcEndpointServicePrivateDnsVerification(StartVpcEndpointServicePrivateDnsVerificationRequest request) {request = beforeClientExecution(request);return executeStartVpcEndpointServicePrivateDnsVerification(request);}

// Translation:
public virtual StartVpcEndpointServicePrivateDnsVerificationResponse StartVpcEndpointServicePrivateDnsVerification(StartVpcEndpointServicePrivateDnsVerificationRequest request){var options = new InvokeOptions();options.RequestMarshaller = StartVpcEndpointServicePrivateDnsVerificationRequestMarshaller.Instance;options.ResponseUnmarshaller = StartVpcEndpointServicePrivateDnsVerificationResponseUnmarshaller.Instance;return Invoke<StartVpcEndpointServicePrivateDnsVerificationResponse>(request, options);}
// Original:
public SSTRecord() {field_1_num_strings = 0;field_2_num_unique_strings = 0;field_3_strings = new IntMapper<>();deserializer = new SSTDeserializer(field_3_strings);}

// Translation:
public SSTRecord(){field_1_num_strings = 0;field_2_num_unique_strings = 0;field_3_strings = new IntMapper<UnicodeString>();deserializer = new SSTDeserializer(field_3_strings);}
// Original:
public void clearData() {points.clear();}

// Translation:
public virtual void ClearData(){points.Clear();}
// Original:
public void visitContainedRecords(RecordVisitor rv) {PositionTrackingVisitor stv = new PositionTrackingVisitor(rv, 0);final int blockCount = getRowBlockCount();for (int blockIndex = 0; blockIndex < blockCount; blockIndex++) {int pos=0;final int rowBlockSize = visitRowRecordsForBlock(blockIndex, rv);pos += rowBlockSize;final int startRowNumber = getStartRowNumberForBlock(blockIndex);final int endRowNumber = getEndRowNumberForBlock(blockIndex);final List<Short> cellOffsets = new ArrayList<>();int cellRefOffset = (rowBlockSize - RowRecord.ENCODED_SIZE);for (int row = startRowNumber; row <= endRowNumber; row++) {if (_valuesAgg.rowHasCells(row)) {stv.setPosition(0);_valuesAgg.visitCellsForRow(row, stv);int rowCellSize = stv.getPosition();pos += rowCellSize;cellOffsets.add((short)cellRefOffset);cellRefOffset = rowCellSize;}}rv.visitRecord(new DBCellRecord(pos, shortListToArray(cellOffsets)));}_unknownRecords.forEach(rv::visitRecord);}

// Translation:
public override void VisitContainedRecords(RecordVisitor rv){PositionTrackingVisitor stv = new PositionTrackingVisitor(rv, 0);int blockCount = this.RowBlockCount;for (int blockIndex = 0; blockIndex < blockCount; blockIndex++){int pos = 0;int rowBlockSize = VisitRowRecordsForBlock(blockIndex, rv);pos += rowBlockSize;int startRowNumber = GetStartRowNumberForBlock(blockIndex);int endRowNumber = GetEndRowNumberForBlock(blockIndex);DBCellRecord cellRecord = new DBCellRecord();int cellRefOffset = (rowBlockSize - RowRecord.ENCODED_SIZE);for (int row = startRowNumber; row <= endRowNumber; row++){if (_valuesAgg.RowHasCells(row)){stv.Position = 0;_valuesAgg.VisitCellsForRow(row, stv);int rowCellSize = stv.Position;pos += rowCellSize;cellRecord.AddCellOffset((short)cellRefOffset);cellRefOffset = rowCellSize;}}cellRecord.RowOffset = (pos);rv.VisitRecord(cellRecord);}for (int i = 0; i < _unknownRecords.Count; i++){rv.VisitRecord((Record)_unknownRecords[i]);}}
// Original:
public ListDatasetsResult listDatasets(ListDatasetsRequest request) {request = beforeClientExecution(request);return executeListDatasets(request);}

// Translation:
public virtual ListDatasetsResponse ListDatasets(ListDatasetsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListDatasetsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListDatasetsResponseUnmarshaller.Instance;return Invoke<ListDatasetsResponse>(request, options);}
// Original:
public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1,ValueEval arg2) {return evaluate(srcRowIndex, srcColumnIndex, arg0, arg1, arg2, DEFAULT_ARG3);}

// Translation:
public ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1,ValueEval arg2){return Evaluate(srcRowIndex, srcColumnIndex, arg0, arg1, arg2, DEFAULT_ARG3);}
// Original:
public int size() {return a.length;}

// Translation:
public override int size(){return a.Length;}
// Original:
public HSSFCell getCell(int cellnum) {return getCell(cellnum, book.getMissingCellPolicy());}

// Translation:
public ICell GetCell(int cellnum){return GetCell(cellnum, book.MissingCellPolicy);}
// Original:
public String toFormulaString(FormulaRenderingWorkbook book) {return ExternSheetNameResolver.prependSheetName(book, field_1_index_extern_sheet, FormulaError.REF.getString());}

// Translation:
public String ToFormulaString(IFormulaRenderingWorkbook book){return ExternSheetNameResolver.PrependSheetName(book, field_1_index_extern_sheet,HSSFErrorConstants.GetText(HSSFErrorConstants.ERROR_REF));}
// Original:
public int getBucket(CharSequence key) {return getExactMatchStartingFromRootArc(0, new BytesRef(key));}

// Translation:
public virtual int GetBucket(string key){return GetExactMatchStartingFromRootArc(0, new BytesRef(key));}
// Original:
public DeleteAuthorizerResult deleteAuthorizer(DeleteAuthorizerRequest request) {request = beforeClientExecution(request);return executeDeleteAuthorizer(request);}

// Translation:
public virtual DeleteAuthorizerResponse DeleteAuthorizer(DeleteAuthorizerRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteAuthorizerRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteAuthorizerResponseUnmarshaller.Instance;return Invoke<DeleteAuthorizerResponse>(request, options);}
// Original:
public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval numberVE) {String octal = OperandResolver.coerceValueToString(numberVE);try {return new NumberEval(BaseNumberUtils.convertToDecimal(octal, OCTAL_BASE, MAX_NUMBER_OF_PLACES));}  catch (IllegalArgumentException e) {return ErrorEval.NUM_ERROR;}}

// Translation:
public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval numberVE){String octal = OperandResolver.CoerceValueToString(numberVE);try{return new NumberEval(BaseNumberUtils.ConvertToDecimal(octal, OCTAL_BASE, MAX_NUMBER_OF_PLACES));}catch (ArgumentException){return ErrorEval.NUM_ERROR;}}
// Original:
public void serialize(LittleEndianOutput out) {out.writeShort(field_1_hcenter);}

// Translation:
public override void Serialize(ILittleEndianOutput out1){out1.WriteShort(field_1_hcenter);}
// Original:
public EnableEnhancedMonitoringResult enableEnhancedMonitoring(EnableEnhancedMonitoringRequest request) {request = beforeClientExecution(request);return executeEnableEnhancedMonitoring(request);}

// Translation:
public virtual EnableEnhancedMonitoringResponse EnableEnhancedMonitoring(EnableEnhancedMonitoringRequest request){var options = new InvokeOptions();options.RequestMarshaller = EnableEnhancedMonitoringRequestMarshaller.Instance;options.ResponseUnmarshaller = EnableEnhancedMonitoringResponseUnmarshaller.Instance;return Invoke<EnableEnhancedMonitoringResponse>(request, options);}
// Original:
public ListDeliveryStreamsResult listDeliveryStreams(ListDeliveryStreamsRequest request) {request = beforeClientExecution(request);return executeListDeliveryStreams(request);}

// Translation:
public virtual ListDeliveryStreamsResponse ListDeliveryStreams(ListDeliveryStreamsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListDeliveryStreamsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListDeliveryStreamsResponseUnmarshaller.Instance;return Invoke<ListDeliveryStreamsResponse>(request, options);}
// Original:
public DetachVolumeResult detachVolume(DetachVolumeRequest request) {request = beforeClientExecution(request);return executeDetachVolume(request);}

// Translation:
public virtual DetachVolumeResponse DetachVolume(DetachVolumeRequest request){var options = new InvokeOptions();options.RequestMarshaller = DetachVolumeRequestMarshaller.Instance;options.ResponseUnmarshaller = DetachVolumeResponseUnmarshaller.Instance;return Invoke<DetachVolumeResponse>(request, options);}
// Original:
public void serialize(LittleEndianOutput out) {out.writeShort(field_15_pattern_style);out.writeShort(field_16_pattern_color_indexes);}

// Translation:
public void Serialize(ILittleEndianOutput out1){out1.WriteShort(field_15_pattern_style);out1.WriteShort(field_16_pattern_color_indexes);}
// Original:
public void setShowSeriesKey(boolean value){field_1_options = showSeriesKey.setShortBoolean(field_1_options, value);}

// Translation:
public void SetShowSeriesKey(bool value){field_1_options = showSeriesKey.SetShortBoolean(field_1_options, value);}
// Original:
public GermanNormalizationFilterFactory(Map<String,String> args) {super(args);if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

// Translation:
public GermanNormalizationFilterFactory(IDictionary<string, string> args) : base(args){if (args.Count > 0){throw new System.ArgumentException("Unknown parameters: " + args);}}
// Original:
public static boolean allSubsetsEqual(Collection<BitSet> altsets) {Iterator<BitSet> it = altsets.iterator();BitSet first = it.next();while ( it.hasNext() ) {BitSet next = it.next();if ( !next.equals(first) ) return false;}return true;}

// Translation:
public static bool AllSubsetsEqual(IEnumerable<BitSet> altsets){IEnumerator<BitSet> it = altsets.GetEnumerator();it.MoveNext();BitSet first = it.Current;while (it.MoveNext()){BitSet next = it.Current;if (!next.Equals(first)){return false;}}return true;}
// Original:
public CellRangeAddressList(RecordInputStream in) {this();int nItems = in.readUShort();for (int k = 0; k < nItems; k++) {_list.add(new CellRangeAddress(in));}}

// Translation:
public CellRangeAddressList(RecordInputStream in1){int nItems = in1.ReadUShort();_list = new ArrayList(nItems);for (int k = 0; k < nItems; k++){_list.Add(new CellRangeAddress(in1));}}
// Original:
public boolean markSupported() {return in.markSupported();}

// Translation:
public override bool MarkSupported(){return @in.MarkSupported();}
// Original:
public DBInstance restoreDBInstanceFromS3(RestoreDBInstanceFromS3Request request) {request = beforeClientExecution(request);return executeRestoreDBInstanceFromS3(request);}

// Translation:
public virtual RestoreDBInstanceFromS3Response RestoreDBInstanceFromS3(RestoreDBInstanceFromS3Request request){var options = new InvokeOptions();options.RequestMarshaller = RestoreDBInstanceFromS3RequestMarshaller.Instance;options.ResponseUnmarshaller = RestoreDBInstanceFromS3ResponseUnmarshaller.Instance;return Invoke<RestoreDBInstanceFromS3Response>(request, options);}
// Original:
public boolean equals(Object other) {if (!(other instanceof FloatBuffer)) {return false;}FloatBuffer otherBuffer = (FloatBuffer) other;if (remaining() != otherBuffer.remaining()) {return false;}int myPosition = position;int otherPosition = otherBuffer.position;boolean equalSoFar = true;while (equalSoFar && (myPosition < limit)) {float a = get(myPosition++);float b = otherBuffer.get(otherPosition++);equalSoFar = a == b || (a != a && b != b);}return equalSoFar;}

// Translation:
public override bool Equals(object other){if (!(other is java.nio.FloatBuffer)){return false;}java.nio.FloatBuffer otherBuffer = (java.nio.FloatBuffer)other;if (remaining() != otherBuffer.remaining()){return false;}int myPosition = _position;int otherPosition = otherBuffer._position;bool equalSoFar = true;while (equalSoFar && (myPosition < _limit)){float a = get(myPosition++);float b = otherBuffer.get(otherPosition++);equalSoFar = a == b || (a != a && b != b);}return equalSoFar;}
// Original:
public static void fill(float[] array, int start, int end, float value) {Arrays.checkStartAndEnd(array.length, start, end);for (int i = start; i < end; i++) {array[i] = value;}}

// Translation:
public static void fill(float[] array, int start, int end, float value){java.util.Arrays.checkStartAndEnd(array.Length, start, end);{for (int i = start; i < end; i++){array[i] = value;}}}
// Original:
public DescribeReceiptRuleResult describeReceiptRule(DescribeReceiptRuleRequest request) {request = beforeClientExecution(request);return executeDescribeReceiptRule(request);}

// Translation:
public virtual DescribeReceiptRuleResponse DescribeReceiptRule(DescribeReceiptRuleRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeReceiptRuleRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeReceiptRuleResponseUnmarshaller.Instance;return Invoke<DescribeReceiptRuleResponse>(request, options);}
// Original:
public String toString() {return super.toString()+" "+prefix;}

// Translation:
public override string ToString(){return base.ToString() + " " + m_prefix;}
// Original:
public float tf(int freq, int passageLen) {float norm = k1 * ((1 - b) + b * (passageLen / pivot));return freq / (freq + norm);}

// Translation:
public virtual float Tf(int freq, int passageLen){float norm = k1 * ((1 - b) + b * (passageLen / pivot));return freq / (freq + norm);}
// Original:
public DescribeModelResult describeModel(DescribeModelRequest request) {request = beforeClientExecution(request);return executeDescribeModel(request);}

// Translation:
public virtual DescribeModelResponse DescribeModel(DescribeModelRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeModelRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeModelResponseUnmarshaller.Instance;return Invoke<DescribeModelResponse>(request, options);}
// Original:
public boolean markSupported() {return true;}

// Translation:
public override bool markSupported(){return true;}
// Original:
public ListEndpointConfigsResult listEndpointConfigs(ListEndpointConfigsRequest request) {request = beforeClientExecution(request);return executeListEndpointConfigs(request);}

// Translation:
public virtual ListEndpointConfigsResponse ListEndpointConfigs(ListEndpointConfigsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListEndpointConfigsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListEndpointConfigsResponseUnmarshaller.Instance;return Invoke<ListEndpointConfigsResponse>(request, options);}
// Original:
public DescribeDBProxyTargetGroupsResult describeDBProxyTargetGroups(DescribeDBProxyTargetGroupsRequest request) {request = beforeClientExecution(request);return executeDescribeDBProxyTargetGroups(request);}

// Translation:
public virtual DescribeDBProxyTargetGroupsResponse DescribeDBProxyTargetGroups(DescribeDBProxyTargetGroupsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeDBProxyTargetGroupsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeDBProxyTargetGroupsResponseUnmarshaller.Instance;return Invoke<DescribeDBProxyTargetGroupsResponse>(request, options);}
// Original:
public long size(DiffEntry.Side side, DiffEntry ent) throws IOException {switch (side) {case OLD:return oldSource.size(ent.oldPath, ent.oldId.toObjectId());case NEW:return newSource.size(ent.newPath, ent.newId.toObjectId());default:throw new IllegalArgumentException();}}

// Translation:
public long Size(DiffEntry.Side side, DiffEntry ent){switch (side){case DiffEntry.Side.OLD:{return oldSource.Size(ent.oldPath, ent.oldId.ToObjectId());}case DiffEntry.Side.NEW:{return newSource.Size(ent.newPath, ent.newId.ToObjectId());}default:{throw new ArgumentException();}}}
// Original:
public GlobalReplicationGroup disassociateGlobalReplicationGroup(DisassociateGlobalReplicationGroupRequest request) {request = beforeClientExecution(request);return executeDisassociateGlobalReplicationGroup(request);}

// Translation:
public virtual DisassociateGlobalReplicationGroupResponse DisassociateGlobalReplicationGroup(DisassociateGlobalReplicationGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = DisassociateGlobalReplicationGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = DisassociateGlobalReplicationGroupResponseUnmarshaller.Instance;return Invoke<DisassociateGlobalReplicationGroupResponse>(request, options);}
// Original:
public static void writeHeader(DataOutput out, String codec, int version) throws IOException {BytesRef bytes = new BytesRef(codec);if (bytes.length != codec.length() || bytes.length >= 128) {throw new IllegalArgumentException("codec must be simple ASCII, less than 128 characters in length [got " + codec + "]");}out.writeInt(CODEC_MAGIC);out.writeString(codec);out.writeInt(version);}

// Translation:
public static void WriteHeader(DataOutput @out, string codec, int version){BytesRef bytes = new BytesRef(codec);if (bytes.Length != codec.Length || bytes.Length >= 128){throw new System.ArgumentException("codec must be simple ASCII, less than 128 characters in length [got " + codec + "]");}@out.WriteInt32(CODEC_MAGIC);@out.WriteString(codec);@out.WriteInt32(version);}
// Original:
public PagedList<DedicatedCapacityInner> listByResourceGroup(String resourceGroupName) {PageImpl<DedicatedCapacityInner> page = new PageImpl<>();page.setItems(listByResourceGroupWithServiceResponseAsync(resourceGroupName).toBlocking().single().body());page.setNextPageLink(null);return new PagedList<DedicatedCapacityInner>(page) {@Overridepublic Page<DedicatedCapacityInner> nextPage(String nextPageLink) {return null;}};}

// Translation:
public async Task<AzureOperationResponse<IEnumerable<DedicatedCapacity>>> ListByResourceGroupWithHttpMessagesAsync(string resourceGroupName, Dictionary<string, List<string>> customHeaders = null, CancellationToken cancellationToken = default(CancellationToken)){return await innerCapacityOperations.ListByResourceGroupWithHttpMessagesAsync(resourceGroupName, customHeaders, cancellationToken).ConfigureAwait(false);}
// Original:
public DescribeIpGroupsResult describeIpGroups(DescribeIpGroupsRequest request) {request = beforeClientExecution(request);return executeDescribeIpGroups(request);}

// Translation:
public virtual DescribeIpGroupsResponse DescribeIpGroups(DescribeIpGroupsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeIpGroupsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeIpGroupsResponseUnmarshaller.Instance;return Invoke<DescribeIpGroupsResponse>(request, options);}
// Original:
public final CoderResult flush(ByteBuffer out) {if (status != END && status != READY) {throw new IllegalStateException();}CoderResult result = implFlush(out);if (result == CoderResult.UNDERFLOW) {status = FLUSH;}return result;}

// Translation:
public java.nio.charset.CoderResult flush(java.nio.ByteBuffer @out){if (status != END && status != READY){throw new System.InvalidOperationException();}java.nio.charset.CoderResult result = implFlush(@out);if (result == java.nio.charset.CoderResult.UNDERFLOW){status = FLUSH;}return result;}
// Original:
public final Type getType() {if (beginA < endA) {if (beginB < endB) {return Type.REPLACE;}return Type.DELETE;}if (beginB < endB) {return Type.INSERT;}return Type.EMPTY;}

// Translation:
public Edit.Type GetType(){if (beginA < endA){if (beginB < endB){return Edit.Type.REPLACE;}else{return Edit.Type.DELETE;}}else{if (beginB < endB){return Edit.Type.INSERT;}else{return Edit.Type.EMPTY;}}}
// Original:
public Builder() {this(false);}

// Translation:
public Builder(): base(){lastDocID = -1;wordNum = -1;word = 0;}
// Original:
public DescribeHsmConfigurationsResult describeHsmConfigurations(DescribeHsmConfigurationsRequest request) {request = beforeClientExecution(request);return executeDescribeHsmConfigurations(request);}

// Translation:
public virtual DescribeHsmConfigurationsResponse DescribeHsmConfigurations(DescribeHsmConfigurationsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeHsmConfigurationsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeHsmConfigurationsResponseUnmarshaller.Instance;return Invoke<DescribeHsmConfigurationsResponse>(request, options);}