yijunyu/c-to-rust huggingface dataset:
// Original:
public static ReaderIterator getReaderIteratorNoHeader(DataInput in, Format format, int version,int valueCount, int bitsPerValue, int mem) {checkVersion(version);return new PackedReaderIterator(format, version, valueCount, bitsPerValue, in, mem);}

// Translation:
public static IReaderIterator GetReaderIteratorNoHeader(DataInput @in, Format format, int version, int valueCount, int bitsPerValue, int mem){CheckVersion(version);return new PackedReaderIterator(format, version, valueCount, bitsPerValue, @in, mem);}
// Original:
public DoubleBuffer put(int index, double c) {throw new ReadOnlyBufferException();}

// Translation:
public override java.nio.DoubleBuffer put(int index, double c){throw new java.nio.ReadOnlyBufferException();}
// Original:
public StashDropCommand stashDrop() {return new StashDropCommand(repo);}

// Translation:
public virtual StashDropCommand StashDrop(){return new StashDropCommand(repo);}
// Original:
public boolean isUnmappable() {return this.type == TYPE_UNMAPPABLE_CHAR;}

// Translation:
public virtual bool isUnmappable(){return this.type == TYPE_UNMAPPABLE_CHAR;}
// Original:
public byte readByte() {checkPosition(1);return (byte)read();}

// Translation:
public int ReadByte(){CheckPosition(1);return _buf[_ReadIndex++];}
// Original:
public void decode(long[] blocks, int blocksOffset, int[] values,int valuesOffset, int iterations) {if (bitsPerValue > 32) {throw new UnsupportedOperationException("Cannot decode " + bitsPerValue + "-bits values into an int[]");}for (int i = 0; i < iterations; ++i) {final long block = blocks[blocksOffset++];valuesOffset = decode(block, values, valuesOffset);}}

// Translation:
public override void Decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations){if (bitsPerValue > 32){throw new System.NotSupportedException("Cannot decode " + bitsPerValue + "-bits values into an int[]");}for (int i = 0; i < iterations; ++i){long block = blocks[blocksOffset++];valuesOffset = Decode(block, values, valuesOffset);}}
// Original:
public CustomAnalyzerConfig build() {return new CustomAnalyzerConfig(this);}

// Translation:
public CompositeReaderContext Build(){return (CompositeReaderContext)Build(null, reader, 0, 0);}
// Original:
public UpdateAddressBookResult updateAddressBook(UpdateAddressBookRequest request) {request = beforeClientExecution(request);return executeUpdateAddressBook(request);}

// Translation:
public virtual UpdateAddressBookResponse UpdateAddressBook(UpdateAddressBookRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateAddressBookRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateAddressBookResponseUnmarshaller.Instance;return Invoke<UpdateAddressBookResponse>(request, options);}
// Original:
public String toString() {return String.format("Point [%dx%d]", x, y);}

// Translation:
public override string ToString(){return "Point(" + x + ", " + y + ")";}
// Original:
public DescribeAccountAttributesResult describeAccountAttributes(DescribeAccountAttributesRequest request) {request = beforeClientExecution(request);return executeDescribeAccountAttributes(request);}

// Translation:
public virtual DescribeAccountAttributesResponse DescribeAccountAttributes(DescribeAccountAttributesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeAccountAttributesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeAccountAttributesResponseUnmarshaller.Instance;return Invoke<DescribeAccountAttributesResponse>(request, options);}
// Original:
public static final RevFilter before(long ts) {return new Before(ts);}

// Translation:
public static RevFilter Before(long ts){return new CommitTimeRevFilterBefore(ts);}
// Original:
public void seekExact(BytesRef target, TermState otherState) {if (!target.equals(term)) {state.copyFrom(otherState);term = BytesRef.deepCopyOf(target);seekPending = true;}}

