yijunyu/c-to-rust huggingface dataset:
// Original:
public boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;FieldVals other = (FieldVals) obj;if (fieldName == null) {if (other.fieldName != null)return false;} else if (!fieldName.equals(other.fieldName))return false;if (maxEdits != other.maxEdits) {return false;}if (prefixLength != other.prefixLength)return false;if (queryString == null) {return other.queryString == null;} else return queryString.equals(other.queryString);}

// Translation:
public override bool Equals(object obj){if (this == obj)return true;if (obj == null)return false;if (GetType() != obj.GetType())return false;FieldVals other = (FieldVals)obj;if (fieldName == null){if (other.fieldName != null)return false;}else if (!fieldName.Equals(other.fieldName, StringComparison.Ordinal))return false;if (J2N.BitConversion.SingleToInt32Bits(minSimilarity) != J2N.BitConversion.SingleToInt32Bits(other.minSimilarity))return false;if (prefixLength != other.prefixLength)return false;if (queryString == null){if (other.queryString != null)return false;}else if (!queryString.Equals(other.queryString, StringComparison.Ordinal))return false;return true;}
// Original:
public void setMaxChainLength(int maxLen) {maxChainLength = maxLen;}

// Translation:
public virtual void SetMaxChainLength(int maxLen){maxChainLength = maxLen;}
// Original:
public DeleteReusableDelegationSetResult deleteReusableDelegationSet(DeleteReusableDelegationSetRequest request) {request = beforeClientExecution(request);return executeDeleteReusableDelegationSet(request);}

// Translation:
public virtual DeleteReusableDelegationSetResponse DeleteReusableDelegationSet(DeleteReusableDelegationSetRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteReusableDelegationSetRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteReusableDelegationSetResponseUnmarshaller.Instance;return Invoke<DeleteReusableDelegationSetResponse>(request, options);}
// Original:
public String toString() {StringBuilder buffer = new StringBuilder();buffer.append("[HEADER]\n");buffer.append("    .header = ").append(getText()).append("\n");buffer.append("[/HEADER]\n");return buffer.toString();}

// Translation:
public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append("[HEADER]\n");buffer.Append("    .header = ").Append(Text).Append("\n");buffer.Append("[/HEADER]\n");return buffer.ToString();}
// Original:
public void writeStringData(String text) {boolean is16bitEncoded = StringUtil.hasMultibyte(text);int keepTogetherSize = 1 + 1; int optionFlags = 0x00;if (is16bitEncoded) {optionFlags |= 0x01;keepTogetherSize += 1; }writeContinueIfRequired(keepTogetherSize);writeByte(optionFlags);writeCharacterData(text, is16bitEncoded);}

// Translation:
public void WriteStringData(String text){bool is16bitEncoded = StringUtil.HasMultibyte(text);int keepTogetherSize = 1 + 1; int optionFlags = 0x00;if (is16bitEncoded){optionFlags |= 0x01;keepTogetherSize += 1; }WriteContinueIfRequired(keepTogetherSize);WriteByte(optionFlags);WriteCharacterData(text, is16bitEncoded);}
// Original:
public void nextBuffer() {if (1+bufferUpto == buffers.length) {byte[][] newBuffers = new byte[ArrayUtil.oversize(buffers.length+1,NUM_BYTES_OBJECT_REF)][];System.arraycopy(buffers, 0, newBuffers, 0, buffers.length);buffers = newBuffers;}buffer = buffers[1+bufferUpto] = allocator.getByteBlock();bufferUpto++;byteUpto = 0;byteOffset += BYTE_BLOCK_SIZE;}

// Translation:
public void NextBuffer(){if (1 + bufferUpto == buffers.Length){var newBuffers = new byte[ArrayUtil.Oversize(buffers.Length + 1, RamUsageEstimator.NUM_BYTES_OBJECT_REF)][];Array.Copy(buffers, 0, newBuffers, 0, buffers.Length);buffers = newBuffers;}buffer = buffers[1 + bufferUpto] = allocator.GetByteBlock();bufferUpto++;ByteUpto = 0;ByteOffset += BYTE_BLOCK_SIZE;}
// Original:
public LruTaxonomyWriterCache(int cacheSize, LRUType lruType) {if (lruType == LRUType.LRU_HASHED) {this.cache = new NameHashIntCacheLRU(cacheSize);} else {this.cache = new NameIntCacheLRU(cacheSize);}}

