yijunyu/c-to-rust huggingface dataset:
// Original:
public HindiNormalizationFilterFactory(Map<String,String> args) {super(args);if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

// Translation:
public HindiNormalizationFilterFactory(IDictionary<string, string> args): base(args){if (args.Count > 0){throw new System.ArgumentException("Unknown parameters: " + args);}}
// Original:
public UpdateUserIdentityInfoResult updateUserIdentityInfo(UpdateUserIdentityInfoRequest request) {request = beforeClientExecution(request);return executeUpdateUserIdentityInfo(request);}

// Translation:
public virtual UpdateUserIdentityInfoResponse UpdateUserIdentityInfo(UpdateUserIdentityInfoRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateUserIdentityInfoRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateUserIdentityInfoResponseUnmarshaller.Instance;return Invoke<UpdateUserIdentityInfoResponse>(request, options);}
// Original:
public Allocator(int blockSize) {this.blockSize = blockSize;}

// Translation:
public Allocator(int blockSize){this.m_blockSize = blockSize;}
// Original:
public NoteMapMerger(Repository db, NoteMerger noteMerger,MergeStrategy nonNotesMergeStrategy) {this.db = db;this.reader = db.newObjectReader();this.inserter = db.newObjectInserter();this.noteMerger = noteMerger;this.nonNotesMergeStrategy = nonNotesMergeStrategy;this.objectIdPrefix = new MutableObjectId();}

// Translation:
public NoteMapMerger(Repository db, NoteMerger noteMerger, MergeStrategy nonNotesMergeStrategy){this.db = db;this.reader = db.NewObjectReader();this.inserter = db.NewObjectInserter();this.noteMerger = noteMerger;this.nonNotesMergeStrategy = nonNotesMergeStrategy;this.objectIdPrefix = new MutableObjectId();}
// Original:
public ListAliasesResult listAliases(ListAliasesRequest request) {request = beforeClientExecution(request);return executeListAliases(request);}

// Translation:
public virtual ListAliasesResponse ListAliases(ListAliasesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListAliasesRequestMarshaller.Instance;options.ResponseUnmarshaller = ListAliasesResponseUnmarshaller.Instance;return Invoke<ListAliasesResponse>(request, options);}
// Original:
public STSAssumeRoleSessionCredentialsProvider withRoleSessionName(String roleSessionName) {this.roleSessionName = roleSessionName;return this;}

// Translation:
public void WithRoleSessionName(string roleSessionName){this.roleSessionName = roleSessionName;}
// Original:
public IntList(int capacity) {entries = new int[capacity];}

// Translation:
public IntList(int capacity){entries = new int[capacity];}
// Original:
public Result getResult() {return result;}

// Translation:
public virtual ReceiveCommand.Result GetResult(){return status;}
// Original:
public int size() {return count;}

// Translation:
public virtual int Size(){return count;}
// Original:
public DescribeAccountAttributesResult describeAccountAttributes() {return describeAccountAttributes(new DescribeAccountAttributesRequest());}

// Translation:
public virtual DescribeAccountAttributesResponse DescribeAccountAttributes(){return DescribeAccountAttributes(new DescribeAccountAttributesRequest());}
// Original:
public String toString() {return "G";}

// Translation:
public override string ToString(){return "G";}
// Original:
public StoredField(String name, double value) {super(name, TYPE);fieldsData = value;}

// Translation:
public StoredField(string name, long value): base(name, TYPE){FieldsData = new Int64(value);}
// Original:
public GroupedFacetResult(int size, int minCount, boolean orderByCount, int totalCount, int totalMissingCount) {this.facetEntries = new TreeSet<>(orderByCount ? orderByCountAndValue : orderByValue);this.totalMissingCount = totalMissingCount;this.totalCount = totalCount;maxSize = size;currentMin = minCount;}

// Translation:
public GroupedFacetResult(int size, int minCount, bool orderByCount, int totalCount, int totalMissingCount){this.facetEntries = new JCG.SortedSet<FacetEntry>(orderByCount ? orderByCountAndValue : orderByValue);this.totalMissingCount = totalMissingCount;this.totalCount = totalCount;maxSize = size;currentMin = minCount;}
// Original:
public FieldInfo fieldInfo(String fieldName) {return byName.get(fieldName);}

// Translation:
public virtual FieldInfo FieldInfo(string fieldName){FieldInfo ret;byName.TryGetValue(fieldName, out ret);return ret;}
// Original:
public int regionStart() {return regionStart;}

// Translation:
public int regionStart(){return _regionStart;}
// Original:
public int getPort() {return Host.this.getPort();}

// Translation:
public virtual int GetPort(){return port;}
// Original:
public InterruptTimer(String threadName) {state = new AlarmState();autoKiller = new AutoKiller(state);thread = new AlarmThread(threadName, state);thread.start();}

// Translation:
public InterruptTimer(string threadName){state = new InterruptTimer.AlarmState();autoKiller = new InterruptTimer.AutoKiller(state);thread = new InterruptTimer.AlarmThread(threadName, state);thread.Start();}
// Original:
public HighFrequencyDictionary(IndexReader reader, String field, float thresh) {this.reader = reader;this.field = field;this.thresh = thresh;}

// Translation:
public HighFrequencyDictionary(IndexReader reader, string field, float thresh){this.reader = reader;this.field = field;this.thresh = thresh;}
// Original:
public ModifyDBProxyTargetGroupResult modifyDBProxyTargetGroup(ModifyDBProxyTargetGroupRequest request) {request = beforeClientExecution(request);return executeModifyDBProxyTargetGroup(request);}

// Translation:
public virtual ModifyDBProxyTargetGroupResponse ModifyDBProxyTargetGroup(ModifyDBProxyTargetGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = ModifyDBProxyTargetGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = ModifyDBProxyTargetGroupResponseUnmarshaller.Instance;return Invoke<ModifyDBProxyTargetGroupResponse>(request, options);}
// Original:
public void close() throws IOException {input.close();}

// Translation:
public override void close(){throw new System.NotImplementedException();}
// Original:
public void reset() {arriving = -1;leaving = -1;}

// Translation:
public void Reset(){arriving = null;leaving = null;}
// Original:
public SetLoadBalancerListenerSSLCertificateRequest(String loadBalancerName, Integer loadBalancerPort, String sSLCertificateId) {setLoadBalancerName(loadBalancerName);setLoadBalancerPort(loadBalancerPort);setSSLCertificateId(sSLCertificateId);}

// Translation:
public SetLoadBalancerListenerSSLCertificateRequest(string loadBalancerName, int loadBalancerPort, string sslCertificateId){_loadBalancerName = loadBalancerName;_loadBalancerPort = loadBalancerPort;_sslCertificateId = sslCertificateId;}
// Original:
public SpanTermQuery(Term term) {this.term = Objects.requireNonNull(term);this.termStates = null;}

// Translation:
public SpanTermQuery(Term term){this.m_term = term;}
// Original:
public long ramBytesUsed() {long ramBytesUsed = postingsReader.ramBytesUsed();for (TermsReader r : fields.values()) {ramBytesUsed += r.ramBytesUsed();}return ramBytesUsed;}

// Translation:
public override long RamBytesUsed(){long sizeInByes = ((postingsReader != null) ? postingsReader.RamBytesUsed() : 0);foreach (FieldReader reader in fields.Values){sizeInByes += reader.RamBytesUsed();}return sizeInByes;}
// Original:
public boolean equals(Object o) {if (this.getClass() != o.getClass()) return false;DocFreqValueSource other = (DocFreqValueSource)o;return this.indexedField.equals(other.indexedField) && this.indexedBytes.equals(other.indexedBytes);}

// Translation:
public override bool Equals(object o){if (this.GetType() != o.GetType()){return false;}var other = (DocFreqValueSource)o;return this.m_indexedField.Equals(other.m_indexedField, StringComparison.Ordinal) && this.m_indexedBytes.Equals(other.m_indexedBytes);}
// Original:
public Term getLucenePrefixTerm(String fieldName) {return new Term(fieldName, getPrefix());}

// Translation:
public virtual Term GetLucenePrefixTerm(string fieldName){return new Term(fieldName, Prefix);}
// Original:
public Collection<ParseTree> evaluate(ParseTree t) {return Trees.findAllTokenNodes(t, tokenType);}

// Translation:
public override ICollection<IParseTree> Evaluate(IParseTree t){return Trees.FindAllTokenNodes(t, tokenType);}
// Original:
public static Signer getSigner(AlibabaCloudCredentials credentials) {if (credentials instanceof KeyPairCredentials) {return SHA256_WITH_RSA_SIGNER;} else if (credentials instanceof BearerTokenCredentials) {return BEARER_TOKEN_SIGNER;} else {return HMACSHA1_SIGNER;}}

// Translation:
public static Signer GetSigner(AlibabaCloudCredentials credentials){if (credentials is BearerTokenCredential){return bearerTokenSigner;}return credentials is KeyPairCredentials ? sha256withRSASigner : hmacSHA1Signer;}
// Original:
public PutAccountSendingAttributesResult putAccountSendingAttributes(PutAccountSendingAttributesRequest request) {request = beforeClientExecution(request);return executePutAccountSendingAttributes(request);}

// Translation:
public virtual PutAccountSendingAttributesResponse PutAccountSendingAttributes(PutAccountSendingAttributesRequest request){var options = new InvokeOptions();options.RequestMarshaller = PutAccountSendingAttributesRequestMarshaller.Instance;options.ResponseUnmarshaller = PutAccountSendingAttributesResponseUnmarshaller.Instance;return Invoke<PutAccountSendingAttributesResponse>(request, options);}
// Original:
public static String getExtension(String filename) {final int idx = filename.indexOf('.');if (idx == -1) {return null;} else {return filename.substring(idx + 1, filename.length());}}

// Translation:
public static string GetExtension(string filename){int idx = filename.IndexOf('.');if (idx == -1){return null;}else{return filename.Substring(idx + 1, filename.Length - (idx + 1));}}
// Original:
public RunJobFlowResult runJobFlow(RunJobFlowRequest request) {request = beforeClientExecution(request);return executeRunJobFlow(request);}

// Translation:
public virtual RunJobFlowResponse RunJobFlow(RunJobFlowRequest request){var options = new InvokeOptions();options.RequestMarshaller = RunJobFlowRequestMarshaller.Instance;options.ResponseUnmarshaller = RunJobFlowResponseUnmarshaller.Instance;return Invoke<RunJobFlowResponse>(request, options);}
// Original:
public int lastLength() {return lastLength;}

// Translation:
public virtual int LastLength(){return lastLength;}
// Original:
public ListStreamConsumersResult listStreamConsumers(ListStreamConsumersRequest request) {request = beforeClientExecution(request);return executeListStreamConsumers(request);}

// Translation:
public virtual ListStreamConsumersResponse ListStreamConsumers(ListStreamConsumersRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListStreamConsumersRequestMarshaller.Instance;options.ResponseUnmarshaller = ListStreamConsumersResponseUnmarshaller.Instance;return Invoke<ListStreamConsumersResponse>(request, options);}
// Original:
public static SimpleFraction buildFractionMaxDenominator(double value, int maxDenominator){return buildFractionMaxDenominator(value, 0, maxDenominator, 100);}

// Translation:
public static SimpleFraction BuildFractionMaxDenominator(double value, int maxDenominator){return BuildFractionMaxDenominator(value, 0, maxDenominator, 100);}
// Original:
public void seekExact(BytesRef term, TermState state) {throw new IllegalStateException("this method should never be called");}

// Translation:
public virtual void SeekExact(BytesRef term, TermState state){if (!SeekExact(term)){throw new System.ArgumentException("term=" + term + " does not exist");}}
// Original:
public LsRemoteCommand setUploadPack(String uploadPack) {this.uploadPack = uploadPack;return this;}

// Translation:
public virtual NGit.Api.LsRemoteCommand SetUploadPack(string uploadPack){this.uploadPack = uploadPack;return this;}
// Original:
public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval numberVE) {final String hex;if (numberVE instanceof RefEval) {RefEval re = (RefEval) numberVE;hex = OperandResolver.coerceValueToString(re.getInnerValueEval(re.getFirstSheetIndex()));} else {hex = OperandResolver.coerceValueToString(numberVE);}try {return new NumberEval(BaseNumberUtils.convertToDecimal(hex, HEXADECIMAL_BASE, MAX_NUMBER_OF_PLACES));}  catch (IllegalArgumentException e) {return ErrorEval.NUM_ERROR;}}