// Translation:
public override void SeekExact(BytesRef target, TermState otherState){Debug.Assert(otherState != null && otherState is BlockTermState);Debug.Assert(!doOrd || ((BlockTermState)otherState).Ord < outerInstance.numTerms);state.CopyFrom(otherState);seekPending = true;indexIsCurrent = false;term.CopyBytes(target);}
// Original:
public DescribeClusterParameterGroupsResult describeClusterParameterGroups(DescribeClusterParameterGroupsRequest request) {request = beforeClientExecution(request);return executeDescribeClusterParameterGroups(request);}

// Translation:
public virtual DescribeClusterParameterGroupsResponse DescribeClusterParameterGroups(DescribeClusterParameterGroupsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeClusterParameterGroupsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeClusterParameterGroupsResponseUnmarshaller.Instance;return Invoke<DescribeClusterParameterGroupsResponse>(request, options);}
// Original:
public BatchGetApplicationsResult batchGetApplications(BatchGetApplicationsRequest request) {request = beforeClientExecution(request);return executeBatchGetApplications(request);}

// Translation:
public virtual BatchGetApplicationsResponse BatchGetApplications(BatchGetApplicationsRequest request){var options = new InvokeOptions();options.RequestMarshaller = BatchGetApplicationsRequestMarshaller.Instance;options.ResponseUnmarshaller = BatchGetApplicationsResponseUnmarshaller.Instance;return Invoke<BatchGetApplicationsResponse>(request, options);}
// Original:
public String toString() {return "dels=" + Arrays.toString(item);}

// Translation:
public override string ToString(){return "dels=" + Arrays.ToString((Term[])item);}
// Original:
public FreeRefFunction findFunction(String name) {FreeRefFunction evaluatorForFunction;for (UDFFinder pack : _usedToolPacks) {evaluatorForFunction = pack.findFunction(name);if (evaluatorForFunction != null) {return evaluatorForFunction;}}return null;}

// Translation:
public override FreeRefFunction FindFunction(String name){FreeRefFunction evaluatorForFunction;foreach (UDFFinder pack in _usedToolPacks){evaluatorForFunction = pack.FindFunction(name);if (evaluatorForFunction != null){return evaluatorForFunction;}}return null;}
// Original:
public String toString(){StringBuilder sb = new StringBuilder();sb.append("[LABEL]\n");sb.append("    .row       = ").append(HexDump.shortToHex(getRow())).append("\n");sb.append("    .column    = ").append(HexDump.shortToHex(getColumn())).append("\n");sb.append("    .xfindex   = ").append(HexDump.shortToHex(getXFIndex())).append("\n");sb.append("    .string_len= ").append(HexDump.shortToHex(field_4_string_len)).append("\n");sb.append("    .unicode_flag= ").append(HexDump.byteToHex(field_5_unicode_flag)).append("\n");sb.append("    .value       = ").append(getValue()).append("\n");sb.append("[/LABEL]\n");return sb.toString();}

// Translation:
public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append("[LABEL]\n");buffer.Append("    .row            = ").Append(StringUtil.ToHexString(Row)).Append("\n");buffer.Append("    .column         = ").Append(StringUtil.ToHexString(Column)).Append("\n");buffer.Append("    .xfindex        = ").Append(StringUtil.ToHexString(XFIndex)).Append("\n");buffer.Append("    .string_len       = ").Append(StringUtil.ToHexString(field_4_string_len)).Append("\n");buffer.Append("    .unicode_flag       = ").Append(StringUtil.ToHexString(field_5_unicode_flag)).Append("\n");buffer.Append("    .value       = ").Append(Value).Append("\n");buffer.Append("[/LABEL]\n");return buffer.ToString();}
// Original:
public static void verifyLabel(String label) {if (label == null || label.isEmpty()) {throw new IllegalArgumentException("empty or null components not allowed; got: " + label);}}

// Translation:
public static void VerifyLabel(string label){if (string.IsNullOrEmpty(label)){throw new System.ArgumentException("empty or null components not allowed; got: " + label);}}
// Original:
public boolean setReadOnly() {return setWritable(false, false);}

// Translation:
public bool setReadOnly(){return setWritable(false, false);}
// Original:
public CopyImageResult copyImage(CopyImageRequest request) {request = beforeClientExecution(request);return executeCopyImage(request);}