// Translation:
public LruTaxonomyWriterCache(int cacheSize, LRUType lruType){if (lruType == LRUType.LRU_HASHED){this.cache = new NameHashInt32CacheLRU(cacheSize);}else{this.cache = new NameInt32CacheLRU(cacheSize);}}
// Original:
public boolean isShowSeriesKey(){return showSeriesKey.isSet(field_1_options);}

// Translation:
public bool IsShowSeriesKey(){return showSeriesKey.IsSet(field_1_options);}
// Original:
public static String toHex(final byte[] value){StringBuilder retVal = new StringBuilder();retVal.append('[');if (value != null && value.length > 0){for(int x = 0; x < value.length; x++){if (x>0) {retVal.append(", ");}retVal.append(toHex(value[x]));}}retVal.append(']');return retVal.toString();}

// Translation:
public static string ToHex(byte[] value){StringBuilder buffer = new StringBuilder();buffer.Append('[');for (int i = 0; i < value.Length; i++){if (i > 0){buffer.Append(", ");}buffer.Append(ToHex(value[i]));}buffer.Append(']');return buffer.ToString();}
// Original:
public void write(LittleEndianOutput out) {out.writeByte(sid + getPtgClass());out.writeShort(field_1_index_extern_sheet);writeCoordinates(out);}

// Translation:
public override void Write(ILittleEndianOutput out1){out1.WriteByte(sid + PtgClass);out1.WriteShort(field_1_index_extern_sheet);WriteCoordinates(out1);}
// Original:
public void flush() {writer.flush();}

// Translation:
public void flush(){_writer.flush();}
// Original:
public UsernamePasswordCredentialsProvider(String username, char[] password) {this.username = username;this.password = password;}

// Translation:
public UsernamePasswordCredentialsProvider(string username, char[] password){this.username = username;this.password = password;}
// Original:
public final List<String> getFooterLines(FooterKey keyName) {final List<FooterLine> src = getFooterLines();if (src.isEmpty())return Collections.emptyList();final ArrayList<String> r = new ArrayList<>(src.size());for (FooterLine f : src) {if (f.matches(keyName))r.add(f.getValue());}return r;}

// Translation:
public IList<string> GetFooterLines(FooterKey keyName){IList<FooterLine> src = GetFooterLines();if (src.IsEmpty()){return Sharpen.Collections.EmptyList<string>();}AList<string> r = new AList<string>(src.Count);foreach (FooterLine f in src){if (f.Matches(keyName)){r.AddItem(f.GetValue());}}return r;}
// Original:
public ActivityTaskStatus recordActivityTaskHeartbeat(RecordActivityTaskHeartbeatRequest request) {request = beforeClientExecution(request);return executeRecordActivityTaskHeartbeat(request);}

// Translation:
public virtual RecordActivityTaskHeartbeatResponse RecordActivityTaskHeartbeat(RecordActivityTaskHeartbeatRequest request){var options = new InvokeOptions();options.RequestMarshaller = RecordActivityTaskHeartbeatRequestMarshaller.Instance;options.ResponseUnmarshaller = RecordActivityTaskHeartbeatResponseUnmarshaller.Instance;return Invoke<RecordActivityTaskHeartbeatResponse>(request, options);}
// Original:
public DescribeStepResult describeStep(DescribeStepRequest request) {request = beforeClientExecution(request);return executeDescribeStep(request);}

// Translation:
public virtual DescribeStepResponse DescribeStep(DescribeStepRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeStepRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeStepResponseUnmarshaller.Instance;return Invoke<DescribeStepResponse>(request, options);}
// Original:
public DeleteMessageBatchResult deleteMessageBatch(String queueUrl, java.util.List<DeleteMessageBatchRequestEntry> entries) {return deleteMessageBatch(new DeleteMessageBatchRequest().withQueueUrl(queueUrl).withEntries(entries));}

// Translation:
public virtual DeleteMessageBatchResponse DeleteMessageBatch(string queueUrl, List<DeleteMessageBatchRequestEntry> entries){var request = new DeleteMessageBatchRequest();request.QueueUrl = queueUrl;request.Entries = entries;return DeleteMessageBatch(request);}
// Original:
public QueryScorer(Query query, IndexReader reader, String field) {init(query, field, reader, true);}

// Translation:
public QueryScorer(Query query, IndexReader reader, string field){Init(query, field, reader, true);}
// Original:
public CreateVpcPeeringAuthorizationResult createVpcPeeringAuthorization(CreateVpcPeeringAuthorizationRequest request) {request = beforeClientExecution(request);return executeCreateVpcPeeringAuthorization(request);}

