yijunyu/c-to-rust huggingface dataset:
// Original:
public AssociateMemberAccountResult associateMemberAccount(AssociateMemberAccountRequest request) {request = beforeClientExecution(request);return executeAssociateMemberAccount(request);}

// Translation:
public virtual AssociateMemberAccountResponse AssociateMemberAccount(AssociateMemberAccountRequest request){var options = new InvokeOptions();options.RequestMarshaller = AssociateMemberAccountRequestMarshaller.Instance;options.ResponseUnmarshaller = AssociateMemberAccountResponseUnmarshaller.Instance;return Invoke<AssociateMemberAccountResponse>(request, options);}
// Original:
public void run() {doRefreshProgress(mId, mProgress, mFromUser, true);mRefreshProgressRunnable = this;}

// Translation:
public virtual void run(){this._enclosing.doRefreshProgress(this.mId, this.mProgress, this.mFromUser, true);this._enclosing.mRefreshProgressRunnable = this;}
// Original:
public SetTerminationProtectionResult setTerminationProtection(SetTerminationProtectionRequest request) {request = beforeClientExecution(request);return executeSetTerminationProtection(request);}

// Translation:
public virtual SetTerminationProtectionResponse SetTerminationProtection(SetTerminationProtectionRequest request){var options = new InvokeOptions();options.RequestMarshaller = SetTerminationProtectionRequestMarshaller.Instance;options.ResponseUnmarshaller = SetTerminationProtectionResponseUnmarshaller.Instance;return Invoke<SetTerminationProtectionResponse>(request, options);}
// Original:
public String getErrorHeader(RecognitionException e) {int line = e.getOffendingToken().getLine();int charPositionInLine = e.getOffendingToken().getCharPositionInLine();return "line "+line+":"+charPositionInLine;}

// Translation:
public virtual string GetErrorHeader(RecognitionException e){int line = e.OffendingToken.Line;int charPositionInLine = e.OffendingToken.Column;return "line " + line + ":" + charPositionInLine;}
// Original:
public CharBuffer asReadOnlyBuffer() {CharToByteBufferAdapter buf = new CharToByteBufferAdapter(byteBuffer.asReadOnlyBuffer());buf.limit = limit;buf.position = position;buf.mark = mark;buf.byteBuffer.order = byteBuffer.order;return buf;}

// Translation:
public override java.nio.CharBuffer asReadOnlyBuffer(){java.nio.CharToByteBufferAdapter buf = new java.nio.CharToByteBufferAdapter(byteBuffer.asReadOnlyBuffer());buf._limit = _limit;buf._position = _position;buf._mark = _mark;buf.byteBuffer._order = byteBuffer._order;return buf;}
// Original:
public StopSentimentDetectionJobResult stopSentimentDetectionJob(StopSentimentDetectionJobRequest request) {request = beforeClientExecution(request);return executeStopSentimentDetectionJob(request);}

// Translation:
public virtual StopSentimentDetectionJobResponse StopSentimentDetectionJob(StopSentimentDetectionJobRequest request){var options = new InvokeOptions();options.RequestMarshaller = StopSentimentDetectionJobRequestMarshaller.Instance;options.ResponseUnmarshaller = StopSentimentDetectionJobResponseUnmarshaller.Instance;return Invoke<StopSentimentDetectionJobResponse>(request, options);}
// Original:
public ObjectIdSubclassMap<ObjectId> getNewObjectIds() {if (newObjectIds != null)return newObjectIds;return new ObjectIdSubclassMap<>();}

// Translation:
public virtual ObjectIdSubclassMap<ObjectId> GetNewObjectIds(){if (newObjectIds != null){return newObjectIds;}return new ObjectIdSubclassMap<ObjectId>();}
// Original:
public void clear() {hash = hash(new byte[0]);super.clear();}

// Translation:
protected internal override void Clear(){hash = Hash(new byte[0]);base.Clear();}
// Original:
public void reset() throws IOException {synchronized (lock) {checkNotClosed();if (mark == -1) {throw new IOException("Invalid mark");}pos = mark;}}

