yijunyu/c-to-rust huggingface dataset:
// Original:
public void skip(long count) throws IOException {assert count >= 0;if (ord + count > valueCount || ord + count < 0) {throw new EOFException();}final int skipBuffer = (int) Math.min(count, blockSize - off);off += skipBuffer;ord += skipBuffer;count -= skipBuffer;if (count == 0L) {return;}assert off == blockSize;while (count >= blockSize) {final int token = in.readByte() & 0xFF;final int bitsPerValue = token >>> BPV_SHIFT;if (bitsPerValue > 64) {throw new IOException("Corrupted");}if ((token & MIN_VALUE_EQUALS_0) == 0) {readVLong(in);}final long blockBytes = PackedInts.Format.PACKED.byteCount(packedIntsVersion, blockSize, bitsPerValue);skipBytes(blockBytes);ord += blockSize;count -= blockSize;}if (count == 0L) {return;}assert count < blockSize;refill();ord += count;off += count;}

// Translation:
public void Skip(long count){Debug.Assert(count >= 0);if (ord + count > valueCount || ord + count < 0){throw new System.IO.EndOfStreamException();}int skipBuffer = (int)Math.Min(count, blockSize - off);off += skipBuffer;ord += skipBuffer;count -= skipBuffer;if (count == 0L){return;}Debug.Assert(off == blockSize);while (count >= blockSize){int token = @in.ReadByte() & 0xFF;int bitsPerValue = (int)((uint)token >> AbstractBlockPackedWriter.BPV_SHIFT);if (bitsPerValue > 64){throw new System.IO.IOException("Corrupted");}if ((token & AbstractBlockPackedWriter.MIN_VALUE_EQUALS_0) == 0){ReadVInt64(@in);}long blockBytes = PackedInt32s.Format.PACKED.ByteCount(packedIntsVersion, blockSize, bitsPerValue);SkipBytes(blockBytes);ord += blockSize;count -= blockSize;}if (count == 0L){return;}Debug.Assert(count < blockSize);Refill();ord += count;off += (int)count;}
// Original:
public GetDownloadUrlsRequest() {super("CloudPhoto", "2017-07-11", "GetDownloadUrls", "cloudphoto");setProtocol(ProtocolType.HTTPS);}

// Translation:
public GetDownloadUrlsRequest(): base("CloudPhoto", "2017-07-11", "GetDownloadUrls", "cloudphoto", "openAPI"){Protocol = ProtocolType.HTTPS;}
// Original:
public ListSecurityProfilesResult listSecurityProfiles(ListSecurityProfilesRequest request) {request = beforeClientExecution(request);return executeListSecurityProfiles(request);}

// Translation:
public virtual ListSecurityProfilesResponse ListSecurityProfiles(ListSecurityProfilesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListSecurityProfilesRequestMarshaller.Instance;options.ResponseUnmarshaller = ListSecurityProfilesResponseUnmarshaller.Instance;return Invoke<ListSecurityProfilesResponse>(request, options);}
// Original:
@Override public boolean contains(Object o) {return containsKey(o);}

// Translation:
public override bool contains(object o){return this._enclosing.containsKey(o);}
// Original:
public TerminalNode getToken(int ttype, int i) {if ( children==null || i < 0 || i >= children.size() ) {return null;}int j = -1; for (ParseTree o : children) {if ( o instanceof TerminalNode ) {TerminalNode tnode = (TerminalNode)o;Token symbol = tnode.getSymbol();if ( symbol.getType()==ttype ) {j++;if ( j == i ) {return tnode;}}}}return null;}

// Translation:
public virtual ITerminalNode GetToken(int ttype, int i){if (children == null || i < 0 || i >= children.Count){return null;}int j = -1;foreach (IParseTree o in children){if (o is ITerminalNode){ITerminalNode tnode = (ITerminalNode)o;IToken symbol = tnode.Symbol;if (symbol.Type == ttype){j++;if (j == i){return tnode;}}}}return null;}
// Original:
public void serialize(LittleEndianOutput out) {out.writeShort(_offset);out.writeShort(_fontIndex);}

// Translation:
public void Serialize(ILittleEndianOutput out1){out1.WriteShort(m_offset);out1.WriteShort(m_fontIndex);}
// Original:
public void incrementOpen() {useCnt.incrementAndGet();}

