yijunyu/c-to-rust huggingface dataset:
// Original:
public Explanation idfExplain(CollectionStatistics collectionStats, TermStatistics termStats) {final long df = termStats.docFreq();final long docCount = collectionStats.docCount();final float idf = idf(df, docCount);return Explanation.match(idf, "idf(docFreq, docCount)",Explanation.match(df, "docFreq, number of documents containing term"),Explanation.match(docCount, "docCount, total number of documents with field"));}

// Translation:
public virtual Explanation IdfExplain(CollectionStatistics collectionStats, TermStatistics termStats){long df = termStats.DocFreq;long max = collectionStats.MaxDoc;float idf = Idf(df, max);return new Explanation(idf, "idf(docFreq=" + df + ", maxDocs=" + max + ")");}
// Original:
public CreateGroupMembershipResult createGroupMembership(CreateGroupMembershipRequest request) {request = beforeClientExecution(request);return executeCreateGroupMembership(request);}

// Translation:
public virtual CreateGroupMembershipResponse CreateGroupMembership(CreateGroupMembershipRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateGroupMembershipRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateGroupMembershipResponseUnmarshaller.Instance;return Invoke<CreateGroupMembershipResponse>(request, options);}
// Original:
public GrowableWriter(int startBitsPerValue, int valueCount, float acceptableOverheadRatio) {this.acceptableOverheadRatio = acceptableOverheadRatio;current = PackedInts.getMutable(valueCount, startBitsPerValue, this.acceptableOverheadRatio);currentMask = mask(current.getBitsPerValue());}

// Translation:
public GrowableWriter(int startBitsPerValue, int valueCount, float acceptableOverheadRatio){this.acceptableOverheadRatio = acceptableOverheadRatio;current = PackedInt32s.GetMutable(valueCount, startBitsPerValue, this.acceptableOverheadRatio);currentMask = Mask(current.BitsPerValue);}
// Original:
public AddJobFlowStepsResult addJobFlowSteps(AddJobFlowStepsRequest request) {request = beforeClientExecution(request);return executeAddJobFlowSteps(request);}

// Translation:
public virtual AddJobFlowStepsResponse AddJobFlowSteps(AddJobFlowStepsRequest request){var options = new InvokeOptions();options.RequestMarshaller = AddJobFlowStepsRequestMarshaller.Instance;options.ResponseUnmarshaller = AddJobFlowStepsResponseUnmarshaller.Instance;return Invoke<AddJobFlowStepsResponse>(request, options);}
// Original:
public RecalcIdRecord() {_reserved0 = 0;_engineId = 0;}

// Translation:
public RecalcIdRecord(){_reserved0 = 0;_engineId = 0;}
// Original:
public boolean matches() {matchFound = matchesImpl(address, input, matchOffsets);if (matchFound) {findPos = matchOffsets[1];}return matchFound;}

// Translation:
public bool matches(){matchFound = matchesImpl(address, input, matchOffsets);if (matchFound){findPos = matchOffsets[1];}return matchFound;}
// Original:
public FieldMaskingSpanQuery(SpanQuery maskedQuery, String maskedField) {this.maskedQuery = Objects.requireNonNull(maskedQuery);this.field = Objects.requireNonNull(maskedField);}

// Translation:
public FieldMaskingSpanQuery(SpanQuery maskedQuery, string maskedField){this.maskedQuery = maskedQuery;this.field = maskedField;}
// Original:
public void print(float fnum) {print(String.valueOf(fnum));}

// Translation:
public virtual void print(float fnum){print(fnum.ToString());}
// Original:
public int addBSERecord(EscherBSERecord e) {createDrawingGroup();escherBSERecords.add( e );int dgLoc = findFirstRecordLocBySid(DrawingGroupRecord.sid);DrawingGroupRecord drawingGroup = (DrawingGroupRecord) getRecords().get( dgLoc );EscherContainerRecord dggContainer = (EscherContainerRecord) drawingGroup.getEscherRecord( 0 );EscherContainerRecord bstoreContainer;if (dggContainer.getChild( 1 ).getRecordId() == EscherContainerRecord.BSTORE_CONTAINER ){bstoreContainer = (EscherContainerRecord) dggContainer.getChild( 1 );} else {bstoreContainer = new EscherContainerRecord();bstoreContainer.setRecordId( EscherContainerRecord.BSTORE_CONTAINER );List<EscherRecord> childRecords = dggContainer.getChildRecords();childRecords.add(1, bstoreContainer);dggContainer.setChildRecords(childRecords);}bstoreContainer.setOptions( (short) ( (escherBSERecords.size() << 4) | 0xF ) );bstoreContainer.addChildRecord( e );return escherBSERecords.size();}