// Translation:
public virtual CopyImageResponse CopyImage(CopyImageRequest request){var options = new InvokeOptions();options.RequestMarshaller = CopyImageRequestMarshaller.Instance;options.ResponseUnmarshaller = CopyImageResponseUnmarshaller.Instance;return Invoke<CopyImageResponse>(request, options);}
// Original:
public CreateTrainingJobResult createTrainingJob(CreateTrainingJobRequest request) {request = beforeClientExecution(request);return executeCreateTrainingJob(request);}

// Translation:
public virtual CreateTrainingJobResponse CreateTrainingJob(CreateTrainingJobRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateTrainingJobRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateTrainingJobResponseUnmarshaller.Instance;return Invoke<CreateTrainingJobResponse>(request, options);}
// Original:
public DescribeDomainsResult describeDomains(DescribeDomainsRequest request) {request = beforeClientExecution(request);return executeDescribeDomains(request);}

// Translation:
public virtual DescribeDomainsResponse DescribeDomains(DescribeDomainsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeDomainsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeDomainsResponseUnmarshaller.Instance;return Invoke<DescribeDomainsResponse>(request, options);}
// Original:
public String toString() {return "ngram(" + n + ")";}

// Translation:
public override string ToString(){return "ngram(" + n + ")";}
// Original:
public boolean formatMatches(ColumnInfoRecord other) {if (_xfIndex != other._xfIndex) {return false;}if (_options != other._options) {return false;}if (_colWidth != other._colWidth) {return false;}return true;}

// Translation:
public bool FormatMatches(ColumnInfoRecord other){if (_xf_index != other._xf_index){return false;}if (_options != other._options){return false;}if (_col_width != other._col_width){return false;}return true;}
// Original:
public AddCommand add() {return new AddCommand(repo);}

// Translation:
public virtual AddCommand Add(){return new AddCommand(repo);}
// Original:
public final int limit() {return limit;}

// Translation:
public int limit(){return _limit;}
// Original:
public CharBuffer asReadOnlyBuffer() {return ReadOnlyCharArrayBuffer.copy(this, mark);}

// Translation:
public override java.nio.CharBuffer asReadOnlyBuffer(){return java.nio.ReadOnlyCharArrayBuffer.copy(this, _mark);}
// Original:
public synchronized boolean add(E object) {if (elementCount == elementData.length) {growByOne();}elementData[elementCount++] = object;modCount++;return true;}

// Translation:
public override bool add(E @object){lock (this){if (elementCount == elementData.Length){growByOne();}elementData[elementCount++] = @object;modCount++;return true;}}
// Original:
public TSTNode getNode(CharSequence key) {return getNode(key, rootNode);}

// Translation:
public virtual TSTNode GetNode(string key){return GetNode(key, rootNode);}
// Original:
public GetEventStreamResult getEventStream(GetEventStreamRequest request) {request = beforeClientExecution(request);return executeGetEventStream(request);}

// Translation:
public virtual GetEventStreamResponse GetEventStream(GetEventStreamRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetEventStreamRequestMarshaller.Instance;options.ResponseUnmarshaller = GetEventStreamResponseUnmarshaller.Instance;return Invoke<GetEventStreamResponse>(request, options);}
// Original:
public SendMessageBatchResult sendMessageBatch(SendMessageBatchRequest request) {request = beforeClientExecution(request);return executeSendMessageBatch(request);}

// Translation:
public virtual SendMessageBatchResponse SendMessageBatch(SendMessageBatchRequest request){var options = new InvokeOptions();options.RequestMarshaller = SendMessageBatchRequestMarshaller.Instance;options.ResponseUnmarshaller = SendMessageBatchResponseUnmarshaller.Instance;return Invoke<SendMessageBatchResponse>(request, options);}
// Original:
public DescribeDirectConnectGatewayAttachmentsResult describeDirectConnectGatewayAttachments(DescribeDirectConnectGatewayAttachmentsRequest request) {request = beforeClientExecution(request);return executeDescribeDirectConnectGatewayAttachments(request);}

