yijunyu/c-to-rust huggingface dataset:
// Original:
public DescribeImagesResult describeImages() {return describeImages(new DescribeImagesRequest());}

// Translation:
public virtual DescribeImagesResponse DescribeImages(){return DescribeImages(new DescribeImagesRequest());}
// Original:
public void close() {_closed = true;}

// Translation:
public override void Close(){delegate1.Close();}
// Original:
public ListSignalingChannelsResult listSignalingChannels(ListSignalingChannelsRequest request) {request = beforeClientExecution(request);return executeListSignalingChannels(request);}

// Translation:
public virtual ListSignalingChannelsResponse ListSignalingChannels(ListSignalingChannelsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListSignalingChannelsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListSignalingChannelsResponseUnmarshaller.Instance;return Invoke<ListSignalingChannelsResponse>(request, options);}
// Original:
public MergeFacesRequest() {super("CloudPhoto", "2017-07-11", "MergeFaces", "cloudphoto");setProtocol(ProtocolType.HTTPS);}

// Translation:
public MergeFacesRequest(): base("CloudPhoto", "2017-07-11", "MergeFaces", "cloudphoto", "openAPI"){Protocol = ProtocolType.HTTPS;}
// Original:
public DetectTextResult detectText(DetectTextRequest request) {request = beforeClientExecution(request);return executeDetectText(request);}

// Translation:
public virtual DetectTextResponse DetectText(DetectTextRequest request){var options = new InvokeOptions();options.RequestMarshaller = DetectTextRequestMarshaller.Instance;options.ResponseUnmarshaller = DetectTextResponseUnmarshaller.Instance;return Invoke<DetectTextResponse>(request, options);}
// Original:
public DoubleBuffer get(double[] dst) {return get(dst, 0, dst.length);}

// Translation:
public virtual java.nio.DoubleBuffer get(double[] dst){return get(dst, 0, dst.Length);}
// Original:
public long getCreationTime() {return decodeTS(P_CTIME);}

// Translation:
public virtual long GetCreationTime(){return DecodeTS(P_CTIME);}
// Original:
public TreeFilter clone() {return new Binary(a.clone(), b.clone());}

// Translation:
public override TreeFilter Clone(){return new AndTreeFilter.Binary(a.Clone(), b.Clone());}
// Original:
public ByteBuffer putChar(char value) {int newPosition = position + SizeOf.CHAR;if (newPosition > limit) {throw new BufferOverflowException();}Memory.pokeShort(backingArray, offset + position, (short) value, order);position = newPosition;return this;}

// Translation:
public override java.nio.ByteBuffer putChar(char value){int newPosition = _position + libcore.io.SizeOf.CHAR;if (newPosition > _limit){throw new java.nio.BufferOverflowException();}libcore.io.Memory.pokeShort(backingArray, offset + _position, (short)value, _order);_position = newPosition;return this;}
// Original:
public String toString() {return String.format("Rect [(%d,%d)-(%d,%d): %dx%d]", x, y, x + w, y + h, w, h);}

// Translation:
public override string ToString(){java.lang.StringBuilder sb = new java.lang.StringBuilder(32);sb.append("Rect(");sb.append(left);sb.append(", ");sb.append(top);sb.append(" - ");sb.append(right);sb.append(", ");sb.append(bottom);sb.append(")");return sb.ToString();}
// Original:
public static LongBuffer wrap(long[] array) {return wrap(array, 0, array.length);}

// Translation:
public static java.nio.LongBuffer wrap(long[] array_1){return wrap(array_1, 0, array_1.Length);}
// Original:
public CharsRef clone() {return new CharsRef(chars, offset, length);}

// Translation:
public object Clone(){return new CharsRef(chars, Offset, Length);}
// Original:
public SpanNearClauseFactory(IndexReader reader, String fieldName, BasicQueryFactory qf) {this.reader = reader;this.fieldName = fieldName;this.weightBySpanQuery = new HashMap<>();this.qf = qf;}

// Translation:
public SpanNearClauseFactory(IndexReader reader, string fieldName, BasicQueryFactory qf) {this.reader = reader;this.fieldName = fieldName;this.weightBySpanQuery = new JCG.Dictionary<SpanQuery, float>();this.qf = qf;}
// Original:
public BeginRecord clone() {return copy();}