// Translation:
public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval numberVE){String hex;if (numberVE is RefEval){RefEval re = (RefEval)numberVE;hex = OperandResolver.CoerceValueToString(re.GetInnerValueEval(re.FirstSheetIndex));}else{hex = OperandResolver.CoerceValueToString(numberVE);}try{return new NumberEval(BaseNumberUtils.ConvertToDecimal(hex, HEXADECIMAL_BASE, MAX_NUMBER_OF_PLACES));}catch (ArgumentException){return ErrorEval.NUM_ERROR;}}
// Original:
public DescribeInstancesResult describeInstances() {return describeInstances(new DescribeInstancesRequest());}

// Translation:
public virtual DescribeInstancesResponse DescribeInstances(){return DescribeInstances(new DescribeInstancesRequest());}
// Original:
public Collection<RevCommit> call() throws GitAPIException,InvalidRefNameException {checkCallable();try {if (repo.exactRef(Constants.R_STASH) == null)return Collections.emptyList();} catch (IOException e) {throw new InvalidRefNameException(MessageFormat.format(JGitText.get().cannotRead, Constants.R_STASH), e);}final ReflogCommand refLog = new ReflogCommand(repo);refLog.setRef(Constants.R_STASH);final Collection<ReflogEntry> stashEntries = refLog.call();if (stashEntries.isEmpty())return Collections.emptyList();final List<RevCommit> stashCommits = new ArrayList<>(stashEntries.size());try (RevWalk walk = new RevWalk(repo)) {for (ReflogEntry entry : stashEntries) {try {stashCommits.add(walk.parseCommit(entry.getNewId()));} catch (IOException e) {throw new JGitInternalException(MessageFormat.format(JGitText.get().cannotReadCommit, entry.getNewId()),e);}}}return stashCommits;}