// Translation:
public override void reset(){lock (@lock){checkNotClosed();if (_mark == -1){throw new System.IO.IOException("Invalid mark");}pos = _mark;}}
// Original:
public RefErrorPtg(LittleEndianInput in)  {field_1_reserved = in.readInt();}

// Translation:
public RefErrorPtg(ILittleEndianInput in1){field_1_reserved = in1.ReadInt();}
// Original:
public SuspendGameServerGroupResult suspendGameServerGroup(SuspendGameServerGroupRequest request) {request = beforeClientExecution(request);return executeSuspendGameServerGroup(request);}

// Translation:
public virtual SuspendGameServerGroupResponse SuspendGameServerGroup(SuspendGameServerGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = SuspendGameServerGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = SuspendGameServerGroupResponseUnmarshaller.Instance;return Invoke<SuspendGameServerGroupResponse>(request, options);}
// Original:
public final ValueEval evaluate(ValueEval[] args, int srcRowIndex, int srcColumnIndex) {if (args.length != 3) {return ErrorEval.VALUE_INVALID;}return evaluate(srcRowIndex, srcColumnIndex, args[0], args[1], args[2]);}

// Translation:
public ValueEval Evaluate(ValueEval[] args, int srcRowIndex, int srcColumnIndex){if (args.Length != 3){return ErrorEval.VALUE_INVALID;}return Evaluate(srcRowIndex, srcColumnIndex, args[0], args[1], args[2]);}
// Original:
public GetRepoRequest() {super("cr", "2016-06-07", "GetRepo", "cr");setUriPattern("/repos/[RepoNamespace]/[RepoName]");setMethod(MethodType.GET);}

// Translation:
public GetRepoRequest(): base("cr", "2016-06-07", "GetRepo", "cr", "openAPI"){UriPattern = "/repos/[RepoNamespace]/[RepoName]";Method = MethodType.GET;}
// Original:
public void setDate(Date date) {if (date != null) {setDate(DateTools.dateToString(date, DateTools.Resolution.SECOND));} else {this.date = null;}}

// Translation:
public virtual void SetDate(DateTime? date){if (date.HasValue){SetDate(DateTools.DateToString(date.Value, DateTools.Resolution.SECOND));}else{this.date = null;}}
// Original:
public TokenStream create(TokenStream input) {return new GermanMinimalStemFilter(input);}

// Translation:
public override TokenStream Create(TokenStream input){return new GermanMinimalStemFilter(input);}
// Original:
public Object[] toArray() {return a.clone();}

// Translation:
public override object[] toArray(){return (object[])a.Clone();}
// Original:
public void write(char[] buffer, int offset, int len) {Arrays.checkOffsetAndCount(buffer.length, offset, len);synchronized (lock) {expand(len);System.arraycopy(buffer, offset, this.buf, this.count, len);this.count += len;}}

// Translation:
public override void write(char[] buffer, int offset, int len){java.util.Arrays.checkOffsetAndCount(buffer.Length, offset, len);lock (@lock){expand(len);System.Array.Copy(buffer, offset, this.buf, this.count, len);this.count += len;}}
// Original:
public static final RevFilter after(Date ts) {return after(ts.getTime());}

// Translation:
public static RevFilter After(long ts){return new CommitTimeRevFilterAfter(ts);}
// Original:
public DeleteGroupPolicyRequest(String groupName, String policyName) {setGroupName(groupName);setPolicyName(policyName);}

// Translation:
public DeleteGroupPolicyRequest(string groupName, string policyName){_groupName = groupName;_policyName = policyName;}
// Original:
public DeregisterTransitGatewayMulticastGroupMembersResult deregisterTransitGatewayMulticastGroupMembers(DeregisterTransitGatewayMulticastGroupMembersRequest request) {request = beforeClientExecution(request);return executeDeregisterTransitGatewayMulticastGroupMembers(request);}

// Translation:
public virtual DeregisterTransitGatewayMulticastGroupMembersResponse DeregisterTransitGatewayMulticastGroupMembers(DeregisterTransitGatewayMulticastGroupMembersRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeregisterTransitGatewayMulticastGroupMembersRequestMarshaller.Instance;options.ResponseUnmarshaller = DeregisterTransitGatewayMulticastGroupMembersResponseUnmarshaller.Instance;return Invoke<DeregisterTransitGatewayMulticastGroupMembersResponse>(request, options);}
// Original:
public BatchDeleteScheduledActionResult batchDeleteScheduledAction(BatchDeleteScheduledActionRequest request) {request = beforeClientExecution(request);return executeBatchDeleteScheduledAction(request);}