// Translation:
public override Object Clone(){BeginRecord br = new BeginRecord();return br;}
// Original:
public int start() {return start(0);}

// Translation:
public int start(){return start(0);}
// Original:
public DescribeGameSessionQueuesResult describeGameSessionQueues(DescribeGameSessionQueuesRequest request) {request = beforeClientExecution(request);return executeDescribeGameSessionQueues(request);}

// Translation:
public virtual DescribeGameSessionQueuesResponse DescribeGameSessionQueues(DescribeGameSessionQueuesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeGameSessionQueuesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeGameSessionQueuesResponseUnmarshaller.Instance;return Invoke<DescribeGameSessionQueuesResponse>(request, options);}
// Original:
public SubmitAttachmentStateChangesResult submitAttachmentStateChanges(SubmitAttachmentStateChangesRequest request) {request = beforeClientExecution(request);return executeSubmitAttachmentStateChanges(request);}

// Translation:
public virtual SubmitAttachmentStateChangesResponse SubmitAttachmentStateChanges(SubmitAttachmentStateChangesRequest request){var options = new InvokeOptions();options.RequestMarshaller = SubmitAttachmentStateChangesRequestMarshaller.Instance;options.ResponseUnmarshaller = SubmitAttachmentStateChangesResponseUnmarshaller.Instance;return Invoke<SubmitAttachmentStateChangesResponse>(request, options);}
// Original:
public UnicodeString getString(int id ){return field_3_strings.get( id );}

// Translation:
public UnicodeString GetString(int id){return (UnicodeString)field_3_strings[id];}
// Original:
public BigInteger getSignificand() {return _significand;}

// Translation:
public BigInteger GetSignificand(){return _significand;}
// Original:
public void join( AbstractEscherHolderRecord record ){rawDataContainer.concatenate(record.getRawData());}

// Translation:
public void Join(AbstractEscherHolderRecord record){rawDataContainer.Concatenate(record.RawData);}
// Original:
public static byte[] grow(byte[] array, int minSize) {assert minSize >= 0: "size must be positive (got " + minSize + "): likely integer overflow?";if (array.length < minSize) {return growExact(array, oversize(minSize, Byte.BYTES));} elsereturn array;}

// Translation:
public static byte[] Grow(byte[] array, int minSize){Debug.Assert(minSize >= 0, "size must be positive (got " + minSize + "): likely integer overflow?");if (array.Length < minSize){byte[] newArray = new byte[Oversize(minSize, 1)];Array.Copy(array, 0, newArray, 0, array.Length);return newArray;}else{return array;}}
// Original:
public boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;FlushInfo other = (FlushInfo) obj;if (estimatedSegmentSize != other.estimatedSegmentSize)return false;if (numDocs != other.numDocs)return false;return true;}

// Translation:
public override bool Equals(object obj){if (this == obj){return true;}if (obj == null){return false;}if (this.GetType() != obj.GetType()){return false;}FlushInfo other = (FlushInfo)obj;if (EstimatedSegmentSize != other.EstimatedSegmentSize){return false;}if (NumDocs != other.NumDocs){return false;}return true;}
// Original:
public void copyRawTo(int[] b, int o) {b[o] = w1;b[o + 1] = w2;b[o + 2] = w3;b[o + 3] = w4;b[o + 4] = w5;}

// Translation:
public virtual void CopyRawTo(int[] b, int o){b[o] = w1;b[o + 1] = w2;b[o + 2] = w3;b[o + 3] = w4;b[o + 4] = w5;}
// Original:
public ReadPipelineResult readPipeline(ReadPipelineRequest request) {request = beforeClientExecution(request);return executeReadPipeline(request);}

// Translation:
public virtual ReadPipelineResponse ReadPipeline(ReadPipelineRequest request){var options = new InvokeOptions();options.RequestMarshaller = ReadPipelineRequestMarshaller.Instance;options.ResponseUnmarshaller = ReadPipelineResponseUnmarshaller.Instance;return Invoke<ReadPipelineResponse>(request, options);}
// Original:
public BoostQueryNode(QueryNode query, float value) {if (query == null) {throw new QueryNodeError(new MessageImpl(QueryParserMessages.NODE_ACTION_NOT_SUPPORTED, "query", "null"));}this.value = value;setLeaf(false);allocate();add(query);}

