yijunyu/c-to-rust huggingface dataset:
// Original:
public final Buffer clear() {position = 0;mark = UNSET_MARK;limit = capacity;return this;}

// Translation:
public java.nio.Buffer clear(){_position = 0;_mark = UNSET_MARK;_limit = _capacity;return this;}
// Original:
public int getNameIx(int definedNameIndex) {return _externalNameRecords[definedNameIndex].getIx();}

// Translation:
public int GetNameIx(int definedNameIndex){return _externalNameRecords[definedNameIndex].Ix;}
// Original:
public DeleteReceiptRuleResult deleteReceiptRule(DeleteReceiptRuleRequest request) {request = beforeClientExecution(request);return executeDeleteReceiptRule(request);}

// Translation:
public virtual DeleteReceiptRuleResponse DeleteReceiptRule(DeleteReceiptRuleRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteReceiptRuleRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteReceiptRuleResponseUnmarshaller.Instance;return Invoke<DeleteReceiptRuleResponse>(request, options);}
// Original:
public boolean equals(Object obj) {if (this == obj) return true;if (!super.equals(obj)) return false;if (getClass() != obj.getClass()) return false;SortedSetSortField other = (SortedSetSortField) obj;if (selector != other.selector) return false;return true;}

// Translation:
public override bool Equals(object obj){if (this == obj) return true;if (!base.Equals(obj)) return false;if (GetType() != obj.GetType()) return false;SortedSetSortField other = (SortedSetSortField)obj;if (selector != other.selector) return false;return true;}
// Original:
public JobFlowDetail(String jobFlowId, String name, JobFlowExecutionStatusDetail executionStatusDetail, JobFlowInstancesDetail instances) {setJobFlowId(jobFlowId);setName(name);setExecutionStatusDetail(executionStatusDetail);setInstances(instances);}

// Translation:
public JobFlowDetail(string jobFlowId, string name, JobFlowExecutionStatusDetail executionStatusDetail, JobFlowInstancesDetail instances){_jobFlowId = jobFlowId;_name = name;_executionStatusDetail = executionStatusDetail;_instances = instances;}
// Original:
public PutVoiceConnectorOriginationResult putVoiceConnectorOrigination(PutVoiceConnectorOriginationRequest request) {request = beforeClientExecution(request);return executePutVoiceConnectorOrigination(request);}

// Translation:
public virtual PutVoiceConnectorOriginationResponse PutVoiceConnectorOrigination(PutVoiceConnectorOriginationRequest request){var options = new InvokeOptions();options.RequestMarshaller = PutVoiceConnectorOriginationRequestMarshaller.Instance;options.ResponseUnmarshaller = PutVoiceConnectorOriginationResponseUnmarshaller.Instance;return Invoke<PutVoiceConnectorOriginationResponse>(request, options);}
// Original:
public DBInstance startDBInstance(StartDBInstanceRequest request) {request = beforeClientExecution(request);return executeStartDBInstance(request);}

// Translation:
public virtual StartDBInstanceResponse StartDBInstance(StartDBInstanceRequest request){var options = new InvokeOptions();options.RequestMarshaller = StartDBInstanceRequestMarshaller.Instance;options.ResponseUnmarshaller = StartDBInstanceResponseUnmarshaller.Instance;return Invoke<StartDBInstanceResponse>(request, options);}
// Original:
public DeleteChangeSetResult deleteChangeSet(DeleteChangeSetRequest request) {request = beforeClientExecution(request);return executeDeleteChangeSet(request);}

// Translation:
public virtual DeleteChangeSetResponse DeleteChangeSet(DeleteChangeSetRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteChangeSetRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteChangeSetResponseUnmarshaller.Instance;return Invoke<DeleteChangeSetResponse>(request, options);}
// Original:
public int nextIndex() {return pos + 1;}

// Translation:
public int nextIndex(){return this.pos + 1;}
// Original:
public DescribeGameSessionDetailsResult describeGameSessionDetails(DescribeGameSessionDetailsRequest request) {request = beforeClientExecution(request);return executeDescribeGameSessionDetails(request);}