// Translation:
public virtual void IncrementOpen(){useCnt.IncrementAndGet();}
// Original:
public OneMerge(List<SegmentCommitInfo> segments) {if (0 == segments.size()) {throw new RuntimeException("segments must include at least one segment");}this.segments = new ArrayList<>(segments);int count = 0;for(SegmentCommitInfo info : segments) {count += info.info.maxDoc();}totalMaxDoc = count;mergeProgress = new OneMergeProgress();}

// Translation:
public OneMerge(IList<SegmentCommitInfo> segments){if (0 == segments.Count){throw new Exception("segments must include at least one segment");}this.Segments = new List<SegmentCommitInfo>(segments);int count = 0;foreach (SegmentCommitInfo info in segments){count += info.Info.DocCount;}TotalDocCount = count;}
// Original:
public final byte get() {if (position == limit) {throw new BufferUnderflowException();}return backingArray[offset + position++];}

// Translation:
public sealed override byte get(){if (_position == _limit){throw new java.nio.BufferUnderflowException();}return backingArray[offset + _position++];}
// Original:
public String toString() {StringBuilder sb = new StringBuilder(64);sb.append(getClass().getName());sb.append(" [");if (_isQuoted) {sb.append("'").append(_name).append("'");} else {sb.append(_name);}sb.append("]");return sb.toString();}

// Translation:
public override String ToString(){StringBuilder sb = new StringBuilder(64);sb.Append(this.GetType().Name);sb.Append(" [");if (_isQuoted){sb.Append("'").Append(_name).Append("'");}else{sb.Append(_name);}sb.Append("]");return sb.ToString();}
// Original:
public AssociateWebsiteCertificateAuthorityResult associateWebsiteCertificateAuthority(AssociateWebsiteCertificateAuthorityRequest request) {request = beforeClientExecution(request);return executeAssociateWebsiteCertificateAuthority(request);}

// Translation:
public virtual AssociateWebsiteCertificateAuthorityResponse AssociateWebsiteCertificateAuthority(AssociateWebsiteCertificateAuthorityRequest request){var options = new InvokeOptions();options.RequestMarshaller = AssociateWebsiteCertificateAuthorityRequestMarshaller.Instance;options.ResponseUnmarshaller = AssociateWebsiteCertificateAuthorityResponseUnmarshaller.Instance;return Invoke<AssociateWebsiteCertificateAuthorityResponse>(request, options);}
// Original:
public RevFilter clone() {return new PatternSearch(pattern());}

// Translation:
public override RevFilter Clone(){return new AuthorRevFilter.PatternSearch(Pattern());}
// Original:
public PredictionContext getParent(int index) {return null;}

// Translation:
public override PredictionContext GetParent(int index){return null;}
// Original:
public AttachVpnGatewayRequest(String vpnGatewayId, String vpcId) {setVpnGatewayId(vpnGatewayId);setVpcId(vpcId);}

// Translation:
public AttachVpnGatewayRequest(string vpnGatewayId, string vpcId){_vpnGatewayId = vpnGatewayId;_vpcId = vpcId;}
// Original:
public void onUpdate(DocumentsWriterFlushControl control, ThreadState state) {onInsert(control, state);onDelete(control, state);}

// Translation:
public virtual void OnUpdate(DocumentsWriterFlushControl control, ThreadState state){OnInsert(control, state);OnDelete(control, state);}
// Original:
public UpdateComponentResult updateComponent(UpdateComponentRequest request) {request = beforeClientExecution(request);return executeUpdateComponent(request);}

// Translation:
public virtual UpdateComponentResponse UpdateComponent(UpdateComponentRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateComponentRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateComponentResponseUnmarshaller.Instance;return Invoke<UpdateComponentResponse>(request, options);}
// Original:
public DeleteDashboardResult deleteDashboard(DeleteDashboardRequest request) {request = beforeClientExecution(request);return executeDeleteDashboard(request);}

// Translation:
public virtual DeleteDashboardResponse DeleteDashboard(DeleteDashboardRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteDashboardRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteDashboardResponseUnmarshaller.Instance;return Invoke<DeleteDashboardResponse>(request, options);}
// Original:
public byte[] getByteBlock() {if (freeBlocks == 0) {bytesUsed.addAndGet(blockSize);return new byte[blockSize];}final byte[] b = freeByteBlocks[--freeBlocks];freeByteBlocks[freeBlocks] = null;return b;}