// Translation:
public int AddBSERecord(EscherBSERecord e){CreateDrawingGroup();escherBSERecords.Add(e);int dgLoc = FindFirstRecordLocBySid(DrawingGroupRecord.sid);DrawingGroupRecord drawingGroup = (DrawingGroupRecord)Records[dgLoc];EscherContainerRecord dggContainer = (EscherContainerRecord)drawingGroup.GetEscherRecord(0);EscherContainerRecord bstoreContainer;if (dggContainer.GetChild(1).RecordId == EscherContainerRecord.BSTORE_CONTAINER){bstoreContainer = (EscherContainerRecord)dggContainer.GetChild(1);}else{bstoreContainer = new EscherContainerRecord();bstoreContainer.RecordId=EscherContainerRecord.BSTORE_CONTAINER;List<EscherRecord> childRecords = dggContainer.ChildRecords;childRecords.Insert(1, bstoreContainer);dggContainer.ChildRecords = (childRecords);}bstoreContainer.Options=(short)((escherBSERecords.Count << 4) | 0xF);bstoreContainer.AddChildRecord(e);return escherBSERecords.Count;}
// Original:
public CreateLoadBalancerListenersRequest(String loadBalancerName, java.util.List<Listener> listeners) {setLoadBalancerName(loadBalancerName);setListeners(listeners);}

// Translation:
public CreateLoadBalancerListenersRequest(string loadBalancerName, List<Listener> listeners){_loadBalancerName = loadBalancerName;_listeners = listeners;}
// Original:
public DeleteDBClusterEndpointResult deleteDBClusterEndpoint(DeleteDBClusterEndpointRequest request) {request = beforeClientExecution(request);return executeDeleteDBClusterEndpoint(request);}

// Translation:
public virtual DeleteDBClusterEndpointResponse DeleteDBClusterEndpoint(DeleteDBClusterEndpointRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteDBClusterEndpointRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteDBClusterEndpointResponseUnmarshaller.Instance;return Invoke<DeleteDBClusterEndpointResponse>(request, options);}
// Original:
public DescribeIngestionResult describeIngestion(DescribeIngestionRequest request) {request = beforeClientExecution(request);return executeDescribeIngestion(request);}

// Translation:
public virtual DescribeIngestionResponse DescribeIngestion(DescribeIngestionRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeIngestionRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeIngestionResponseUnmarshaller.Instance;return Invoke<DescribeIngestionResponse>(request, options);}
// Original:
public PutCompositeAlarmResult putCompositeAlarm(PutCompositeAlarmRequest request) {request = beforeClientExecution(request);return executePutCompositeAlarm(request);}

// Translation:
public virtual PutCompositeAlarmResponse PutCompositeAlarm(PutCompositeAlarmRequest request){var options = new InvokeOptions();options.RequestMarshaller = PutCompositeAlarmRequestMarshaller.Instance;options.ResponseUnmarshaller = PutCompositeAlarmResponseUnmarshaller.Instance;return Invoke<PutCompositeAlarmResponse>(request, options);}
// Original:
public Collection<ParseTree> evaluate(ParseTree t) {List<ParseTree> nodes = new ArrayList<ParseTree>();for (Tree c : Trees.getChildren(t)) {if ( c instanceof ParserRuleContext ) {ParserRuleContext ctx = (ParserRuleContext)c;if ( (ctx.getRuleIndex() == ruleIndex && !invert) ||(ctx.getRuleIndex() != ruleIndex && invert) ){nodes.add(ctx);}}}return nodes;}