// Translation:
public virtual CreateVpcPeeringAuthorizationResponse CreateVpcPeeringAuthorization(CreateVpcPeeringAuthorizationRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateVpcPeeringAuthorizationRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateVpcPeeringAuthorizationResponseUnmarshaller.Instance;return Invoke<CreateVpcPeeringAuthorizationResponse>(request, options);}
// Original:
public boolean contains(Object object) {if (object != null) {for (E element : a) {if (object.equals(element)) {return true;}}} else {for (E element : a) {if (element == null) {return true;}}}return false;}

// Translation:
public override bool contains(object @object){if (@object != null){foreach (E element in a){if (@object.Equals(element)){return true;}}}else{foreach (E element in a){if ((object)element == null){return true;}}}return false;}
// Original:
public DescribeDBSubnetGroupsResult describeDBSubnetGroups(DescribeDBSubnetGroupsRequest request) {request = beforeClientExecution(request);return executeDescribeDBSubnetGroups(request);}

// Translation:
public virtual DescribeDBSubnetGroupsResponse DescribeDBSubnetGroups(DescribeDBSubnetGroupsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeDBSubnetGroupsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeDBSubnetGroupsResponseUnmarshaller.Instance;return Invoke<DescribeDBSubnetGroupsResponse>(request, options);}
// Original:
public JobFlowExecutionStatusDetail(JobFlowExecutionState state, java.util.Date creationDateTime) {setState(state.toString());setCreationDateTime(creationDateTime);}

// Translation:
public JobFlowExecutionStatusDetail(JobFlowExecutionState state, DateTime creationDateTime){_state = state;_creationDateTime = creationDateTime;}
// Original:
public String toString() {return "more";}

// Translation:
public override string ToString(){return "more";}
// Original:
public KeyValue(String key, String value) {setKey(key);setValue(value);}

// Translation:
public KeyValue(string key, string value){_key = key;_value = value;}
// Original:
public void balancedTree(Object[] tokens, Object[] vals, int lo, int hi,TernaryTreeNode root) {if (lo > hi) return;int mid = (lo + hi) / 2;root = insert(root, (String) tokens[mid], vals[mid], 0);balancedTree(tokens, vals, lo, mid - 1, root);balancedTree(tokens, vals, mid + 1, hi, root);}

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

// Translation:
public override Object Clone(){PlotAreaRecord rec = new PlotAreaRecord();return rec;}
// Original:
public DeleteSecurityConfigurationResult deleteSecurityConfiguration(DeleteSecurityConfigurationRequest request) {request = beforeClientExecution(request);return executeDeleteSecurityConfiguration(request);}

// Translation:
public virtual DeleteSecurityConfigurationResponse DeleteSecurityConfiguration(DeleteSecurityConfigurationRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteSecurityConfigurationRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteSecurityConfigurationResponseUnmarshaller.Instance;return Invoke<DeleteSecurityConfigurationResponse>(request, options);}
// Original:
@Override public String toString() {return mapEntry.toString();}

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

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

// Translation:
public virtual ListJobsByStatusResponse ListJobsByStatus(ListJobsByStatusRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListJobsByStatusRequestMarshaller.Instance;options.ResponseUnmarshaller = ListJobsByStatusResponseUnmarshaller.Instance;return Invoke<ListJobsByStatusResponse>(request, options);}
// Original:
public UpdateClusterVersionResult updateClusterVersion(UpdateClusterVersionRequest request) {request = beforeClientExecution(request);return executeUpdateClusterVersion(request);}

// Translation:
public virtual UpdateClusterVersionResponse UpdateClusterVersion(UpdateClusterVersionRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateClusterVersionRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateClusterVersionResponseUnmarshaller.Instance;return Invoke<UpdateClusterVersionResponse>(request, options);}
// Original:
public PushCommand setForce(boolean force) {checkCallable();this.force = force;return this;}

// Translation:
public virtual NGit.Api.PushCommand SetForce(bool force){CheckCallable();this.force = force;return this;}
// Original:
public ListStreamsResult listStreams(ListStreamsRequest request) {request = beforeClientExecution(request);return executeListStreams(request);}

// Translation:
public virtual ListStreamsResponse ListStreams(ListStreamsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListStreamsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListStreamsResponseUnmarshaller.Instance;return Invoke<ListStreamsResponse>(request, options);}
// Original:
public boolean wasEscaped(int index) {return this.wasEscaped[index];}