// Translation:
public virtual DescribeDirectConnectGatewayAttachmentsResponse DescribeDirectConnectGatewayAttachments(DescribeDirectConnectGatewayAttachmentsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeDirectConnectGatewayAttachmentsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeDirectConnectGatewayAttachmentsResponseUnmarshaller.Instance;return Invoke<DescribeDirectConnectGatewayAttachmentsResponse>(request, options);}
// Original:
public Object add(Object prefix, Object output) {assert !(prefix instanceof List);if (!(output instanceof List)) {return outputs.add((T) prefix, (T) output);} else {List<T> outputList = (List<T>) output;List<T> addedList = new ArrayList<>(outputList.size());for(T _output : outputList) {addedList.add(outputs.add((T) prefix, _output));}return addedList;}}

// Translation:
public override object Add(object prefix, object output){Debug.Assert(!(prefix is IList));if (!(output is IList)){return outputs.Add((T)prefix, (T)output);}else{IList outputList = (IList)output;IList<T> addedList = new JCG.List<T>(outputList.Count);foreach (object _output in outputList){addedList.Add(outputs.Add((T)prefix, (T)_output));}return addedList;}}
// Original:
public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1,ValueEval arg2, ValueEval arg3) {return evaluate(srcRowIndex, srcColumnIndex, arg0, arg1, arg2, arg3, DEFAULT_ARG4);}

// Translation:
public ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1,ValueEval arg2, ValueEval arg3){return Evaluate(srcRowIndex, srcColumnIndex, arg0, arg1, arg2, arg3, DEFAULT_ARG4);}
// Original:
public static List<ParseTree> findAllNodes(ParseTree t, int index, boolean findTokens) {List<ParseTree> nodes = new ArrayList<ParseTree>();_findAllNodes(t, index, findTokens, nodes);return nodes;}

// Translation:
public static IList<IParseTree> FindAllNodes(IParseTree t, int index, bool findTokens){IList<IParseTree> nodes = new List<IParseTree>();_findAllNodes(t, index, findTokens, nodes);return nodes;}
// Original:
public boolean containsChart() {EscherOptRecord optRecord = (EscherOptRecord)_boundAggregate.findFirstWithId(EscherOptRecord.RECORD_ID);if (optRecord == null) {return false;}for (EscherProperty prop : optRecord.getEscherProperties()) {if (prop.getPropertyNumber() == 896 && prop.isComplex()) {EscherComplexProperty cp = (EscherComplexProperty) prop;String str = StringUtil.getFromUnicodeLE(cp.getComplexData());if (str.equals("Chart 1\0")) {return true;}}}return false;}

// Translation:
public bool ContainsChart(){EscherOptRecord optRecord = (EscherOptRecord)_boundAggregate.FindFirstWithId(EscherOptRecord.RECORD_ID);if (optRecord == null){return false;}for (IEnumerator it = optRecord.EscherProperties.GetEnumerator(); it.MoveNext(); ){EscherProperty prop = (EscherProperty)it.Current;if (prop.PropertyNumber == 896 && prop.IsComplex){EscherComplexProperty cp = (EscherComplexProperty)prop;String str = StringUtil.GetFromUnicodeLE(cp.ComplexData);if (str.Equals("Chart 1\0")){return true;}}}return false;}
// Original:
public int getWidth() {return w;}

// Translation:
public virtual int getWidth(){return w;}
// Original:
public StopInstanceResult stopInstance(StopInstanceRequest request) {request = beforeClientExecution(request);return executeStopInstance(request);}