// Translation:
public override ICollection<RevCommit> Call(){CheckCallable();try{if (repo.GetRef(Constants.R_STASH) == null){return Sharpen.Collections.EmptyList<RevCommit>();}}catch (IOException e){throw new InvalidRefNameException(MessageFormat.Format(JGitText.Get().cannotRead,Constants.R_STASH), e);}ReflogCommand refLog = new ReflogCommand(repo);refLog.SetRef(Constants.R_STASH);ICollection<ReflogEntry> stashEntries = refLog.Call();if (stashEntries.IsEmpty()){return Sharpen.Collections.EmptyList<RevCommit>();}IList<RevCommit> stashCommits = new AList<RevCommit>(stashEntries.Count);RevWalk walk = new RevWalk(repo);walk.SetRetainBody(true);try{foreach (ReflogEntry entry in stashEntries){try{stashCommits.AddItem(walk.ParseCommit(entry.GetNewId()));}catch (IOException e){throw new JGitInternalException(MessageFormat.Format(JGitText.Get().cannotReadCommit, entry.GetNewId()), e);}}}finally{walk.Dispose();}return stashCommits;}
// Original:
public void write(LittleEndianOutput out) {out.writeByte(sid + getPtgClass());out.writeByte(field_1_error_code);}

// Translation:
public override void Write(ILittleEndianOutput out1){out1.WriteByte(sid + PtgClass);out1.WriteByte((byte)field_1_error_code);}
// Original:
public PutAccountSettingResult putAccountSetting(PutAccountSettingRequest request) {request = beforeClientExecution(request);return executePutAccountSetting(request);}