// Translation:
public BoostQueryNode(IQueryNode query, float value){if (query == null){throw new QueryNodeError(new Message(QueryParserMessages.NODE_ACTION_NOT_SUPPORTED, "query", "null"));}this.value = value;IsLeaf = false;Allocate();Add(query);}
// Original:
public void setFallbackAlgorithm(DiffAlgorithm alg) {fallback = alg;}

// Translation:
public virtual void SetFallbackAlgorithm(DiffAlgorithm alg){fallback = alg;}
// Original:
public void add(Transition t) {find(t.min).starts.add(t);find(1+t.max).ends.add(t);}

// Translation:
public void Add(Transition t){Find(t.min).starts.Add(t);Find(1 + t.max).ends.Add(t);}
// Original:
public String toString() {StringBuilder buffer = new StringBuilder();buffer.append(" [FEATURE FORMULA ERRORS]\n");buffer.append("  checkCalculationErrors    = ");buffer.append("  checkEmptyCellRef         = ");buffer.append("  checkNumbersAsText        = ");buffer.append("  checkInconsistentRanges   = ");buffer.append("  checkInconsistentFormulas = ");buffer.append("  checkDateTimeFormats      = ");buffer.append("  checkUnprotectedFormulas  = ");buffer.append("  performDataValidation     = ");buffer.append(" [/FEATURE FORMULA ERRORS]\n");return buffer.toString();}

// Translation:
public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append(" [FEATURE FORMULA ERRORS]\n");buffer.Append("  checkCalculationErrors    = ");buffer.Append("  checkEmptyCellRef         = ");buffer.Append("  checkNumbersAsText        = ");buffer.Append("  checkInconsistentRanges   = ");buffer.Append("  checkInconsistentFormulas = ");buffer.Append("  checkDateTimeFormats      = ");buffer.Append("  checkUnprotectedFormulas  = ");buffer.Append("  performDataValidation     = ");buffer.Append(" [/FEATURE FORMULA ERRORS]\n");return buffer.ToString();}
// Original:
public void execute(Lexer lexer) {lexer.setType(type);}

// Translation:
public virtual void Execute(Lexer lexer){lexer.Type = type;}
// Original:
public UpgradePublishedSchemaResult upgradePublishedSchema(UpgradePublishedSchemaRequest request) {request = beforeClientExecution(request);return executeUpgradePublishedSchema(request);}

// Translation:
public virtual UpgradePublishedSchemaResponse UpgradePublishedSchema(UpgradePublishedSchemaRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpgradePublishedSchemaRequestMarshaller.Instance;options.ResponseUnmarshaller = UpgradePublishedSchemaResponseUnmarshaller.Instance;return Invoke<UpgradePublishedSchemaResponse>(request, options);}
// Original:
public int readRecordSID() {readPlain(buffer, 0, LittleEndianConsts.SHORT_SIZE);int sid = LittleEndian.getUShort(buffer, 0);shouldSkipEncryptionOnCurrentRecord = isNeverEncryptedRecord(sid);return sid;}

// Translation:
public int ReadRecordSID(){int sid = _le.ReadUShort();_rc4.SkipTwoBytes();_rc4.StartRecord(sid);return sid;}
// Original:
public CreateImageBuilderStreamingURLResult createImageBuilderStreamingURL(CreateImageBuilderStreamingURLRequest request) {request = beforeClientExecution(request);return executeCreateImageBuilderStreamingURL(request);}

// Translation:
public virtual CreateImageBuilderStreamingURLResponse CreateImageBuilderStreamingURL(CreateImageBuilderStreamingURLRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateImageBuilderStreamingURLRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateImageBuilderStreamingURLResponseUnmarshaller.Instance;return Invoke<CreateImageBuilderStreamingURLResponse>(request, options);}
// Original:
public SheetIdentifier(String bookName, NameIdentifier sheetIdentifier) {_bookName = bookName;_sheetIdentifier = sheetIdentifier;}

// Translation:
public SheetIdentifier(String bookName, NameIdentifier sheetIdentifier){_bookName = bookName;_sheetIdentifier = sheetIdentifier;}
// Original:
public boolean equals( Object o ) {return o instanceof PortugueseStemmer;}