// Translation:
public virtual StopInstanceResponse StopInstance(StopInstanceRequest request){var options = new InvokeOptions();options.RequestMarshaller = StopInstanceRequestMarshaller.Instance;options.ResponseUnmarshaller = StopInstanceResponseUnmarshaller.Instance;return Invoke<StopInstanceResponse>(request, options);}
// Original:
public String toString() {StringBuilder buffer = new StringBuilder();buffer.append("[TABLE]\n");buffer.append("    .range    = ").append(getRange()).append("\n");buffer.append("    .flags    = ") .append(HexDump.byteToHex(field_5_flags)).append("\n");buffer.append("    .alwaysClc= ").append(isAlwaysCalc()).append("\n");buffer.append("    .reserved = ").append(HexDump.intToHex(field_6_res)).append("\n");CellReference crRowInput = cr(field_7_rowInputRow, field_8_colInputRow);CellReference crColInput = cr(field_9_rowInputCol, field_10_colInputCol);buffer.append("    .rowInput = ").append(crRowInput.formatAsString()).append("\n");buffer.append("    .colInput = ").append(crColInput.formatAsString()).append("\n");buffer.append("[/TABLE]\n");return buffer.toString();}

// Translation:
public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append("[TABLE]\n");buffer.Append("    .range    = ").Append(Range.ToString()).Append("\n");buffer.Append("    .flags    = ").Append(HexDump.ByteToHex(field_5_flags)).Append("\n");buffer.Append("    .alwaysClc= ").Append(IsAlwaysCalc).Append("\n");buffer.Append("    .reserved = ").Append(HexDump.IntToHex(field_6_res)).Append("\n");CellReference crRowInput = cr(field_7_rowInputRow, field_8_colInputRow);CellReference crColInput = cr(field_9_rowInputCol, field_10_colInputCol);buffer.Append("    .rowInput = ").Append(crRowInput.FormatAsString()).Append("\n");buffer.Append("    .colInput = ").Append(crColInput.FormatAsString()).Append("\n");buffer.Append("[/TABLE]\n");return buffer.ToString();}
// Original:
public RemoveTagsResult removeTags(RemoveTagsRequest request) {request = beforeClientExecution(request);return executeRemoveTags(request);}

// Translation:
public virtual RemoveTagsResponse RemoveTags(RemoveTagsRequest request){var options = new InvokeOptions();options.RequestMarshaller = RemoveTagsRequestMarshaller.Instance;options.ResponseUnmarshaller = RemoveTagsResponseUnmarshaller.Instance;return Invoke<RemoveTagsResponse>(request, options);}
// Original:
public boolean hasNext() {if (next == null)next = peek();return next != null;}

// Translation:
public override bool HasNext(){if (this.next == null){this.next = this.Peek();}return this.next != null;}
// Original:
public long byteCount(int packedIntsVersion, int valueCount, int bitsPerValue) {return (long) Math.ceil((double) valueCount * bitsPerValue / 8);}

// Translation:
public virtual long ByteCount(int packedIntsVersion, int valueCount, int bitsPerValue){return 8L * Int64Count(packedIntsVersion, valueCount, bitsPerValue);}
// Original:
public GetQueueUrlRequest(String queueName) {setQueueName(queueName);}

// Translation:
public GetQueueUrlRequest(string queueName){_queueName = queueName;}
// Original:
public void addEscherRecord(int index, EscherRecord element){escherRecords.add( index, element );}

// Translation:
public void AddEscherRecord(int index, EscherRecord element){escherRecords.Insert(index, element);}
// Original:
public ListInstanceGroupsResult listInstanceGroups(ListInstanceGroupsRequest request) {request = beforeClientExecution(request);return executeListInstanceGroups(request);}