// Translation:
public override byte[] GetByteBlock(){if (freeBlocks == 0){bytesUsed.AddAndGet(m_blockSize);return new byte[m_blockSize];}var b = freeByteBlocks[--freeBlocks];freeByteBlocks[freeBlocks] = null;return b;}
// Original:
public DisableLoggingResult disableLogging(DisableLoggingRequest request) {request = beforeClientExecution(request);return executeDisableLogging(request);}

// Translation:
public virtual DisableLoggingResponse DisableLogging(DisableLoggingRequest request){var options = new InvokeOptions();options.RequestMarshaller = DisableLoggingRequestMarshaller.Instance;options.ResponseUnmarshaller = DisableLoggingResponseUnmarshaller.Instance;return Invoke<DisableLoggingResponse>(request, options);}
// Original:
public TokenStream create(TokenStream input) {return new CJKWidthFilter(input);}

// Translation:
public override TokenStream Create(TokenStream input){return new CJKWidthFilter(input);}
// Original:
public void reset(int startOffset, int endOffset) {bufferUpto = startOffset / INT_BLOCK_SIZE;bufferOffset = bufferUpto * INT_BLOCK_SIZE;this.end = endOffset;upto = startOffset;level = 1;buffer = pool.buffers[bufferUpto];upto = startOffset & INT_BLOCK_MASK;final int firstSize = IntBlockPool.LEVEL_SIZE_ARRAY[0];if (startOffset+firstSize >= endOffset) {limit = endOffset & INT_BLOCK_MASK;} else {limit = upto+firstSize-1;}}

// Translation:
public void Reset(int startOffset, int endOffset){bufferUpto = startOffset / INT32_BLOCK_SIZE;bufferOffset = bufferUpto * INT32_BLOCK_SIZE;this.end = endOffset;upto = startOffset;level = 1;buffer = pool.buffers[bufferUpto];upto = startOffset & INT32_BLOCK_MASK;int firstSize = Int32BlockPool.LEVEL_SIZE_ARRAY[0];if (startOffset + firstSize >= endOffset){limit = endOffset & INT32_BLOCK_MASK;}else{limit = upto + firstSize - 1;}}
// Original:
public long ramBytesUsed() {return values.ramBytesUsed()+ super.ramBytesUsed()+ Long.BYTES+ RamUsageEstimator.NUM_BYTES_OBJECT_REF;}

// Translation:
public long RamBytesUsed(){return RamUsageEstimator.AlignObjectSize(3 * RamUsageEstimator.NUM_BYTES_OBJECT_REF) + docIDs.RamBytesUsed() + offsets.RamBytesUsed();}
// Original:
public PutItemOutcome putItem(Item item) {return putItemDelegate.putItem(item);}

// Translation:
public void PutItem(Document doc){PutItem(doc, null);}
// Original:
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {for (int i = 0; i < iterations; ++i) {final long byte0 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = byte0 >>> 2;final long byte1 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte0 & 3) << 4) | (byte1 >>> 4);final long byte2 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte1 & 15) << 2) | (byte2 >>> 6);values[valuesOffset++] = byte2 & 63;}}

// Translation:
public override void Decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations){for (int i = 0; i < iterations; ++i){long byte0 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = (long)((ulong)byte0 >> 2);long byte1 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte0 & 3) << 4) | ((long)((ulong)byte1 >> 4));long byte2 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte1 & 15) << 2) | ((long)((ulong)byte2 >> 6));values[valuesOffset++] = byte2 & 63;}}
// Original:
public String toString() {StringBuilder buffer = new StringBuilder();buffer.append("[DELTA]\n");buffer.append("    .maxchange = ").append(getMaxChange()).append("\n");buffer.append("[/DELTA]\n");return buffer.toString();}

// Translation:
public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append("[DELTA]\n");buffer.Append("    .maxChange      = ").Append(MaxChange).Append("\n");buffer.Append("[/DELTA]\n");return buffer.ToString();}
// Original:
public StartFaceDetectionResult startFaceDetection(StartFaceDetectionRequest request) {request = beforeClientExecution(request);return executeStartFaceDetection(request);}