// Translation:
public override ICollection<IParseTree> Evaluate(IParseTree t){IList<IParseTree> nodes = new List<IParseTree>();foreach (ITree c in Trees.GetChildren(t)){if (c is ParserRuleContext){ParserRuleContext ctx = (ParserRuleContext)c;if ((ctx.RuleIndex == ruleIndex && !invert) || (ctx.RuleIndex != ruleIndex && invert)){nodes.Add(ctx);}}}return nodes;}
// Original:
public CreateKeyPairResult createKeyPair(CreateKeyPairRequest request) {request = beforeClientExecution(request);return executeCreateKeyPair(request);}

// Translation:
public virtual CreateKeyPairResponse CreateKeyPair(CreateKeyPairRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateKeyPairRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateKeyPairResponseUnmarshaller.Instance;return Invoke<CreateKeyPairResponse>(request, options);}
// Original:
public DiffCommand setOldTree(AbstractTreeIterator oldTree) {this.oldTree = oldTree;return this;}

// Translation:
public virtual NGit.Api.DiffCommand SetOldTree(AbstractTreeIterator oldTree){this.oldTree = oldTree;return this;}
// Original:
public GetDeploymentConfigResult getDeploymentConfig(GetDeploymentConfigRequest request) {request = beforeClientExecution(request);return executeGetDeploymentConfig(request);}

// Translation:
public virtual GetDeploymentConfigResponse GetDeploymentConfig(GetDeploymentConfigRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetDeploymentConfigRequestMarshaller.Instance;options.ResponseUnmarshaller = GetDeploymentConfigResponseUnmarshaller.Instance;return Invoke<GetDeploymentConfigResponse>(request, options);}
// Original:
public static void addNewSheetRecord(List<RecordBase> sheetRecords, RecordBase newRecord) {int index = findSheetInsertPos(sheetRecords, newRecord.getClass());sheetRecords.add(index, newRecord);}

// Translation:
public static void AddNewSheetRecord(List<RecordBase> sheetRecords, RecordBase newRecord){int index = FindSheetInsertPos(sheetRecords, newRecord.GetType());sheetRecords.Insert(index, newRecord);}
// Original:
public final void restoreState(State state) {if (state == null)  return;do {AttributeImpl targetImpl = attributeImpls.get(state.attribute.getClass());if (targetImpl == null) {throw new IllegalArgumentException("State contains AttributeImpl of type " +state.attribute.getClass().getName() + " that is not in in this AttributeSource");}state.attribute.copyTo(targetImpl);state = state.next;} while (state != null);}

// Translation:
public void RestoreState(State state){if (state == null){return;}do{if (!attributeImpls.ContainsKey(state.attribute.GetType())){throw new ArgumentException("State contains Attribute of type " + state.attribute.GetType().Name + " that is not in in this AttributeSource");}state.attribute.CopyTo(attributeImpls[state.attribute.GetType()]);state = state.next;} while (state != null);}
// Original:
public SendVoiceMessageResult sendVoiceMessage(SendVoiceMessageRequest request) {request = beforeClientExecution(request);return executeSendVoiceMessage(request);}

// Translation:
public virtual SendVoiceMessageResponse SendVoiceMessage(SendVoiceMessageRequest request){var options = new InvokeOptions();options.RequestMarshaller = SendVoiceMessageRequestMarshaller.Instance;options.ResponseUnmarshaller = SendVoiceMessageResponseUnmarshaller.Instance;return Invoke<SendVoiceMessageResponse>(request, options);}
// Original:
public DescribeLoadBalancersResult describeLoadBalancers() {return describeLoadBalancers(new DescribeLoadBalancersRequest());}

// Translation:
public virtual DescribeLoadBalancersResponse DescribeLoadBalancers(){return DescribeLoadBalancers(new DescribeLoadBalancersRequest());}
// Original:
public DisassociateTransitGatewayRouteTableResult disassociateTransitGatewayRouteTable(DisassociateTransitGatewayRouteTableRequest request) {request = beforeClientExecution(request);return executeDisassociateTransitGatewayRouteTable(request);}