// Translation:
public virtual BatchDeleteScheduledActionResponse BatchDeleteScheduledAction(BatchDeleteScheduledActionRequest request){var options = new InvokeOptions();options.RequestMarshaller = BatchDeleteScheduledActionRequestMarshaller.Instance;options.ResponseUnmarshaller = BatchDeleteScheduledActionResponseUnmarshaller.Instance;return Invoke<BatchDeleteScheduledActionResponse>(request, options);}
// Original:
public CreateAlgorithmResult createAlgorithm(CreateAlgorithmRequest request) {request = beforeClientExecution(request);return executeCreateAlgorithm(request);}

// Translation:
public virtual CreateAlgorithmResponse CreateAlgorithm(CreateAlgorithmRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateAlgorithmRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateAlgorithmResponseUnmarshaller.Instance;return Invoke<CreateAlgorithmResponse>(request, options);}
// Original:
public int readUByte() {return readByte() & 0x00FF;}

// Translation:
public int ReadUByte(){CheckPosition(1);return _buf[_ReadIndex++] & 0xFF;}
// Original:
public void setLength(int sz) {NB.encodeInt32(info, infoOffset + P_SIZE, sz);}

// Translation:
public virtual void SetLength(int sz){NB.EncodeInt32(info, infoOffset + P_SIZE, sz);}
// Original:
public DescribeScalingProcessTypesResult describeScalingProcessTypes() {return describeScalingProcessTypes(new DescribeScalingProcessTypesRequest());}

// Translation:
public virtual DescribeScalingProcessTypesResponse DescribeScalingProcessTypes(){return DescribeScalingProcessTypes(new DescribeScalingProcessTypesRequest());}
// Original:
public ListResourceRecordSetsResult listResourceRecordSets(ListResourceRecordSetsRequest request) {request = beforeClientExecution(request);return executeListResourceRecordSets(request);}

// Translation:
public virtual ListResourceRecordSetsResponse ListResourceRecordSets(ListResourceRecordSetsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListResourceRecordSetsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListResourceRecordSetsResponseUnmarshaller.Instance;return Invoke<ListResourceRecordSetsResponse>(request, options);}
// Original:
public Token recoverInline(Parser recognizer)throws RecognitionException{InputMismatchException e = new InputMismatchException(recognizer);for (ParserRuleContext context = recognizer.getContext(); context != null; context = context.getParent()) {context.exception = e;}throw new ParseCancellationException(e);}

// Translation:
public override IToken RecoverInline(Parser recognizer){InputMismatchException e = new InputMismatchException(recognizer);for (ParserRuleContext context = recognizer.Context; context != null; context = ((ParserRuleContext)context.Parent)){context.exception = e;}throw new ParseCanceledException(e);}
// Original:
public SetTagsForResourceResult setTagsForResource(SetTagsForResourceRequest request) {request = beforeClientExecution(request);return executeSetTagsForResource(request);}

// Translation:
public virtual SetTagsForResourceResponse SetTagsForResource(SetTagsForResourceRequest request){var options = new InvokeOptions();options.RequestMarshaller = SetTagsForResourceRequestMarshaller.Instance;options.ResponseUnmarshaller = SetTagsForResourceResponseUnmarshaller.Instance;return Invoke<SetTagsForResourceResponse>(request, options);}
// Original:
public ModifyStrategyRequest() {super("CloudCallCenter", "2017-07-05", "ModifyStrategy", "CloudCallCenter", "innerAPI");}

// Translation:
public ModifyStrategyRequest(): base("aegis", "2016-11-11", "ModifyStrategy", "vipaegis", "openAPI"){Method = MethodType.POST;}
// Original:
public DescribeVpcEndpointServicesResult describeVpcEndpointServices(DescribeVpcEndpointServicesRequest request) {request = beforeClientExecution(request);return executeDescribeVpcEndpointServices(request);}