// Translation:
public bool WasEscaped(int index){return this.wasEscaped[index];}
// Original:
public void setNewObjectId(AnyObjectId id) {newValue = id.copy();}

// Translation:
public virtual void SetNewObjectId(AnyObjectId id){newValue = id.Copy();}
// Original:
public BatchRefUpdate newBatchUpdate() {return new BatchRefUpdate(this);}

// Translation:
public virtual BatchRefUpdate NewBatchUpdate(){return new BatchRefUpdate(this);}
// Original:
public String toString() {return getClass().getSimpleName() + "(fields=" + fields.size() + ",delegate=" + postingsReader + ")";}

// Translation:
public override string ToString(){return "arc=" + arc + " state=" + state;}
// Original:
public CreateTrafficMirrorFilterRuleResult createTrafficMirrorFilterRule(CreateTrafficMirrorFilterRuleRequest request) {request = beforeClientExecution(request);return executeCreateTrafficMirrorFilterRule(request);}

// Translation:
public virtual CreateTrafficMirrorFilterRuleResponse CreateTrafficMirrorFilterRule(CreateTrafficMirrorFilterRuleRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateTrafficMirrorFilterRuleRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateTrafficMirrorFilterRuleResponseUnmarshaller.Instance;return Invoke<CreateTrafficMirrorFilterRuleResponse>(request, options);}
// Original:
public SendEventResult sendEvent(SendEventRequest request) {request = beforeClientExecution(request);return executeSendEvent(request);}

// Translation:
public virtual SendEventResponse SendEvent(SendEventRequest request){var options = new InvokeOptions();options.RequestMarshaller = SendEventRequestMarshaller.Instance;options.ResponseUnmarshaller = SendEventResponseUnmarshaller.Instance;return Invoke<SendEventResponse>(request, options);}
// Original:
public MissingRowDummyRecord(int rowNumber) {this.rowNumber = rowNumber;}

// Translation:
public MissingRowDummyRecord(int rowNumber){this.rowNumber = rowNumber;}
// Original:
public final int getLengthB() {return endB - beginB;}

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

// Translation:
public override void Decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations){for (int i = 0; i < iterations; ++i){long block = blocks[blocksOffset++];for (int shift = 63; shift >= 0; shift -= 1){values[valuesOffset++] = (int)(((long)((ulong)block >> shift)) & 1);}}}
// Original:
public void writeInt(int value) throws IOException {checkWritePrimitiveTypes();primitiveTypes.writeInt(value);}

// Translation:
public virtual void writeInt(int value){throw new System.NotImplementedException();}
// Original:
public ByteBuffer putInt(int index, int value) {throw new ReadOnlyBufferException();}

// Translation:
public override java.nio.ByteBuffer putInt(int index, int value){throw new System.NotImplementedException();}
// Original:
public K next() {return super.nextEntry().getKey();}

// Translation:
public override K next(){return this.nextEntry().key;}
// Original:
public RenameDetectionType getRenameDetectionType() {return renameDetectionType;}

// Translation:
public virtual DiffConfig.RenameDetectionType GetRenameDetectionType(){return renameDetectionType;}
// Original:
public ReplaceNetworkAclAssociationResult replaceNetworkAclAssociation(ReplaceNetworkAclAssociationRequest request) {request = beforeClientExecution(request);return executeReplaceNetworkAclAssociation(request);}

// Translation:
public virtual ReplaceNetworkAclAssociationResponse ReplaceNetworkAclAssociation(ReplaceNetworkAclAssociationRequest request){var options = new InvokeOptions();options.RequestMarshaller = ReplaceNetworkAclAssociationRequestMarshaller.Instance;options.ResponseUnmarshaller = ReplaceNetworkAclAssociationResponseUnmarshaller.Instance;return Invoke<ReplaceNetworkAclAssociationResponse>(request, options);}
// Original:
public String getFontName(){return _fontName;}

// Translation:
public String GetFontName(){return fontName;}
// Original:
public ViewSourceRecord(RecordInputStream in) {vs = in.readShort();}

// Translation:
public ViewSourceRecord(RecordInputStream in1){vs = in1.ReadShort();}
// Original:
public boolean hasTrackingRefUpdate() {return trackingRefUpdate != null;}

// Translation:
public virtual bool HasTrackingRefUpdate(){return trackingRefUpdate != null;}
// Original:
public boolean matches(int symbol, int minVocabSymbol, int maxVocabSymbol) {return set.contains(symbol);}