// Translation:
public virtual PutAccountSettingResponse PutAccountSetting(PutAccountSettingRequest request){var options = new InvokeOptions();options.RequestMarshaller = PutAccountSettingRequestMarshaller.Instance;options.ResponseUnmarshaller = PutAccountSettingResponseUnmarshaller.Instance;return Invoke<PutAccountSettingResponse>(request, options);}
// Original:
public static CharacterBuffer newCharacterBuffer(final int bufferSize) {if (bufferSize < 2) {throw new IllegalArgumentException("buffersize must be >= 2");}return new CharacterBuffer(new char[bufferSize], 0, 0);}

// Translation:
public static CharacterBuffer NewCharacterBuffer(int bufferSize){if (bufferSize < 2){throw new ArgumentException("buffersize must be >= 2");}return new CharacterBuffer(new char[bufferSize], 0, 0);}
// Original:
public int getLevelForDistance(double dist) {if (dist == 0)return maxLevels;for (int i = 0; i < maxLevels-1; i++) {if(dist > levelW[i] && dist > levelH[i]) {return i+1;}}return maxLevels;}

// Translation:
public override int GetLevelForDistance(double dist){if (dist == 0){return m_maxLevels;}int level = GeohashUtils.LookupHashLenForWidthHeight(dist, dist);return Math.Max(Math.Min(level, m_maxLevels), 1);}
// Original:
public Query makeLuceneQueryFieldNoBoost(String fieldName, BasicQueryFactory qf) {return makeLuceneQueryNoBoost(qf); }