// Translation:
public virtual DisassociateTransitGatewayRouteTableResponse DisassociateTransitGatewayRouteTable(DisassociateTransitGatewayRouteTableRequest request){var options = new InvokeOptions();options.RequestMarshaller = DisassociateTransitGatewayRouteTableRequestMarshaller.Instance;options.ResponseUnmarshaller = DisassociateTransitGatewayRouteTableResponseUnmarshaller.Instance;return Invoke<DisassociateTransitGatewayRouteTableResponse>(request, options);}
// Original:
public String segString(Directory dir) {StringBuilder b = new StringBuilder();b.append("MergeSpec:\n");final int count = merges.size();for(int i=0;i<count;i++) {b.append("  ").append(1 + i).append(": ").append(merges.get(i).segString());}return b.toString();}

// Translation:
public virtual string SegString(Directory dir){StringBuilder b = new StringBuilder();b.Append("MergeSpec:\n");int count = Merges.Count;for (int i = 0; i < count; i++){b.Append("  ").Append(1 + i).Append(": ").Append(Merges[i].SegString(dir));}return b.ToString();}
// Original:
public DetachNetworkInterfaceResult detachNetworkInterface(DetachNetworkInterfaceRequest request) {request = beforeClientExecution(request);return executeDetachNetworkInterface(request);}

// Translation:
public virtual DetachNetworkInterfaceResponse DetachNetworkInterface(DetachNetworkInterfaceRequest request){var options = new InvokeOptions();options.RequestMarshaller = DetachNetworkInterfaceRequestMarshaller.Instance;options.ResponseUnmarshaller = DetachNetworkInterfaceResponseUnmarshaller.Instance;return Invoke<DetachNetworkInterfaceResponse>(request, options);}
// Original:
public ObjectInserter newObjectInserter() {return getObjectDatabase().newInserter();}

// Translation:
public virtual ObjectInserter NewObjectInserter(){return ObjectDatabase.NewInserter();}
// Original:
public Class<? extends Record> getRecordClass() {return _c.getDeclaringClass();}

// Translation:
public Type GetRecordClass(){return _c.DeclaringType;}
// Original:
public StringBufferInputStream(String str) {if (str == null) {throw new NullPointerException();}buffer = str;count = str.length();}

// Translation:
public StringBufferInputStream(string str){if (str == null){throw new System.ArgumentNullException();}buffer = str;count = str.Length;}
// Original:
public DeletedRef3DPtg(LittleEndianInput in)  {field_1_index_extern_sheet = in.readUShort();unused1 = in.readInt();}

// Translation:
public DeletedRef3DPtg(ILittleEndianInput in1){field_1_index_extern_sheet = in1.ReadUShort();unused1 = in1.ReadInt();}
// Original:
public CellRangeAddress get(int index) {checkIndex(index);return _mergedRegions.get(index);}

// Translation:
public CellRangeAddress Get(int index){CheckIndex(index);return (CellRangeAddress)_mergedRegions[index];}
// Original:
public boolean removePushRefSpec(RefSpec s) {return push.remove(s);}

// Translation:
public virtual bool RemovePushRefSpec(RefSpec s){return push.Remove(s);}
// Original:
public CreateJobResult createJob(CreateJobRequest request) {request = beforeClientExecution(request);return executeCreateJob(request);}

// Translation:
public virtual CreateJobResponse CreateJob(CreateJobRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateJobRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateJobResponseUnmarshaller.Instance;return Invoke<CreateJobResponse>(request, options);}
// Original:
public CreateResourceResult createResource(CreateResourceRequest request) {request = beforeClientExecution(request);return executeCreateResource(request);}

// Translation:
public virtual CreateResourceResponse CreateResource(CreateResourceRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateResourceRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateResourceResponseUnmarshaller.Instance;return Invoke<CreateResourceResponse>(request, options);}
// Original:
public String log() {return " (TERM = " + TERM + ")" +" (CT = " + CT +")" +" (RV = " + RV +")" +" (R1 = " + R1 +")" +" (R2 = " + R2 +")" ;}

// Translation:
public virtual string Log(){return " (TERM = " + TERM + ")" + " (CT = " + CT + ")" + " (RV = " + RV + ")" + " (R1 = " + R1 + ")" + " (R2 = " + R2 + ")";}
// Original:
public VerifyDomainIdentityResult verifyDomainIdentity(VerifyDomainIdentityRequest request) {request = beforeClientExecution(request);return executeVerifyDomainIdentity(request);}