// Translation:
public override bool Equals(object o){return o is PortugueseStemmer;}
// Original:
public PasswordRecord clone() {return copy();}

// Translation:
public override Object Clone(){return new PasswordRecord(field_1_password);}
// Original:
public DescribeTableRequest(String tableName) {setTableName(tableName);}

// Translation:
public DescribeTableRequest(string tableName){_tableName = tableName;}
// Original:
public ModifyCacheParameterGroupResult modifyCacheParameterGroup(ModifyCacheParameterGroupRequest request) {request = beforeClientExecution(request);return executeModifyCacheParameterGroup(request);}

// Translation:
public virtual ModifyCacheParameterGroupResponse ModifyCacheParameterGroup(ModifyCacheParameterGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = ModifyCacheParameterGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = ModifyCacheParameterGroupResponseUnmarshaller.Instance;return Invoke<ModifyCacheParameterGroupResponse>(request, options);}
// Original:
public E set(int location, E object) {ListIterator<E> it = listIterator(location);if (!it.hasNext()) {throw new IndexOutOfBoundsException();}E result = it.next();it.set(object);return result;}

// Translation:
public override E set(int location, E @object){java.util.ListIterator<E> it = listIterator(location);if (!it.hasNext()){throw new System.IndexOutOfRangeException();}E result = it.next();it.set(@object);return result;}
// Original:
public String toFormulaString() {return NumberToTextConverter.toText(field_1_value);}

// Translation:
public override String ToFormulaString(){return NumberToTextConverter.ToText(Value);}
// Original:
public ListBootstrapActionsResult listBootstrapActions(ListBootstrapActionsRequest request) {request = beforeClientExecution(request);return executeListBootstrapActions(request);}

// Translation:
public virtual ListBootstrapActionsResponse ListBootstrapActions(ListBootstrapActionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListBootstrapActionsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListBootstrapActionsResponseUnmarshaller.Instance;return Invoke<ListBootstrapActionsResponse>(request, options);}
// Original:
public void serialize(LittleEndianOutput out) {out.writeShort(_wStyle);out.writeShort(_cLine);out.writeShort(_dxMin);StringUtil.writeUnicodeString(out, _str);if(_unused != null) {out.writeByte(_unused);}}

// Translation:
public void Serialize(ILittleEndianOutput out1) {out1.WriteShort(_wStyle);out1.WriteShort(_cLine);out1.WriteShort(_dxMin);StringUtil.WriteUnicodeString(out1, _str);out1.WriteByte(_unused);}
// Original:
public SynonymFilter(TokenStream input, SynonymMap synonyms, boolean ignoreCase) {super(input);this.synonyms = synonyms;this.ignoreCase = ignoreCase;this.fst = synonyms.fst;if (fst == null) {throw new IllegalArgumentException("fst must be non-null");}this.fstReader = fst.getBytesReader();rollBufferSize = 1+synonyms.maxHorizontalContext;futureInputs = new PendingInput[rollBufferSize];futureOutputs = new PendingOutputs[rollBufferSize];for(int pos=0;pos<rollBufferSize;pos++) {futureInputs[pos] = new PendingInput();futureOutputs[pos] = new PendingOutputs();}scratchArc = new FST.Arc<>();}

// Translation:
public SynonymFilter(TokenStream input, SynonymMap synonyms, bool ignoreCase): base(input){termAtt = AddAttribute<ICharTermAttribute>();posIncrAtt = AddAttribute<IPositionIncrementAttribute>();posLenAtt = AddAttribute<IPositionLengthAttribute>();typeAtt = AddAttribute<ITypeAttribute>();offsetAtt = AddAttribute<IOffsetAttribute>();this.synonyms = synonyms;this.ignoreCase = ignoreCase;this.fst = synonyms.Fst;if (fst == null){throw new System.ArgumentException("fst must be non-null");}this.fstReader = fst.GetBytesReader();rollBufferSize = 1 + synonyms.MaxHorizontalContext;futureInputs = new PendingInput[rollBufferSize];futureOutputs = new PendingOutputs[rollBufferSize];for (int pos = 0; pos < rollBufferSize; pos++){futureInputs[pos] = new PendingInput();futureOutputs[pos] = new PendingOutputs();}scratchArc = new FST.Arc<BytesRef>();}
// Original:
public CreateApiResult createApi(CreateApiRequest request) {request = beforeClientExecution(request);return executeCreateApi(request);}