// Translation:
public virtual StartFaceDetectionResponse StartFaceDetection(StartFaceDetectionRequest request){var options = new InvokeOptions();options.RequestMarshaller = StartFaceDetectionRequestMarshaller.Instance;options.ResponseUnmarshaller = StartFaceDetectionResponseUnmarshaller.Instance;return Invoke<StartFaceDetectionResponse>(request, options);}
// Original:
public DataValidation createValidation(DataValidationConstraint constraint, CellRangeAddressList cellRangeAddressList) {return new HSSFDataValidation(cellRangeAddressList, constraint);}

// Translation:
public IDataValidation CreateValidation(IDataValidationConstraint constraint, CellRangeAddressList cellRangeAddressList){return new HSSFDataValidation(cellRangeAddressList, constraint);}
// Original:
public DocumentStoredFieldVisitor(Set<String> fieldsToAdd) {this.fieldsToAdd = fieldsToAdd;}

// Translation:
public DocumentStoredFieldVisitor(ISet<string> fieldsToAdd){this.fieldsToAdd = fieldsToAdd;}
// Original:
public TokenStream create(TokenStream tokenStream) {return new HunspellStemFilter(tokenStream, dictionary, true, longestOnly);}

// Translation:
public override TokenStream Create(TokenStream tokenStream){return new HunspellStemFilter(tokenStream, dictionary, true, longestOnly);}
// Original:
public Repository getRepository() {return repository;}

// Translation:
public virtual Repository GetRepository(){return repository;}
// Original:
public DeleteMLModelResult deleteMLModel(DeleteMLModelRequest request) {request = beforeClientExecution(request);return executeDeleteMLModel(request);}

// Translation:
public virtual DeleteMLModelResponse DeleteMLModel(DeleteMLModelRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteMLModelRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteMLModelResponseUnmarshaller.Instance;return Invoke<DeleteMLModelResponse>(request, options);}
// Original:
public GetAccountLimitResult getAccountLimit(GetAccountLimitRequest request) {request = beforeClientExecution(request);return executeGetAccountLimit(request);}

// Translation:
public virtual GetAccountLimitResponse GetAccountLimit(GetAccountLimitRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetAccountLimitRequestMarshaller.Instance;options.ResponseUnmarshaller = GetAccountLimitResponseUnmarshaller.Instance;return Invoke<GetAccountLimitResponse>(request, options);}
// Original:
public final char[] GetSuffix(int len) {char[] value = new char[len];System.arraycopy(buffer, bufferPosition - len, value, 0, len);return value;}

// Translation:
public char[] GetSuffix(int len){char[] value_Renamed = new char[len];Array.Copy(buffer, bufferPosition - len, value_Renamed, 0, len);return value_Renamed;}
// Original:
public ModifyClientVpnEndpointResult modifyClientVpnEndpoint(ModifyClientVpnEndpointRequest request) {request = beforeClientExecution(request);return executeModifyClientVpnEndpoint(request);}

// Translation:
public virtual ModifyClientVpnEndpointResponse ModifyClientVpnEndpoint(ModifyClientVpnEndpointRequest request){var options = new InvokeOptions();options.RequestMarshaller = ModifyClientVpnEndpointRequestMarshaller.Instance;options.ResponseUnmarshaller = ModifyClientVpnEndpointResponseUnmarshaller.Instance;return Invoke<ModifyClientVpnEndpointResponse>(request, options);}
// Original:
public final boolean containsRow(int row) {return _firstRow <= row && _lastRow >= row;}

// Translation:
public bool ContainsRow(int row){return (_firstRow <= row) && (_lastRow >= row);}
// Original:
public int available() {return remainingBytes();}

// Translation:
public override int Available(){return delegate1.Available();}
// Original:
public RequestEnvironmentInfoRequest(EnvironmentInfoType infoType) {setInfoType(infoType.toString());}

// Translation:
public RequestEnvironmentInfoRequest(EnvironmentInfoType infoType){_infoType = infoType;}
// Original:
public void write(byte[] buf) throws IOException {write(buf, 0, buf.length);}