// Translation:
public virtual VerifyDomainIdentityResponse VerifyDomainIdentity(VerifyDomainIdentityRequest request){var options = new InvokeOptions();options.RequestMarshaller = VerifyDomainIdentityRequestMarshaller.Instance;options.ResponseUnmarshaller = VerifyDomainIdentityResponseUnmarshaller.Instance;return Invoke<VerifyDomainIdentityResponse>(request, options);}
// Original:
public void remove(int index) {checkIndex(index);_mergedRegions.remove(index);}

// Translation:
public void Remove(int index){CheckIndex(index);_mergedRegions.RemoveAt(index);}
// Original:
public static org.apache.poi.hssf.record.Record [] createRecord(RecordInputStream in) {Record record = createSingleRecord(in);if (record instanceof DBCellRecord) {return new Record[] { null, };}if (record instanceof RKRecord) {return new Record[] { convertToNumberRecord((RKRecord) record), };}if (record instanceof MulRKRecord) {return convertRKRecords((MulRKRecord)record);}return new Record[] { record, };}

// Translation:
public static Record[] CreateRecord(RecordInputStream in1){Record record = CreateSingleRecord(in1);if (record is DBCellRecord){return new Record[] { null, };}if (record is RKRecord){return new Record[] { ConvertToNumberRecord((RKRecord)record), };}if (record is MulRKRecord){return ConvertRKRecords((MulRKRecord)record);}return new Record[] { record, };}
// Original:
public DeleteIpGroupResult deleteIpGroup(DeleteIpGroupRequest request) {request = beforeClientExecution(request);return executeDeleteIpGroup(request);}

// Translation:
public virtual DeleteIpGroupResponse DeleteIpGroup(DeleteIpGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteIpGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteIpGroupResponseUnmarshaller.Instance;return Invoke<DeleteIpGroupResponse>(request, options);}
// Original:
public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0) {double d;try {ValueEval ve = OperandResolver.getSingleValue(arg0, srcRowIndex, srcColumnIndex);d = OperandResolver.coerceValueToDouble(ve);} catch (EvaluationException e) {return e.getErrorEval();}if (d == 0.0) { return NumberEval.ZERO;}return new NumberEval(-d);}

// Translation:
public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0){double d;try{ValueEval ve = OperandResolver.GetSingleValue(arg0, srcRowIndex, srcColumnIndex);d = OperandResolver.CoerceValueToDouble(ve);}catch (EvaluationException e){return e.GetErrorEval();}if (d == 0.0){ return NumberEval.ZERO;}return new NumberEval(-d);}
// Original:
public String toString() {return "action_"+ruleIndex+":"+actionIndex;}

// Translation:
public override string ToString(){return "action_" + ruleIndex + ":" + actionIndex;}
// Original:
public StopFleetResult stopFleet(StopFleetRequest request) {request = beforeClientExecution(request);return executeStopFleet(request);}

// Translation:
public virtual StopFleetResponse StopFleet(StopFleetRequest request){var options = new InvokeOptions();options.RequestMarshaller = StopFleetRequestMarshaller.Instance;options.ResponseUnmarshaller = StopFleetResponseUnmarshaller.Instance;return Invoke<StopFleetResponse>(request, options);}
// Original:
public String toString() {return("TermStats: term=" + termtext.utf8ToString() + " docFreq=" + docFreq + " totalTermFreq=" + totalTermFreq);}

// Translation:
public override string ToString(){return ("TermStats: Term=" + termtext.Utf8ToString() + " DocFreq=" + DocFreq + " TotalTermFreq=" + TotalTermFreq);}
// Original:
final public Token getNextToken() {if (token.next != null) token = token.next;else token = token.next = token_source.getNextToken();jj_ntk = -1;jj_gen++;return token;}

// Translation:
public Token GetNextToken(){if (Token.Next != null) Token = Token.Next;else Token = Token.Next = TokenSource.GetNextToken();jj_ntk = -1;jj_gen++;return Token;}
// Original:
public GetLabelDetectionResult getLabelDetection(GetLabelDetectionRequest request) {request = beforeClientExecution(request);return executeGetLabelDetection(request);}