// Translation:
public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol){return set.Contains(symbol);}
// Original:
public ValueEval evaluate(EvaluationCell srcCell) {int sheetIndex = getSheetIndex(srcCell.getSheet());return evaluateAny(srcCell, sheetIndex, srcCell.getRowIndex(), srcCell.getColumnIndex(), new EvaluationTracker(_cache));}

// Translation:
public ValueEval Evaluate(IEvaluationCell srcCell){int sheetIndex = GetSheetIndex(srcCell.Sheet);return EvaluateAny(srcCell, sheetIndex, srcCell.RowIndex, srcCell.ColumnIndex, new EvaluationTracker(_cache));}
// Original:
public AcceptTransitGatewayVpcAttachmentResult acceptTransitGatewayVpcAttachment(AcceptTransitGatewayVpcAttachmentRequest request) {request = beforeClientExecution(request);return executeAcceptTransitGatewayVpcAttachment(request);}

// Translation:
public virtual AcceptTransitGatewayVpcAttachmentResponse AcceptTransitGatewayVpcAttachment(AcceptTransitGatewayVpcAttachmentRequest request){var options = new InvokeOptions();options.RequestMarshaller = AcceptTransitGatewayVpcAttachmentRequestMarshaller.Instance;options.ResponseUnmarshaller = AcceptTransitGatewayVpcAttachmentResponseUnmarshaller.Instance;return Invoke<AcceptTransitGatewayVpcAttachmentResponse>(request, options);}
// Original:
public String toString() {return "<opaque schema='" + this.schema + "' value='" + this.value + "'/>";}

// Translation:
public override string ToString(){return "<opaque schema='" + this.schema + "' value='" + this.value + "'/>";}
// Original:
public static FuzzySet createSetBasedOnQuality(int maxNumUniqueValues, float desiredMaxSaturation){int setSize=getNearestSetSize(maxNumUniqueValues,desiredMaxSaturation);return new FuzzySet(new FixedBitSet(setSize+1),setSize, hashFunctionForVersion(VERSION_CURRENT));}

// Translation:
public static FuzzySet CreateSetBasedOnQuality(int maxNumUniqueValues, float desiredMaxSaturation){var setSize = GetNearestSetSize(maxNumUniqueValues, desiredMaxSaturation);return new FuzzySet(new FixedBitSet(setSize + 1), setSize, HashFunctionForVersion(VERSION_CURRENT));}
// Original:
public DeregisterInstancesFromLoadBalancerRequest(String loadBalancerName, java.util.List<Instance> instances) {setLoadBalancerName(loadBalancerName);setInstances(instances);}

// Translation:
public DeregisterInstancesFromLoadBalancerRequest(string loadBalancerName, List<Instance> instances){_loadBalancerName = loadBalancerName;_instances = instances;}
// Original:
public DeleteIntegrationResult deleteIntegration(DeleteIntegrationRequest request) {request = beforeClientExecution(request);return executeDeleteIntegration(request);}

// Translation:
public virtual DeleteIntegrationResponse DeleteIntegration(DeleteIntegrationRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteIntegrationRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteIntegrationResponseUnmarshaller.Instance;return Invoke<DeleteIntegrationResponse>(request, options);}
// Original:
public Ref3DPtg(LittleEndianInput in)  {field_1_index_extern_sheet = in.readShort();readCoordinates(in);}

// Translation:
public Ref3DPtg(ILittleEndianInput in1){field_1_index_extern_sheet = in1.ReadShort();ReadCoordinates(in1);}
// Original:
public synchronized E peek() {try {return (E) elementData[elementCount - 1];} catch (IndexOutOfBoundsException e) {throw new EmptyStackException();}}

// Translation:
public virtual E peek(){lock (this){try{return (E)elementData[elementCount - 1];}catch (System.IndexOutOfRangeException){throw new java.util.EmptyStackException();}}}
// Original:
public CheckDomainTransferabilityResult checkDomainTransferability(CheckDomainTransferabilityRequest request) {request = beforeClientExecution(request);return executeCheckDomainTransferability(request);}

// Translation:
public virtual CheckDomainTransferabilityResponse CheckDomainTransferability(CheckDomainTransferabilityRequest request){var options = new InvokeOptions();options.RequestMarshaller = CheckDomainTransferabilityRequestMarshaller.Instance;options.ResponseUnmarshaller = CheckDomainTransferabilityResponseUnmarshaller.Instance;return Invoke<CheckDomainTransferabilityResponse>(request, options);}
// Original:
@Override public Iterator<K> iterator() {return new MultisetKeyIterator();}

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