// Translation:
public override void Write(int b){try{BeginWrite();dst.Write(b);}catch (ThreadInterruptedException){throw WriteTimedOut();}finally{EndWrite();}}
// Original:
public ResetDBClusterParameterGroupResult resetDBClusterParameterGroup(ResetDBClusterParameterGroupRequest request) {request = beforeClientExecution(request);return executeResetDBClusterParameterGroup(request);}

// Translation:
public virtual ResetDBClusterParameterGroupResponse ResetDBClusterParameterGroup(ResetDBClusterParameterGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = ResetDBClusterParameterGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = ResetDBClusterParameterGroupResponseUnmarshaller.Instance;return Invoke<ResetDBClusterParameterGroupResponse>(request, options);}
// Original:
public void unwriteProtectWorkbook() {this.workbook.unwriteProtectWorkbook();}

// Translation:
public void UnwriteProtectWorkbook(){this.workbook.UnwriteProtectWorkbook();}
// Original:
public ANTLRInputStream(String input) {this.data = input.toCharArray();this.n = input.length();}

// Translation:
public AntlrInputStream(string input){this.data = input.ToCharArray();this.n = input.Length;}
// Original:
public ByteBuffer putShort(short value) {throw new ReadOnlyBufferException();}

// Translation:
public override java.nio.ByteBuffer putShort(short value){throw new java.nio.ReadOnlyBufferException();}
// Original:
public ReplaceIamInstanceProfileAssociationResult replaceIamInstanceProfileAssociation(ReplaceIamInstanceProfileAssociationRequest request) {request = beforeClientExecution(request);return executeReplaceIamInstanceProfileAssociation(request);}

// Translation:
public virtual ReplaceIamInstanceProfileAssociationResponse ReplaceIamInstanceProfileAssociation(ReplaceIamInstanceProfileAssociationRequest request){var options = new InvokeOptions();options.RequestMarshaller = ReplaceIamInstanceProfileAssociationRequestMarshaller.Instance;options.ResponseUnmarshaller = ReplaceIamInstanceProfileAssociationResponseUnmarshaller.Instance;return Invoke<ReplaceIamInstanceProfileAssociationResponse>(request, options);}
// Original:
public void add(String name, Expression expression) {map.put(name, expression);}

// Translation:
public void Add(string name, Expression expression){map[name] = expression;}
// Original:
public Ref3DPtg(CellReference c, int externIdx) {super(c);setExternSheetIndex(externIdx);}

// Translation:
public Ref3DPtg(CellReference cr, int externIdx):base(cr){ExternSheetIndex = externIdx;}
// Original:
public int readUShort() {byte[] buf = new byte[LittleEndianConsts.SHORT_SIZE];try {checkEOF(read(buf), LittleEndianConsts.SHORT_SIZE);} catch (IOException e) {throw new RuntimeException(e);}return LittleEndian.getUShort(buf);}

// Translation:
public int ReadUShort(){int ch1;int ch2;try{ch1 = in1.ReadByte();ch2 = in1.ReadByte();}catch (IOException e){throw new RuntimeException(e);}CheckEOF(ch1 | ch2);return (ch2 << 8) + (ch1 << 0);}
// Original:
public int stem(char s[], int len) {len = removeCase(s, len);len = removePossessives(s, len);if (len > 0) {len = normalize(s, len);}return len;}

// Translation:
public virtual int Stem(char[] s, int len){len = RemoveCase(s, len);len = RemovePossessives(s, len);if (len > 0){len = Normalize(s, len);}return len;}
// Original:
public static int getNearestSetSize(int maxNumberOfBits){int result=usableBitSetSizes[0];for (int i = 0; i < usableBitSetSizes.length; i++) {if(usableBitSetSizes[i]<=maxNumberOfBits){result=usableBitSetSizes[i];}}return result;}

// Translation:
public static int GetNearestSetSize(int maxNumberOfBits){var result = _usableBitSetSizes[0];foreach (var t in _usableBitSetSizes.Where(t => t <= maxNumberOfBits)){result = t;}return result;}
// Original:
public String toString() {return "AbbreviatedObjectId[" + name() + "]"; }

// Translation:
public override string ToString(){return "AbbreviatedObjectId[" + Name + "]";}
// Original:
public ListFacesRequest() {super("CloudPhoto", "2017-07-11", "ListFaces", "cloudphoto");setProtocol(ProtocolType.HTTPS);}