// Translation:
public virtual DescribeVpcEndpointServicesResponse DescribeVpcEndpointServices(DescribeVpcEndpointServicesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeVpcEndpointServicesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeVpcEndpointServicesResponseUnmarshaller.Instance;return Invoke<DescribeVpcEndpointServicesResponse>(request, options);}
// Original:
public EnableLoggingResult enableLogging(EnableLoggingRequest request) {request = beforeClientExecution(request);return executeEnableLogging(request);}

// Translation:
public virtual EnableLoggingResponse EnableLogging(EnableLoggingRequest request){var options = new InvokeOptions();options.RequestMarshaller = EnableLoggingRequestMarshaller.Instance;options.ResponseUnmarshaller = EnableLoggingResponseUnmarshaller.Instance;return Invoke<EnableLoggingResponse>(request, options);}
// Original:
public boolean contains(Object o) {return ConcurrentHashMap.this.containsValue(o);}

// Translation:
public override bool contains(object o){return this._enclosing.containsValue(o);}
// Original:
public SheetRangeIdentifier(String bookName, NameIdentifier firstSheetIdentifier, NameIdentifier lastSheetIdentifier) {super(bookName, firstSheetIdentifier);_lastSheetIdentifier = lastSheetIdentifier;}

// Translation:
public SheetRangeIdentifier(String bookName, NameIdentifier firstSheetIdentifier, NameIdentifier lastSheetIdentifier): base(bookName, firstSheetIdentifier){_lastSheetIdentifier = lastSheetIdentifier;}
// Original:
public DomainMetadataRequest(String domainName) {setDomainName(domainName);}

// Translation:
public DomainMetadataRequest(string domainName){_domainName = domainName;}
// Original:
public ParseException(Token currentTokenVal,int[][] expectedTokenSequencesVal, String[] tokenImageVal) {super(new MessageImpl(QueryParserMessages.INVALID_SYNTAX, initialise(currentTokenVal, expectedTokenSequencesVal, tokenImageVal)));this.currentToken = currentTokenVal;this.expectedTokenSequences = expectedTokenSequencesVal;this.tokenImage = tokenImageVal;}

// Translation:
public ParseException(Token currentToken,int[][] expectedTokenSequences,string[] tokenImage): base(Initialize(currentToken, expectedTokenSequences, tokenImage)){this.CurrentToken = currentToken;this.ExpectedTokenSequences = expectedTokenSequences;this.TokenImage = tokenImage;}
// Original:
public FetchPhotosRequest() {super("CloudPhoto", "2017-07-11", "FetchPhotos", "cloudphoto");setProtocol(ProtocolType.HTTPS);}

// Translation:
public FetchPhotosRequest(): base("CloudPhoto", "2017-07-11", "FetchPhotos", "cloudphoto", "openAPI"){Protocol = ProtocolType.HTTPS;}
// Original:
public PrintWriter writer() {return writer;}