// Translation:
public virtual DescribeGameSessionDetailsResponse DescribeGameSessionDetails(DescribeGameSessionDetailsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeGameSessionDetailsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeGameSessionDetailsResponseUnmarshaller.Instance;return Invoke<DescribeGameSessionDetailsResponse>(request, options);}
// Original:
public ListDatasetImportJobsResult listDatasetImportJobs(ListDatasetImportJobsRequest request) {request = beforeClientExecution(request);return executeListDatasetImportJobs(request);}

// Translation:
public virtual ListDatasetImportJobsResponse ListDatasetImportJobs(ListDatasetImportJobsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListDatasetImportJobsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListDatasetImportJobsResponseUnmarshaller.Instance;return Invoke<ListDatasetImportJobsResponse>(request, options);}
// Original:
public String toString() {return new StringBuilder().append("(").append(x).append(",").append(y).append(")").toString();}

// Translation:
public override string ToString(){return "Point(" + x + ", " + y + ")";}
// Original:
public CharBlockArray append(char c) {if (this.current.length == this.blockSize) {addBlock();}this.current.chars[this.current.length++] = c;this.length++;return this;}

// Translation:
public virtual CharBlockArray Append(char c){if (this.current.length == this.blockSize){AddBlock();}this.current.chars[this.current.length++] = c;this.length++;return this;}
// Original:
public SimpleBoolFunction(ValueSource source) {this.source = source;}

// Translation:
public SimpleBoolFunction(ValueSource source){this.m_source = source;}
// Original:
public String toStringUnquoted() {return getPrefix();}

// Translation:
public override string ToStringUnquoted(){return Prefix;}
// Original:
public static Transport open(URIish uri) throws NotSupportedException, TransportException {for (WeakReference<TransportProtocol> ref : protocols) {TransportProtocol proto = ref.get();if (proto == null) {protocols.remove(ref);continue;}if (proto.canHandle(uri, null, null))return proto.open(uri);}throw new NotSupportedException(MessageFormat.format(JGitText.get().URINotSupported, uri));}

// Translation:
public static NGit.Transport.Transport Open(URIish uri){foreach (JavaWeakReference<TransportProtocol> @ref in protocols){TransportProtocol proto = @ref.Get();if (proto == null){protocols.Remove(@ref);continue;}if (proto.CanHandle(uri, null, null)){return proto.Open(uri);}}throw new NGit.Errors.NotSupportedException(MessageFormat.Format(JGitText.Get().URINotSupported, uri));}
// Original:
public void mark(int readAheadLimit) throws IOException {throw new IOException("mark/reset not supported");}

// Translation:
public override void mark(int readAheadLimit){throw new System.IO.IOException("mark/reset not supported");}
// Original:
public DeleteClusterSecurityGroupResult deleteClusterSecurityGroup(DeleteClusterSecurityGroupRequest request) {request = beforeClientExecution(request);return executeDeleteClusterSecurityGroup(request);}

// Translation:
public virtual DeleteClusterSecurityGroupResponse DeleteClusterSecurityGroup(DeleteClusterSecurityGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteClusterSecurityGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteClusterSecurityGroupResponseUnmarshaller.Instance;return Invoke<DeleteClusterSecurityGroupResponse>(request, options);}
// Original:
public GlobalReplicationGroup rebalanceSlotsInGlobalReplicationGroup(RebalanceSlotsInGlobalReplicationGroupRequest request) {request = beforeClientExecution(request);return executeRebalanceSlotsInGlobalReplicationGroup(request);}

// Translation:
public virtual RebalanceSlotsInGlobalReplicationGroupResponse RebalanceSlotsInGlobalReplicationGroup(RebalanceSlotsInGlobalReplicationGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = RebalanceSlotsInGlobalReplicationGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = RebalanceSlotsInGlobalReplicationGroupResponseUnmarshaller.Instance;return Invoke<RebalanceSlotsInGlobalReplicationGroupResponse>(request, options);}
// Original:
public DeleteLocalGatewayRouteResult deleteLocalGatewayRoute(DeleteLocalGatewayRouteRequest request) {request = beforeClientExecution(request);return executeDeleteLocalGatewayRoute(request);}