// Translation:
public override Search.Query MakeLuceneQueryFieldNoBoost(string fieldName, BasicQueryFactory qf){return MakeLuceneQueryNoBoost(qf); }
// Original:
public ListDedicatedIpPoolsResult listDedicatedIpPools(ListDedicatedIpPoolsRequest request) {request = beforeClientExecution(request);return executeListDedicatedIpPools(request);}

// Translation:
public virtual ListDedicatedIpPoolsResponse ListDedicatedIpPools(ListDedicatedIpPoolsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListDedicatedIpPoolsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListDedicatedIpPoolsResponseUnmarshaller.Instance;return Invoke<ListDedicatedIpPoolsResponse>(request, options);}
// Original:
public static ValueVector createVector(RefEval re) {return new SheetVector(re);}

// Translation:
public static ValueVector CreateVector(RefEval re){return new SheetVector(re);}
// Original:
public RemoveNoteCommand setObjectId(RevObject id) {checkCallable();this.id = id;return this;}

// Translation:
public virtual NGit.Api.RemoveNoteCommand SetObjectId(RevObject id){CheckCallable();this.id = id;return this;}
// Original:
public int getSheetIndex(String sheetName) {return _uBook.getSheetIndex(sheetName);}

// Translation:
public int GetSheetIndex(String sheetName){return _uBook.GetSheetIndex(sheetName);}
// Original:
public void serialize(LittleEndianOutput out) {out.writeShort(field_1_chartGroupIndex);}

// Translation:
public override void Serialize(ILittleEndianOutput out1){out1.WriteShort(field_1_chartGroupIndex);}
// Original:
public FontFormatting() {setFontHeight(-1);setItalic(false);setFontWieghtModified(false);setOutline(false);setShadow(false);setStrikeout(false);setEscapementType((short)0);setUnderlineType((byte)0);setFontColorIndex((short)-1);setFontStyleModified(false);setFontOutlineModified(false);setFontShadowModified(false);setFontCancellationModified(false);setEscapementTypeModified(false);setUnderlineTypeModified(false);setShort(OFFSET_FONT_NAME, 0);setInt(OFFSET_NOT_USED1, 0x00000001);setInt(OFFSET_NOT_USED2, 0x00000000);setInt(OFFSET_NOT_USED3, 0x7FFFFFFF);setShort(OFFSET_FONT_FORMATING_END, 0x0001);}

// Translation:
public FontFormatting():this(new byte[RAW_DATA_SIZE]){FontHeight=-1;IsItalic=false;IsFontWeightModified=false;IsOutlineOn=false;IsShadowOn=false;IsStruckout=false;EscapementType=(FontSuperScript)0;UnderlineType=(FontUnderlineType)0;FontColorIndex=(short)-1;IsFontStyleModified=false;IsFontOutlineModified=false;IsFontShadowModified=false;IsFontCancellationModified=false;IsEscapementTypeModified=false;IsUnderlineTypeModified=false;SetShort(OFFSET_FONT_NAME, 0);SetInt(OFFSET_NOT_USED1, 0x00000001);SetInt(OFFSET_NOT_USED2, 0x00000000);SetInt(OFFSET_NOT_USED3, 0x7FFFFFFF);SetShort(OFFSET_FONT_FORMATING_END, 0x0001);}
// Original:
public GetFacetResult getFacet(GetFacetRequest request) {request = beforeClientExecution(request);return executeGetFacet(request);}