// Translation:
public virtual CreateApiResponse CreateApi(CreateApiRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateApiRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateApiResponseUnmarshaller.Instance;return Invoke<CreateApiResponse>(request, options);}
// Original:
public IndexOutput createOutput(String name, IOContext context) throws IOException {ensureOpen();if (context.context != Context.MERGE || context.mergeInfo.estimatedMergeBytes < minBytesDirect) {return delegate.createOutput(name, context);} else {return new NativeUnixIndexOutput(getDirectory().resolve(name), name, mergeBufferSize);}}

// Translation:
public IndexOutput createOutput(string name, IOContext context) throws IOException{ensureOpen();if (context.context != Context.MERGE || context.mergeInfo.estimatedMergeBytes < minBytesDirect){return @delegate.createOutput(name, context);}else{ensureCanWrite(name);return new NativeUnixIndexOutput(new File(Directory, name), mergeBufferSize);}}
// Original:
public void drawArc(int x, int y, int width, int height,int startAngle, int arcAngle){if (logger.check( POILogger.WARN ))logger.log(POILogger.WARN,"drawArc not supported");}

// Translation:
public void DrawArc(int x, int y, int width, int height,int startAngle, int arcAngle){if (Logger.Check(POILogger.WARN))Logger.Log(POILogger.WARN, "DrawArc not supported");}
// Original:
public UpdateUserSettingsResult updateUserSettings(UpdateUserSettingsRequest request) {request = beforeClientExecution(request);return executeUpdateUserSettings(request);}

// Translation:
public virtual UpdateUserSettingsResponse UpdateUserSettings(UpdateUserSettingsRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateUserSettingsRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateUserSettingsResponseUnmarshaller.Instance;return Invoke<UpdateUserSettingsResponse>(request, options);}
// Original:
public DeleteDiskSnapshotResult deleteDiskSnapshot(DeleteDiskSnapshotRequest request) {request = beforeClientExecution(request);return executeDeleteDiskSnapshot(request);}

// Translation:
public virtual DeleteDiskSnapshotResponse DeleteDiskSnapshot(DeleteDiskSnapshotRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteDiskSnapshotRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteDiskSnapshotResponseUnmarshaller.Instance;return Invoke<DeleteDiskSnapshotResponse>(request, options);}
// Original:
public ColumnInfoRecord() {setColumnWidth(2275);_options = 2;_xfIndex = 0x0f;field_6_reserved = 2; }

// Translation:
public ColumnInfoRecord(){this.ColumnWidth = 2275;_options = 2;_xf_index = 0x0f;field_6_reserved = 2; }
// Original:
public final long getLong(int index) {checkIndex(index, SizeOf.LONG);return Memory.peekLong(backingArray, offset + index, order);}

// Translation:
public sealed override long getLong(int index){checkIndex(index, libcore.io.SizeOf.LONG);return libcore.io.Memory.peekLong(backingArray, offset + index, _order);}
// Original:
public DeleteKnownHostKeysResult deleteKnownHostKeys(DeleteKnownHostKeysRequest request) {request = beforeClientExecution(request);return executeDeleteKnownHostKeys(request);}

// Translation:
public virtual DeleteKnownHostKeysResponse DeleteKnownHostKeys(DeleteKnownHostKeysRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteKnownHostKeysRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteKnownHostKeysResponseUnmarshaller.Instance;return Invoke<DeleteKnownHostKeysResponse>(request, options);}
// Original:
public DeleteSigningCertificateRequest(String certificateId) {setCertificateId(certificateId);}

// Translation:
public DeleteSigningCertificateRequest(string certificateId){_certificateId = certificateId;}
// Original:
public StopProcessingJobResult stopProcessingJob(StopProcessingJobRequest request) {request = beforeClientExecution(request);return executeStopProcessingJob(request);}