// Translation:
public virtual DeleteLocalGatewayRouteResponse DeleteLocalGatewayRoute(DeleteLocalGatewayRouteRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteLocalGatewayRouteRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteLocalGatewayRouteResponseUnmarshaller.Instance;return Invoke<DeleteLocalGatewayRouteResponse>(request, options);}
// Original:
public DBCluster restoreDBClusterFromSnapshot(RestoreDBClusterFromSnapshotRequest request) {request = beforeClientExecution(request);return executeRestoreDBClusterFromSnapshot(request);}

// Translation:
public virtual RestoreDBClusterFromSnapshotResponse RestoreDBClusterFromSnapshot(RestoreDBClusterFromSnapshotRequest request){var options = new InvokeOptions();options.RequestMarshaller = RestoreDBClusterFromSnapshotRequestMarshaller.Instance;options.ResponseUnmarshaller = RestoreDBClusterFromSnapshotResponseUnmarshaller.Instance;return Invoke<RestoreDBClusterFromSnapshotResponse>(request, options);}
// Original:
public String getReading(int wordId, char surface[], int off, int len) {return null;}

// Translation:
public override string GetReading(int wordId, char[] surface, int off, int len){return null;}
// Original:
public CreateDBSnapshotRequest(String dBSnapshotIdentifier, String dBInstanceIdentifier) {setDBSnapshotIdentifier(dBSnapshotIdentifier);setDBInstanceIdentifier(dBInstanceIdentifier);}

// Translation:
public CreateDBSnapshotRequest(string dbSnapshotIdentifier, string dbInstanceIdentifier){_dbSnapshotIdentifier = dbSnapshotIdentifier;_dbInstanceIdentifier = dbInstanceIdentifier;}
// Original:
public RemoveRoleFromDBInstanceResult removeRoleFromDBInstance(RemoveRoleFromDBInstanceRequest request) {request = beforeClientExecution(request);return executeRemoveRoleFromDBInstance(request);}

// Translation:
public virtual RemoveRoleFromDBInstanceResponse RemoveRoleFromDBInstance(RemoveRoleFromDBInstanceRequest request){var options = new InvokeOptions();options.RequestMarshaller = RemoveRoleFromDBInstanceRequestMarshaller.Instance;options.ResponseUnmarshaller = RemoveRoleFromDBInstanceResponseUnmarshaller.Instance;return Invoke<RemoveRoleFromDBInstanceResponse>(request, options);}
// Original:
public Token nextToken() {if (i >= tokens.size()) {if (eofToken == null) {int start = -1;if (tokens.size() > 0) {int previousStop = tokens.get(tokens.size() - 1).getStopIndex();if (previousStop != -1) {start = previousStop + 1;}}int stop = Math.max(-1, start - 1);eofToken = _factory.create(new Pair<TokenSource, CharStream>(this, getInputStream()), Token.EOF, "EOF", Token.DEFAULT_CHANNEL, start, stop, getLine(), getCharPositionInLine());}return eofToken;}Token t = tokens.get(i);if (i == tokens.size() - 1 && t.getType() == Token.EOF) {eofToken = t;}i++;return t;}

// Translation:
public virtual IToken NextToken(){if (i >= tokens.Count){if (eofToken == null){int start = -1;if (tokens.Count > 0){int previousStop = tokens[tokens.Count - 1].StopIndex;if (previousStop != -1){start = previousStop + 1;}}int stop = Math.Max(-1, start - 1);eofToken = _factory.Create(Tuple.Create((ITokenSource)this, InputStream), TokenConstants.EOF, "EOF", TokenConstants.DefaultChannel, start, stop, Line, Column);}return eofToken;}IToken t = tokens[i];if (i == tokens.Count - 1 && t.Type == TokenConstants.EOF){eofToken = t;}i++;return t;}
// Original:
public QueryMaker getQueryMaker() {return null; }