// Translation:
public virtual ListInstanceGroupsResponse ListInstanceGroups(ListInstanceGroupsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListInstanceGroupsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListInstanceGroupsResponseUnmarshaller.Instance;return Invoke<ListInstanceGroupsResponse>(request, options);}
// Original:
public TruncateTokenFilterFactory(Map<String, String> args) {super(args);prefixLength = Byte.parseByte(get(args, PREFIX_LENGTH_KEY, "5"));if (prefixLength < 1)throw new IllegalArgumentException(PREFIX_LENGTH_KEY + " parameter must be a positive number: " + prefixLength);if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameter(s): " + args);}}

// Translation:
public TruncateTokenFilterFactory(IDictionary<string, string> args): base(args){var prefixLengthString = Get(args, PREFIX_LENGTH_KEY, "5");prefixLength = sbyte.Parse(prefixLengthString, NumberStyles.Integer, CultureInfo.InvariantCulture);if (prefixLength < 1){throw new System.ArgumentException(PREFIX_LENGTH_KEY + " parameter must be a positive number: " + prefixLengthString);}if (args.Count > 0){throw new System.ArgumentException("Unknown parameter(s): " + args);}}
// Original:
public GetDetectorResult getDetector(GetDetectorRequest request) {request = beforeClientExecution(request);return executeGetDetector(request);}

// Translation:
public virtual GetDetectorResponse GetDetector(GetDetectorRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetDetectorRequestMarshaller.Instance;options.ResponseUnmarshaller = GetDetectorResponseUnmarshaller.Instance;return Invoke<GetDetectorResponse>(request, options);}
// Original:
public void set(int index, int n) {if (count < index)throw new ArrayIndexOutOfBoundsException(index);else if (count == index)add(n);elseentries[index] = n;}

// Translation:
public virtual void Set(int index, int n){if (count < index){throw Sharpen.Extensions.CreateIndexOutOfRangeException(index);}else{if (count == index){Add(n);}else{entries[index] = n;}}}
// Original:
public StatePair(int s1, int s2) {this.s1 = s1;this.s2 = s2;this.s = -1;}

// Translation:
public StatePair(State s1, State s2){this.S1 = s1;this.S2 = s2;}
// Original:
public DetachDiskResult detachDisk(DetachDiskRequest request) {request = beforeClientExecution(request);return executeDetachDisk(request);}

// Translation:
public virtual DetachDiskResponse DetachDisk(DetachDiskRequest request){var options = new InvokeOptions();options.RequestMarshaller = DetachDiskRequestMarshaller.Instance;options.ResponseUnmarshaller = DetachDiskResponseUnmarshaller.Instance;return Invoke<DetachDiskResponse>(request, options);}
// Original:
public void clear() {count = 0;}

// Translation:
public virtual void Clear(){count = 0;}
// Original:
public ListIterator<E> listIterator() {return delegate().listIterator(); }

// Translation:
public virtual java.util.ListIterator<E> listIterator(){lock (mutex){return list.listIterator();}}
// Original:
public FieldDoc(int doc, float score, Object[] fields, int shardIndex) {super(doc, score, shardIndex);this.fields = fields;}

// Translation:
public FieldDoc(int doc, float score, object[] fields, int shardIndex): base(doc, score, shardIndex){this.fields = fields;}
// Original:
public ResourceRecord(String value) {setValue(value);}

// Translation:
public ResourceRecord(string value){_value = value;}
// Original:
public String getAuthority() {return decode(authority);}

// Translation:
public string getAuthority(){return decode(authority);}
// Original:
public void flush() throws IOException {drain();output.flush();}

// Translation:
public override void flush(){throw new System.NotImplementedException();}
// Original:
public ListMultipartUploadsRequest(String accountId, String vaultName) {setAccountId(accountId);setVaultName(vaultName);}

// Translation:
public ListMultipartUploadsRequest(string accountId, string vaultName){_accountId = accountId;_vaultName = vaultName;}
// Original:
public UpdateRouteResponseResult updateRouteResponse(UpdateRouteResponseRequest request) {request = beforeClientExecution(request);return executeUpdateRouteResponse(request);}

// Translation:
public virtual UpdateRouteResponseResponse UpdateRouteResponse(UpdateRouteResponseRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateRouteResponseRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateRouteResponseResponseUnmarshaller.Instance;return Invoke<UpdateRouteResponseResponse>(request, options);}
// Original:
public boolean containsKey(Object name) {return get(name) != null;}

// Translation:
public override bool ContainsKey(object name){return Get(name) != null;}
// Original:
public SimpleRateLimiter(double mbPerSec) {setMBPerSec(mbPerSec);lastNS = System.nanoTime();}

// Translation:
public SimpleRateLimiter(double mbPerSec){SetMbPerSec(mbPerSec);}