// Translation:
public virtual GetFacetResponse GetFacet(GetFacetRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetFacetRequestMarshaller.Instance;options.ResponseUnmarshaller = GetFacetResponseUnmarshaller.Instance;return Invoke<GetFacetResponse>(request, options);}
// Original:
public IndexInput clone() {return (IndexInput) super.clone();}

// Translation:
public override object Clone(){return (IndexInput)base.Clone();}
// Original:
public String toFormulaString(){throw new RuntimeException("Table and Arrays are not yet supported");}

// Translation:
public override String ToFormulaString(){throw new RecordFormatException("Table and Arrays are not yet supported");}
// Original:
public StartFleetResult startFleet(StartFleetRequest request) {request = beforeClientExecution(request);return executeStartFleet(request);}

// Translation:
public virtual StartFleetResponse StartFleet(StartFleetRequest request){var options = new InvokeOptions();options.RequestMarshaller = StartFleetRequestMarshaller.Instance;options.ResponseUnmarshaller = StartFleetResponseUnmarshaller.Instance;return Invoke<StartFleetResponse>(request, options);}
// Original:
public static FontFamily valueOf(int nativeId) {for (FontFamily ff : values()) {if (ff.nativeId == nativeId) {return ff;}}return null;}

// Translation:
public static FontFamily ValueOf(int family){switch(family){case 0: return NOT_APPLICABLE;case 1: return ROMAN;case 2: return SWISS;case 3: return MODERN;case 4: return SCRIPT;case 5: return DECORATIVE;}return NOT_APPLICABLE;}
// Original:
public synchronized boolean isEmpty() {return size == 0;}

// Translation:
public override bool isEmpty(){lock (this){return _size == 0;}}
// Original:
public static String encodeBytes(byte[] source) {return encodeBytes(source, 0, source.length);}

// Translation:
public static string EncodeBytes(byte[] source){return EncodeBytes(source, 0, source.Length);}
// Original:
public DescribeBackupsResult describeBackups(DescribeBackupsRequest request) {request = beforeClientExecution(request);return executeDescribeBackups(request);}

// Translation:
public virtual DescribeBackupsResponse DescribeBackups(DescribeBackupsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeBackupsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeBackupsResponseUnmarshaller.Instance;return Invoke<DescribeBackupsResponse>(request, options);}
// Original:
public ReflectionMethodRecordCreator(Method m) {_m = m;}

// Translation:
public ReflectionMethodRecordCreator(MethodInfo m){_m = m;}
// Original:
public static int resolvesToJustOneViableAlt(Collection<BitSet> altsets) {return getSingleViableAlt(altsets);}

// Translation:
public static int ResolvesToJustOneViableAlt(IEnumerable<BitSet> altsets){return GetSingleViableAlt(altsets);}
// Original:
public GetGatewayResult getGateway(GetGatewayRequest request) {request = beforeClientExecution(request);return executeGetGateway(request);}

// Translation:
public virtual GetGatewayResponse GetGateway(GetGatewayRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetGatewayRequestMarshaller.Instance;options.ResponseUnmarshaller = GetGatewayResponseUnmarshaller.Instance;return Invoke<GetGatewayResponse>(request, options);}
// Original:
public void onFilterComplete(int count) {updateDropDownForFilter(count);}

// Translation:
public virtual void onFilterComplete(int count){updateDropDownForFilter(count);}
// Original:
public boolean isReadOnly() {return true;}

// Translation:
public override bool isReadOnly(){return true;}
// Original:
public FreeRefFunction findUserDefinedFunction(String functionName) {return _bookEvaluator.findUserDefinedFunction(functionName);}

// Translation:
public FreeRefFunction FindUserDefinedFunction(String functionName){return _bookEvaluator.FindUserDefinedFunction(functionName);}
// Original:
public boolean equals(Object obj) {if (!(obj instanceof PrecedencePredicate)) {return false;}if (this == obj) {return true;}PrecedencePredicate other = (PrecedencePredicate)obj;return this.precedence == other.precedence;}

// Translation:
public override bool Equals(object obj){if (!(obj is SemanticContext.PrecedencePredicate)){return false;}if (this == obj){return true;}SemanticContext.PrecedencePredicate other = (SemanticContext.PrecedencePredicate)obj;return this.precedence == other.precedence;}