// Translation:
public override IQueryMaker GetQueryMaker(){return null; }
// Original:
public GC(FileRepository repo) {this.repo = repo;this.pconfig = new PackConfig(repo);this.pm = NullProgressMonitor.INSTANCE;}

// Translation:
public GC(FileRepository repo){this.repo = repo;this.pm = NullProgressMonitor.INSTANCE;}
// Original:
public synchronized void setLength(int length) {super.setLength(length);}

// Translation:
public override void setLength(int length_1){lock (this){base.setLength(length_1);}}
// Original:
public CancelImportTaskResult cancelImportTask(CancelImportTaskRequest request) {request = beforeClientExecution(request);return executeCancelImportTask(request);}

// Translation:
public virtual CancelImportTaskResponse CancelImportTask(CancelImportTaskRequest request){var options = new InvokeOptions();options.RequestMarshaller = CancelImportTaskRequestMarshaller.Instance;options.ResponseUnmarshaller = CancelImportTaskResponseUnmarshaller.Instance;return Invoke<CancelImportTaskResponse>(request, options);}
// Original:
public int first() {return (current = start);}

// Translation:
public override int First(){return (current = start);}
// Original:
public DeleteDiskResult deleteDisk(DeleteDiskRequest request) {request = beforeClientExecution(request);return executeDeleteDisk(request);}

// Translation:
public virtual DeleteDiskResponse DeleteDisk(DeleteDiskRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteDiskRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteDiskResponseUnmarshaller.Instance;return Invoke<DeleteDiskResponse>(request, options);}
// Original:
public DeleteVpcEndpointConnectionNotificationsResult deleteVpcEndpointConnectionNotifications(DeleteVpcEndpointConnectionNotificationsRequest request) {request = beforeClientExecution(request);return executeDeleteVpcEndpointConnectionNotifications(request);}

// Translation:
public virtual DeleteVpcEndpointConnectionNotificationsResponse DeleteVpcEndpointConnectionNotifications(DeleteVpcEndpointConnectionNotificationsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteVpcEndpointConnectionNotificationsRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteVpcEndpointConnectionNotificationsResponseUnmarshaller.Instance;return Invoke<DeleteVpcEndpointConnectionNotificationsResponse>(request, options);}
// Original:
public final boolean equals(Object o) {if (o instanceof AnyObjectId) {return equals((AnyObjectId) o);}return false;}

// Translation:
public bool Equals(AnyObjectId other){return other != null ? Equals(this, other) : false;}
// Original:
public DescribeConfigurationSettingsRequest(String applicationName) {setApplicationName(applicationName);}

// Translation:
public DescribeConfigurationSettingsRequest(string applicationName){_applicationName = applicationName;}
// Original:
public ET next() {if (expectedModCount == list.modCount) {LinkedList.Link<ET> next = link.next;if (next != list.voidLink) {lastLink = link = next;pos++;return link.data;}throw new NoSuchElementException();}throw new ConcurrentModificationException();}

// Translation:
public ET next(){if (expectedModCount == list.modCount){java.util.LinkedList.Link<ET> next_1 = link.next;if (next_1 != list.voidLink){lastLink = link = next_1;pos++;return link.data;}throw new java.util.NoSuchElementException();}throw new java.util.ConcurrentModificationException();}
// Original:
public CreateConfigurationResult createConfiguration(CreateConfigurationRequest request) {request = beforeClientExecution(request);return executeCreateConfiguration(request);}

// Translation:
public virtual CreateConfigurationResponse CreateConfiguration(CreateConfigurationRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateConfigurationRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateConfigurationResponseUnmarshaller.Instance;return Invoke<CreateConfigurationResponse>(request, options);}
// Original:
public ResetClusterParameterGroupResult resetClusterParameterGroup(ResetClusterParameterGroupRequest request) {request = beforeClientExecution(request);return executeResetClusterParameterGroup(request);}

// Translation:
public virtual ResetClusterParameterGroupResponse ResetClusterParameterGroup(ResetClusterParameterGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = ResetClusterParameterGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = ResetClusterParameterGroupResponseUnmarshaller.Instance;return Invoke<ResetClusterParameterGroupResponse>(request, options);}
// Original:
public void mark(int readlimit) {in.mark(readlimit);}