// Translation:
public java.io.PrintWriter writer(){return _writer;}
// Original:
public NGramTokenizerFactory(Map<String, String> args) {super(args);minGramSize = getInt(args, "minGramSize", NGramTokenizer.DEFAULT_MIN_NGRAM_SIZE);maxGramSize = getInt(args, "maxGramSize", NGramTokenizer.DEFAULT_MAX_NGRAM_SIZE);if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

// Translation:
public NGramTokenizerFactory(IDictionary<string, string> args): base(args){minGramSize = GetInt32(args, "minGramSize", NGramTokenizer.DEFAULT_MIN_NGRAM_SIZE);maxGramSize = GetInt32(args, "maxGramSize", NGramTokenizer.DEFAULT_MAX_NGRAM_SIZE);if (args.Count > 0){throw new System.ArgumentException("Unknown parameters: " + args);}}
// Original:
public boolean isDirectoryFileConflict() {return dfConflict != null;}

// Translation:
public virtual bool IsDirectoryFileConflict(){return dfConflict != null;}
// Original:
public IndonesianStemFilter(TokenStream input, boolean stemDerivational) {super(input);this.stemDerivational = stemDerivational;}

// Translation:
public IndonesianStemFilter(TokenStream input, bool stemDerivational): base(input){this.stemDerivational = stemDerivational;termAtt = AddAttribute<ICharTermAttribute>();keywordAtt = AddAttribute<IKeywordAttribute>();}
// Original:
public CreateTrafficPolicyResult createTrafficPolicy(CreateTrafficPolicyRequest request) {request = beforeClientExecution(request);return executeCreateTrafficPolicy(request);}

// Translation:
public virtual CreateTrafficPolicyResponse CreateTrafficPolicy(CreateTrafficPolicyRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateTrafficPolicyRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateTrafficPolicyResponseUnmarshaller.Instance;return Invoke<CreateTrafficPolicyResponse>(request, options);}
// Original:
public void serialize(LittleEndianOutput out) {out.writeInt(fSD);out.writeInt(passwordVerifier);StringUtil.writeUnicodeString(out, title);out.write(securityDescriptor);}

// Translation:
public void Serialize(ILittleEndianOutput out1){out1.WriteInt(fSD);out1.WriteInt(passwordVerifier);StringUtil.WriteUnicodeString(out1, title);out1.Write(securityDescriptor);}
// Original:
public static double floor(double n, double s) {if (s==0 && n!=0) {return Double.NaN;} else {return (n==0 || s==0) ? 0 : Math.floor(n/s) * s;}}

// Translation:
public static double Floor(double n, double s){double f;if ((n < 0 && s > 0) || (n > 0 && s < 0) || (s == 0 && n != 0)){f = double.NaN;}else{f = (n == 0 || s == 0) ? 0 : Math.Floor(n / s) * s;}return f;}
// Original:
public ByteArrayDataOutput(byte[] bytes, int offset, int len) {reset(bytes, offset, len);}

// Translation:
public ByteArrayDataOutput(byte[] bytes, int offset, int len){Reset(bytes, offset, len);}
// Original:
public static List<Tree> getChildren(Tree t) {List<Tree> kids = new ArrayList<Tree>();for (int i=0; i<t.getChildCount(); i++) {kids.add(t.getChild(i));}return kids;}

// Translation:
public static IList<ITree> GetChildren(ITree t){IList<ITree> kids = new List<ITree>();for (int i = 0; i < t.ChildCount; i++){kids.Add(t.GetChild(i));}return kids;}
// Original:
public void clear() {Hashtable.this.clear();}

// Translation:
public override void clear(){this._enclosing.clear();}
// Original:
public RefreshAllRecord(boolean refreshAll) {this(0);setRefreshAll(refreshAll);}

// Translation:
public RefreshAllRecord(bool refreshAll): this(0){RefreshAll = (refreshAll);}
// Original:
public DeleteNamedQueryResult deleteNamedQuery(DeleteNamedQueryRequest request) {request = beforeClientExecution(request);return executeDeleteNamedQuery(request);}

// Translation:
public virtual DeleteNamedQueryResponse DeleteNamedQuery(DeleteNamedQueryRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteNamedQueryRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteNamedQueryResponseUnmarshaller.Instance;return Invoke<DeleteNamedQueryResponse>(request, options);}
// Original:
public GraphvizFormatter(ConnectionCosts costs) {this.costs = costs;this.bestPathMap = new HashMap<>();sb.append(formatHeader());sb.append("  init [style=invis]\n");sb.append("  init -> 0.0 [label=\"" + BOS_LABEL + "\"]\n");}

// Translation:
public GraphvizFormatter(ConnectionCosts costs){this.costs = costs;this.bestPathMap = new Dictionary<string, string>();sb.Append(FormatHeader());sb.Append("  init [style=invis]\n");sb.Append("  init -> 0.0 [label=\"" + BOS_LABEL + "\"]\n");}
// Original:
public CheckMultiagentRequest() {super("visionai-poc", "2020-04-08", "CheckMultiagent");setMethod(MethodType.POST);}

// Translation:
public CheckMultiagentRequest(): base("visionai-poc", "2020-04-08", "CheckMultiagent"){Method = MethodType.POST;}
// Original:
public ListUserProfilesResult listUserProfiles(ListUserProfilesRequest request) {request = beforeClientExecution(request);return executeListUserProfiles(request);}

// Translation:
public virtual ListUserProfilesResponse ListUserProfiles(ListUserProfilesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListUserProfilesRequestMarshaller.Instance;options.ResponseUnmarshaller = ListUserProfilesResponseUnmarshaller.Instance;return Invoke<ListUserProfilesResponse>(request, options);}
// Original:
public CreateRelationalDatabaseFromSnapshotResult createRelationalDatabaseFromSnapshot(CreateRelationalDatabaseFromSnapshotRequest request) {request = beforeClientExecution(request);return executeCreateRelationalDatabaseFromSnapshot(request);}

// Translation:
public virtual CreateRelationalDatabaseFromSnapshotResponse CreateRelationalDatabaseFromSnapshot(CreateRelationalDatabaseFromSnapshotRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateRelationalDatabaseFromSnapshotRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateRelationalDatabaseFromSnapshotResponseUnmarshaller.Instance;return Invoke<CreateRelationalDatabaseFromSnapshotResponse>(request, options);}
// Original:
public StartTaskResult startTask(StartTaskRequest request) {request = beforeClientExecution(request);return executeStartTask(request);}

// Translation:
public virtual StartTaskResponse StartTask(StartTaskRequest request){var options = new InvokeOptions();options.RequestMarshaller = StartTaskRequestMarshaller.Instance;options.ResponseUnmarshaller = StartTaskResponseUnmarshaller.Instance;return Invoke<StartTaskResponse>(request, options);}
// Original:
public Set<String> getIgnoredPaths() {return ignoredPaths;}

// Translation:
public virtual ICollection<string> GetIgnoredPaths(){return ignoredPaths;}
// Original:
public FeatSmartTag(RecordInputStream in) {data = in.readRemainder();}

// Translation:
public FeatSmartTag(RecordInputStream in1){data = in1.ReadRemainder();}
// Original:
public Change(ChangeAction action, ResourceRecordSet resourceRecordSet) {setAction(action.toString());setResourceRecordSet(resourceRecordSet);}

// Translation:
public Change(ChangeAction action, ResourceRecordSet resourceRecordSet){_action = action;_resourceRecordSet = resourceRecordSet;}
// Original:
public DeleteImageResult deleteImage(DeleteImageRequest request) {request = beforeClientExecution(request);return executeDeleteImage(request);}

// Translation:
public virtual DeleteImageResponse DeleteImage(DeleteImageRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteImageRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteImageResponseUnmarshaller.Instance;return Invoke<DeleteImageResponse>(request, options);}
// Original:
public CreateConfigurationSetResult createConfigurationSet(CreateConfigurationSetRequest request) {request = beforeClientExecution(request);return executeCreateConfigurationSet(request);}

// Translation:
public virtual CreateConfigurationSetResponse CreateConfigurationSet(CreateConfigurationSetRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateConfigurationSetRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateConfigurationSetResponseUnmarshaller.Instance;return Invoke<CreateConfigurationSetResponse>(request, options);}
// Original:
public Iterator<E> iterator() {Object[] snapshot = elements;return new CowIterator<E>(snapshot, 0, snapshot.length);}

// Translation:
public virtual java.util.Iterator<E> iterator(){object[] snapshot = elements;return new java.util.concurrent.CopyOnWriteArrayList.CowIterator<E>(snapshot, 0,snapshot.Length);}
// Original:
public void visitContainedRecords(RecordVisitor rv) {if (_recs.isEmpty()) {return;}rv.visitRecord(_bofRec);for (int i = 0; i < _recs.size(); i++) {RecordBase rb = _recs.get(i);if (rb instanceof RecordAggregate) {((RecordAggregate) rb).visitContainedRecords(rv);} else {rv.visitRecord((org.apache.poi.hssf.record.Record) rb);}}rv.visitRecord(EOFRecord.instance);}

// Translation:
public override void VisitContainedRecords(RecordVisitor rv){if (_recs.Count==0){return;}rv.VisitRecord(_bofRec);for (int i = 0; i < _recs.Count; i++){RecordBase rb = _recs[i];if (rb is RecordAggregate){((RecordAggregate)rb).VisitContainedRecords(rv);}else{rv.VisitRecord((Record)rb);}}rv.VisitRecord(EOFRecord.instance);}