// Translation:
public virtual GetLabelDetectionResponse GetLabelDetection(GetLabelDetectionRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetLabelDetectionRequestMarshaller.Instance;options.ResponseUnmarshaller = GetLabelDetectionResponseUnmarshaller.Instance;return Invoke<GetLabelDetectionResponse>(request, options);}
// Original:
public synchronized IndexCommit getIndexCommit(long gen) {return indexCommits.get(gen);}

// Translation:
public virtual IndexCommit GetIndexCommit(long gen){lock (this){return m_indexCommits[gen];}}
// Original:
public ListMetricsResult listMetrics(ListMetricsRequest request) {request = beforeClientExecution(request);return executeListMetrics(request);}

// Translation:
public virtual ListMetricsResponse ListMetrics(ListMetricsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListMetricsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListMetricsResponseUnmarshaller.Instance;return Invoke<ListMetricsResponse>(request, options);}
// Original:
public void delete() {throw new UnsupportedOperationException("This IndexCommit does not support deletions");}

// Translation:
public override void Delete(){throw new NotSupportedException("this IndexCommit does not support deletions");}
// Original:
public ByteBuffer putChar(int index, char value) {checkIndex(index, SizeOf.CHAR);Memory.pokeShort(backingArray, offset + index, (short) value, order);return this;}

// Translation:
public override java.nio.ByteBuffer putChar(int index, char value){checkIndex(index, libcore.io.SizeOf.CHAR);libcore.io.Memory.pokeShort(backingArray, offset + index, (short)value, _order);return this;}
// Original:
public CreateBasePathMappingResult createBasePathMapping(CreateBasePathMappingRequest request) {request = beforeClientExecution(request);return executeCreateBasePathMapping(request);}

// Translation:
public virtual CreateBasePathMappingResponse CreateBasePathMapping(CreateBasePathMappingRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateBasePathMappingRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateBasePathMappingResponseUnmarshaller.Instance;return Invoke<CreateBasePathMappingResponse>(request, options);}
// Original:
public synchronized StringBuffer insert(int index, CharSequence s) {insert0(index, s == null ? "null" : s.toString());return this;}

// Translation:
public java.lang.StringBuffer insert(int index, char[] chars){lock (this){insert0(index, chars);return this;}}
// Original:
public DescribeDBInstancesResult describeDBInstances(DescribeDBInstancesRequest request) {request = beforeClientExecution(request);return executeDescribeDBInstances(request);}

// Translation:
public virtual DescribeDBInstancesResponse DescribeDBInstances(DescribeDBInstancesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeDBInstancesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeDBInstancesResponseUnmarshaller.Instance;return Invoke<DescribeDBInstancesResponse>(request, options);}
// Original:
public ValueEval evaluate(ValueEval[] args, int srcRowIndex, int srcColumnIndex) {switch (args.length) {case 2:return evaluate(srcRowIndex, srcColumnIndex, args[0], args[1]);case 3:return evaluate(srcRowIndex, srcColumnIndex, args[0], args[1], args[2]);case 4:return evaluate(srcRowIndex, srcColumnIndex, args[0], args[1], args[2], args[3]);}return ErrorEval.VALUE_INVALID;}

// Translation:
public ValueEval Evaluate(ValueEval[] args, int srcRowIndex, int srcColumnIndex){switch (args.Length){case 2:return Evaluate(srcRowIndex, srcColumnIndex, args[0], args[1]);case 3:return Evaluate(srcRowIndex, srcColumnIndex, args[0], args[1], args[2]);case 4:return Evaluate(srcRowIndex, srcColumnIndex, args[0], args[1], args[2], args[3]);}return ErrorEval.VALUE_INVALID;}
// Original:
@Override public boolean add(E object) {throw new UnsupportedOperationException();}

// Translation:
public virtual bool add(E @object){throw new System.NotSupportedException();}
// Original:
public Collection<TrackingRefUpdate> getTrackingRefUpdates() {return Collections.unmodifiableCollection(updates.values());}

// Translation:
public virtual ICollection<TrackingRefUpdate> GetTrackingRefUpdates(){return Sharpen.Collections.UnmodifiableCollection(updates.Values);}