// Translation:
public override void Mark(int readlimit){@in.Mark(readlimit);}
// Original:
public String toString() {StringBuilder buffer = new StringBuilder();buffer.append("[PASSWORD]\n");buffer.append("    .password = ").append(HexDump.shortToHex(field_1_password)).append("\n");buffer.append("[/PASSWORD]\n");return buffer.toString();}

// Translation:
public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append("[PASSWORD]\n");buffer.Append("    .password       = ").Append(StringUtil.ToHexString(Password)).Append("\n");buffer.Append("[/PASSWORD]\n");return buffer.ToString();}
// Original:
public SendTemplatedEmailResult sendTemplatedEmail(SendTemplatedEmailRequest request) {request = beforeClientExecution(request);return executeSendTemplatedEmail(request);}

// Translation:
public virtual SendTemplatedEmailResponse SendTemplatedEmail(SendTemplatedEmailRequest request){var options = new InvokeOptions();options.RequestMarshaller = SendTemplatedEmailRequestMarshaller.Instance;options.ResponseUnmarshaller = SendTemplatedEmailResponseUnmarshaller.Instance;return Invoke<SendTemplatedEmailResponse>(request, options);}
// Original:
public boolean equals(Object obj) {if ( !(obj instanceof Predicate) ) return false;if ( this == obj ) return true;Predicate p = (Predicate)obj;return this.ruleIndex == p.ruleIndex &&this.predIndex == p.predIndex &&this.isCtxDependent == p.isCtxDependent;}

// Translation:
public override bool Equals(object obj){if (!(obj is SemanticContext.Predicate)){return false;}if (this == obj){return true;}SemanticContext.Predicate p = (SemanticContext.Predicate)obj;return this.ruleIndex == p.ruleIndex && this.predIndex == p.predIndex && this.isCtxDependent == p.isCtxDependent;}
// Original:
public void writeBoolean(boolean value) throws IOException {checkWritePrimitiveTypes();primitiveTypes.writeBoolean(value);}

// Translation:
public virtual void writeBoolean(bool value){throw new System.NotImplementedException();}
// Original:
public boolean checkPosition(int position) {Iterator<PositionSpan> positionSpanIt = positionSpans.iterator();while (positionSpanIt.hasNext()) {PositionSpan posSpan = positionSpanIt.next();if (((position >= posSpan.start) && (position <= posSpan.end))) {return true;}}return false;}

// Translation:
public virtual bool CheckPosition(int position){foreach (var positionSpan in _positionSpans){if ((position >= positionSpan.Start) && (position <= positionSpan.End)){return true;}}return false;}
// Original:
public static int log(long x, int base) {if (base <= 1) {throw new IllegalArgumentException("base must be > 1");}int ret = 0;while (x >= base) {x /= base;ret++;}return ret;}

// Translation:
public static int Log(long x, int @base){if (@base <= 1){throw new System.ArgumentException("base must be > 1");}int ret = 0;while (x >= @base){x /= @base;ret++;}return ret;}
// Original:
public final LongBuffer get(long[] dst, int dstOffset, int longCount) {if (longCount > remaining()) {throw new BufferUnderflowException();}System.arraycopy(backingArray, offset + position, dst, dstOffset, longCount);position += longCount;return this;}

// Translation:
public sealed override java.nio.LongBuffer get(long[] dst, int dstOffset, int longCount){if (longCount > remaining()){throw new java.nio.BufferUnderflowException();}System.Array.Copy(backingArray, offset + _position, dst, dstOffset, longCount);_position += longCount;return this;}
// Original:
public boolean equals(Object obj) {return obj == this;}

// Translation:
public override bool Equals(object obj){return obj == this;}
// Original:
public void exportRepository(String name, Repository db) {exports.put(nameWithDotGit(name), db);}

// Translation:
public virtual void ExportRepository(string name, Repository db){exports.Put(NameWithDotGit(name), db);}
// Original:
public void println(long l) {println(String.valueOf(l));}