// Translation:
public virtual StopProcessingJobResponse StopProcessingJob(StopProcessingJobRequest request){var options = new InvokeOptions();options.RequestMarshaller = StopProcessingJobRequestMarshaller.Instance;options.ResponseUnmarshaller = StopProcessingJobResponseUnmarshaller.Instance;return Invoke<StopProcessingJobResponse>(request, options);}
// Original:
public TermsEnum getTermsEnum(Terms terms) throws IOException {switch(type) {case NONE:return TermsEnum.EMPTY;case ALL:return terms.iterator();case SINGLE:return new SingleTermsEnum(terms.iterator(), term);case NORMAL:return terms.intersect(this, null);default:throw new RuntimeException("unhandled case");}}

// Translation:
public virtual TermsEnum GetTermsEnum(Terms terms){switch (Type){case Lucene.Net.Util.Automaton.CompiledAutomaton.AUTOMATON_TYPE.NONE:return TermsEnum.EMPTY;case Lucene.Net.Util.Automaton.CompiledAutomaton.AUTOMATON_TYPE.ALL:return terms.GetIterator(null);case Lucene.Net.Util.Automaton.CompiledAutomaton.AUTOMATON_TYPE.SINGLE:return new SingleTermsEnum(terms.GetIterator(null), Term);case Lucene.Net.Util.Automaton.CompiledAutomaton.AUTOMATON_TYPE.PREFIX:return new PrefixTermsEnum(terms.GetIterator(null), Term);case Lucene.Net.Util.Automaton.CompiledAutomaton.AUTOMATON_TYPE.NORMAL:return terms.Intersect(this, null);default:throw new Exception("unhandled case");}}
// Original:
public void grow() {costs = ArrayUtil.grow(costs, 1+count);lastRightID = ArrayUtil.grow(lastRightID, 1+count);backPos = ArrayUtil.grow(backPos, 1+count);backWordPos = ArrayUtil.grow(backWordPos, 1+count);backIndex = ArrayUtil.grow(backIndex, 1+count);backID = ArrayUtil.grow(backID, 1+count);final Type[] newBackType = new Type[backID.length];System.arraycopy(backType, 0, newBackType, 0, backType.length);backType = newBackType;}

// Translation:
public void Grow(){costs = ArrayUtil.Grow(costs, 1 + count);lastRightID = ArrayUtil.Grow(lastRightID, 1 + count);backPos = ArrayUtil.Grow(backPos, 1 + count);backIndex = ArrayUtil.Grow(backIndex, 1 + count);backID = ArrayUtil.Grow(backID, 1 + count);JapaneseTokenizerType[] newBackType = new JapaneseTokenizerType[backID.Length];System.Array.Copy(backType, 0, newBackType, 0, backType.Length);backType = newBackType;}
// Original:
public int get(final int index){if (index >= _limit){throw new IndexOutOfBoundsException(index + " not accessible in a list of length " + _limit);}return _array[ index ];}

// Translation:
public int Get(int index){if (index >= _limit){throw new IndexOutOfRangeException(index + " not accessible in a list of length " + _limit);}return _array[index];}
// Original:
public LongBuffer slice() {return new ReadWriteLongArrayBuffer(remaining(), backingArray, offset + position);}

// Translation:
public override java.nio.LongBuffer slice(){return new java.nio.ReadWriteLongArrayBuffer(remaining(), backingArray, offset +_position);}
// Original:
public ListProblemsResult listProblems(ListProblemsRequest request) {request = beforeClientExecution(request);return executeListProblems(request);}

// Translation:
public virtual ListProblemsResponse ListProblems(ListProblemsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListProblemsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListProblemsResponseUnmarshaller.Instance;return Invoke<ListProblemsResponse>(request, options);}
// Original:
public static double pmt(double r, double n, double p, double f, boolean t) {double retval = 0;if (r == 0) {retval = -1*(f+p)/n;}else {double r1 = r + 1;retval = ( f + p * Math.pow(r1, n) ) * r/((t ? r1 : 1) * (1 - Math.pow(r1, n)));}return retval;}

// Translation:
public static double pmt(double r, double n, double p, double f, bool t){double retval = 0;if (r == 0){retval = -1 * (f + p) / n;}else{double r1 = r + 1;retval = (f + p * Math.Pow(r1, n)) * r/((t ? r1 : 1) * (1 - Math.Pow(r1, n)));}return retval;}