// Translation:
public ListFacesRequest(): base("CloudPhoto", "2017-07-11", "ListFaces", "cloudphoto", "openAPI"){Protocol = ProtocolType.HTTPS;}
// Original:
public BytesRef(int capacity) {this.bytes = new byte[capacity];}

// Translation:
public BytesRef(int capacity){this.bytes = new byte[capacity];}
// Original:
public DescribeFargateProfileResult describeFargateProfile(DescribeFargateProfileRequest request) {request = beforeClientExecution(request);return executeDescribeFargateProfile(request);}

// Translation:
public virtual DescribeFargateProfileResponse DescribeFargateProfile(DescribeFargateProfileRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeFargateProfileRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeFargateProfileResponseUnmarshaller.Instance;return Invoke<DescribeFargateProfileResponse>(request, options);}
// Original:
public GetOpenIdTokenForDeveloperIdentityResult getOpenIdTokenForDeveloperIdentity(GetOpenIdTokenForDeveloperIdentityRequest request) {request = beforeClientExecution(request);return executeGetOpenIdTokenForDeveloperIdentity(request);}

// Translation:
public virtual GetOpenIdTokenForDeveloperIdentityResponse GetOpenIdTokenForDeveloperIdentity(GetOpenIdTokenForDeveloperIdentityRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetOpenIdTokenForDeveloperIdentityRequestMarshaller.Instance;options.ResponseUnmarshaller = GetOpenIdTokenForDeveloperIdentityResponseUnmarshaller.Instance;return Invoke<GetOpenIdTokenForDeveloperIdentityResponse>(request, options);}
// Original:
public int countBytesWritten() {return _countBytesWritten;}

// Translation:
public int CountBytesWritten(){return _countBytesWritten;}
// Original:
public boolean containsAll(final IntList c){boolean rval = true;if (this != c){for (int j = 0; rval && (j < c._limit); j++){if (!contains(c._array[ j ])){rval = false;}}}return rval;}

// Translation:
public bool ContainsAll(IntList c){bool rval = true;if (this != c){for (int j = 0; rval && (j < c._limit); j++){if (!Contains(c._array[j])){rval = false;}}}return rval;}
// Original:
public void setTreeFilter(TreeFilter newFilter) {assertNotStarted();treeFilter = newFilter != null ? newFilter : TreeFilter.ALL;}

// Translation:
public virtual void SetTreeFilter(TreeFilter newFilter){AssertNotStarted();treeFilter = newFilter != null ? newFilter : TreeFilter.ALL;}
// Original:
public DBInstance promoteReadReplica(PromoteReadReplicaRequest request) {request = beforeClientExecution(request);return executePromoteReadReplica(request);}

// Translation:
public virtual PromoteReadReplicaResponse PromoteReadReplica(PromoteReadReplicaRequest request){var options = new InvokeOptions();options.RequestMarshaller = PromoteReadReplicaRequestMarshaller.Instance;options.ResponseUnmarshaller = PromoteReadReplicaResponseUnmarshaller.Instance;return Invoke<PromoteReadReplicaResponse>(request, options);}
// Original:
public final short getShort() {int newPosition = position + SizeOf.SHORT;if (newPosition > limit) {throw new BufferUnderflowException();}short result = Memory.peekShort(backingArray, offset + position, order);position = newPosition;return result;}

// Translation:
public sealed override short getShort(){int newPosition = _position + libcore.io.SizeOf.SHORT;if (newPosition > _limit){throw new java.nio.BufferUnderflowException();}short result = libcore.io.Memory.peekShort(backingArray, offset + _position, _order);_position = newPosition;return result;}
// Original:
public AttachClassicLinkVpcResult attachClassicLinkVpc(AttachClassicLinkVpcRequest request) {request = beforeClientExecution(request);return executeAttachClassicLinkVpc(request);}

// Translation:
public virtual AttachClassicLinkVpcResponse AttachClassicLinkVpc(AttachClassicLinkVpcRequest request){var options = new InvokeOptions();options.RequestMarshaller = AttachClassicLinkVpcRequestMarshaller.Instance;options.ResponseUnmarshaller = AttachClassicLinkVpcResponseUnmarshaller.Instance;return Invoke<AttachClassicLinkVpcResponse>(request, options);}