// Translation:
public virtual void println(long l){println(l.ToString());}
// Original:
public HSSFFormulaEvaluator createFormulaEvaluator(){return new HSSFFormulaEvaluator(workbook);}

// Translation:
public NPOI.SS.UserModel.IFormulaEvaluator CreateFormulaEvaluator(){return new HSSFFormulaEvaluator(workbook);}
// Original:
public boolean equals(Object obj) {if ( obj==null || !(obj instanceof IntervalSet) ) {return false;}IntervalSet other = (IntervalSet)obj;return this.intervals.equals(other.intervals);}

// Translation:
public override bool Equals(object obj){if (obj == null || !(obj is Antlr4.Runtime.Misc.IntervalSet)){return false;}Antlr4.Runtime.Misc.IntervalSet other = (Antlr4.Runtime.Misc.IntervalSet)obj;return this.intervals.SequenceEqual(other.intervals);}
// Original:
public FileMode getIndexFileMode(DirCacheIterator indexIter) {final FileMode wtMode = getEntryFileMode();if (indexIter == null) {return wtMode;}final FileMode iMode = indexIter.getEntryFileMode();if (getOptions().isFileMode() && iMode != FileMode.GITLINK && iMode != FileMode.TREE) {return wtMode;}if (!getOptions().isFileMode()) {if (FileMode.REGULAR_FILE == wtMode&& FileMode.EXECUTABLE_FILE == iMode) {return iMode;}if (FileMode.EXECUTABLE_FILE == wtMode&& FileMode.REGULAR_FILE == iMode) {return iMode;}}if (FileMode.GITLINK == iMode&& FileMode.TREE == wtMode && !getOptions().isDirNoGitLinks()) {return iMode;}if (FileMode.TREE == iMode&& FileMode.GITLINK == wtMode) {return iMode;}return wtMode;}

// Translation:
public virtual FileMode GetIndexFileMode(DirCacheIterator indexIter){FileMode wtMode = EntryFileMode;if (indexIter == null){return wtMode;}if (GetOptions().IsFileMode()){return wtMode;}FileMode iMode = indexIter.EntryFileMode;if (FileMode.REGULAR_FILE == wtMode && FileMode.EXECUTABLE_FILE == iMode){return iMode;}if (FileMode.EXECUTABLE_FILE == wtMode && FileMode.REGULAR_FILE == iMode){return iMode;}return wtMode;}
// Original:
public CreateScheduledActionResult createScheduledAction(CreateScheduledActionRequest request) {request = beforeClientExecution(request);return executeCreateScheduledAction(request);}

// Translation:
public virtual CreateScheduledActionResponse CreateScheduledAction(CreateScheduledActionRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateScheduledActionRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateScheduledActionResponseUnmarshaller.Instance;return Invoke<CreateScheduledActionResponse>(request, options);}
// Original:
public PackConfig getConfig() {return config;}

// Translation:
public virtual PackConfig GetConfig(){return this._enclosing.config;}
// Original:
public CharBuffer put(char c) {throw new ReadOnlyBufferException();}

// Translation:
public override java.nio.CharBuffer put(char c){throw new java.nio.ReadOnlyBufferException();}
// Original:
public DeleteDistributionRequest(String id, String ifMatch) {setId(id);setIfMatch(ifMatch);}

// Translation:
public DeleteDistributionRequest(string id, string ifMatch){_id = id;_ifMatch = ifMatch;}
// Original:
public static long pop_andnot(long[] arr1, long[] arr2, int wordOffset, int numWords) {long popCount = 0;for (int i = wordOffset, end = wordOffset + numWords; i < end; ++i) {popCount += Long.bitCount(arr1[i] & ~arr2[i]);}return popCount;}

// Translation:
public static long Pop_AndNot(long[] arr1, long[] arr2, int wordOffset, int numWords){long popCount = 0;for (int i = wordOffset, end = wordOffset + numWords; i < end; ++i){popCount += (arr1[i] & ~arr2[i]).PopCount();}return popCount;}
// Original:
public boolean include(TreeWalk walker) {return true;}

// Translation:
public override bool Include(TreeWalk walker){return true;}