yijunyu/c-to-rust huggingface dataset:
// Original:
public void write(char[] buf, int offset, int count) {doWrite(buf, offset, count);}

// Translation:
public override void write(char[] buf, int offset, int count){doWrite(buf, offset, count);}
// Original:
public String formatAsString() {if(isWholeColumnReference()) {returnCellReference.convertNumToColString(_firstCell.getCol())+ ":" +CellReference.convertNumToColString(_lastCell.getCol());}StringBuilder sb = new StringBuilder(32);sb.append(_firstCell.formatAsString());if(!_isSingleCell) {sb.append(CELL_DELIMITER);if(_lastCell.getSheetName() == null) {sb.append(_lastCell.formatAsString());} else {_lastCell.appendCellReference(sb);}}return sb.toString();}

// Translation:
public String FormatAsString(){if (IsWholeColumnReference()){returnCellReference.ConvertNumToColString(_firstCell.Col)+ ":" +CellReference.ConvertNumToColString(_lastCell.Col);}StringBuilder sb = new StringBuilder(32);sb.Append(_firstCell.FormatAsString());if (!_isSingleCell){sb.Append(CELL_DELIMITER);if (_lastCell.SheetName == null){sb.Append(_lastCell.FormatAsString());}else{_lastCell.AppendCellReference(sb);}}return sb.ToString();}
// Original:
public Graphics create(){return new EscherGraphics(escherGroup, workbook,foreground, font, verticalPointsPerPixel );}

// Translation:
public EscherGraphics Create(){EscherGraphics g = new EscherGraphics(escherGroup, workbook,foreground, font, verticalPointsPerPixel);return g;}
// Original:
public DoubleDocValues(ValueSource vs) {this.vs = vs;}

// Translation:
public DoubleDocValues(ValueSource vs){this.m_vs = vs;}
// Original:
public static CharArraySet getDefaultStopSet(){return DefaultSetHolder.DEFAULT_STOP_SET;}

// Translation:
public static CharArraySet GetDefaultStopSet(){return DefaultSetHolder.DEFAULT_STOP_SET;}
// Original:
public DeleteLoadBalancerPolicyResult deleteLoadBalancerPolicy(DeleteLoadBalancerPolicyRequest request) {request = beforeClientExecution(request);return executeDeleteLoadBalancerPolicy(request);}

// Translation:
public virtual DeleteLoadBalancerPolicyResponse DeleteLoadBalancerPolicy(DeleteLoadBalancerPolicyRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteLoadBalancerPolicyRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteLoadBalancerPolicyResponseUnmarshaller.Instance;return Invoke<DeleteLoadBalancerPolicyResponse>(request, options);}
// Original:
public ReplicationGroup decreaseReplicaCount(DecreaseReplicaCountRequest request) {request = beforeClientExecution(request);return executeDecreaseReplicaCount(request);}

// Translation:
public virtual DecreaseReplicaCountResponse DecreaseReplicaCount(DecreaseReplicaCountRequest request){var options = new InvokeOptions();options.RequestMarshaller = DecreaseReplicaCountRequestMarshaller.Instance;options.ResponseUnmarshaller = DecreaseReplicaCountResponseUnmarshaller.Instance;return Invoke<DecreaseReplicaCountResponse>(request, options);}
// Original:
public Result update(RevWalk walk) throws IOException {requireCanDoUpdate();try {return result = updateImpl(walk, new Store() {@OverrideResult execute(Result status) throws IOException {if (status == Result.NO_CHANGE)return status;return doUpdate(status);}});} catch (IOException x) {result = Result.IO_FAILURE;throw x;}}

// Translation:
public virtual RefUpdate.Result Update(RevWalk walk){RequireCanDoUpdate();try{return result = UpdateImpl(walk, new _Store_484(this));}catch (IOException x){result = RefUpdate.Result.IO_FAILURE;throw;}}
// Original:
public Set<String> getChanged() {return Collections.unmodifiableSet(diff.getChanged());}

// Translation:
public virtual ICollection<string> GetChanged(){return Sharpen.Collections.UnmodifiableSet(diff.GetChanged());}
// Original:
public static String toHex(long value) {StringBuilder sb = new StringBuilder(16);writeHex(sb, value, 16, "");return sb.toString();}

// Translation:
public static string ToHex(long value){return ToHex(value, 16);}
// Original:
public int createPlaceholder() {return _offset++;}

// Translation:
public int CreatePlaceholder(){return _offset++;}
// Original:
@Override public boolean equals(Object o) {if (o instanceof Map.Entry) {Map.Entry other = (Map.Entry) o;return (key == null ? other.getKey() == null : key.equals(other.getKey()))&& (value == null ? other.getValue() == null : value.equals(other.getValue()));}return false;}

// Translation:
public override bool Equals(object o){if (o is java.util.MapClass.Entry<K, V>){java.util.MapClass.Entry<K, V> other = (java.util.MapClass.Entry<K, V>)o;return ((object)key == null ? other.getKey() == null : key.Equals(other.getKey())) && ((object)value == null ? other.getValue() == null : value.Equals(other.getValue()));}return false;}
// Original:
public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0,ValueEval arg1) {double result;try {double d0 = NumericFunction.singleOperandEvaluate(arg0, srcRowIndex, srcColumnIndex);double d1 = NumericFunction.singleOperandEvaluate(arg1, srcRowIndex, srcColumnIndex);double logE = Math.log(d0);if (Double.compare(d1, Math.E) == 0) {result = logE;} else {result = logE / Math.log(d1);}NumericFunction.checkValue(result);} catch (EvaluationException e) {return e.getErrorEval();}return new NumberEval(result);}

// Translation:
public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0,ValueEval arg1) {double result;try {double d0 = NumericFunction.SingleOperandEvaluate(arg0, srcRowIndex, srcColumnIndex);double d1 = NumericFunction.SingleOperandEvaluate(arg1, srcRowIndex, srcColumnIndex);double logE = Math.Log(d0);double base1 = d1;if (base1 == Math.E) {result = logE;} else {result = logE / Math.Log(base1);}NumericFunction.CheckValue(result);} catch (EvaluationException e) {return e.GetErrorEval();}return new NumberEval(result);}
// Original:
public DeleteFilterResult deleteFilter(DeleteFilterRequest request) {request = beforeClientExecution(request);return executeDeleteFilter(request);}

// Translation:
public virtual DeleteFilterResponse DeleteFilter(DeleteFilterRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteFilterRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteFilterResponseUnmarshaller.Instance;return Invoke<DeleteFilterResponse>(request, options);}
// Original:
public CreateInstanceSnapshotResult createInstanceSnapshot(CreateInstanceSnapshotRequest request) {request = beforeClientExecution(request);return executeCreateInstanceSnapshot(request);}

// Translation:
public virtual CreateInstanceSnapshotResponse CreateInstanceSnapshot(CreateInstanceSnapshotRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateInstanceSnapshotRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateInstanceSnapshotResponseUnmarshaller.Instance;return Invoke<CreateInstanceSnapshotResponse>(request, options);}
// Original:
public List<Token> getTokens(int start, int stop) {return getTokens(start, stop, null);}

// Translation:
public virtual IList<IToken> GetTokens(int start, int stop){return GetTokens(start, stop, null);}
// Original:
public static TermGroupFacetCollector createTermGroupFacetCollector(String groupField,String facetField,boolean facetFieldMultivalued,BytesRef facetPrefix,int initialSize) {if (facetFieldMultivalued) {return new MV(groupField, facetField, facetPrefix, initialSize);} else {return new SV(groupField, facetField, facetPrefix, initialSize);}}

// Translation:
public static TermGroupFacetCollector CreateTermGroupFacetCollector(string groupField,string facetField,bool facetFieldMultivalued,BytesRef facetPrefix,int initialSize){if (facetFieldMultivalued){return new MV(groupField, facetField, facetPrefix, initialSize);}else{return new SV(groupField, facetField, facetPrefix, initialSize);}}
// Original:
public RenameAlbumRequest() {super("CloudPhoto", "2017-07-11", "RenameAlbum", "cloudphoto");setProtocol(ProtocolType.HTTPS);}

// Translation:
public RenameAlbumRequest(): base("CloudPhoto", "2017-07-11", "RenameAlbum", "cloudphoto", "openAPI"){Protocol = ProtocolType.HTTPS;}
// Original:
@Override public boolean contains(Object object) {synchronized (mutex) {return c.contains(object);}}

// Translation:
public virtual bool contains(object @object){lock (mutex){return c.contains(@object);}}
// Original:
public CharBuffer put(char[] src, int srcOffset, int charCount) {if (charCount > remaining()) {throw new BufferOverflowException();}System.arraycopy(src, srcOffset, backingArray, offset + position, charCount);position += charCount;return this;}

// Translation:
public override java.nio.CharBuffer put(char[] src, int srcOffset, int charCount){if (charCount > remaining()){throw new java.nio.BufferOverflowException();}System.Array.Copy(src, srcOffset, backingArray, offset + _position, charCount);_position += charCount;return this;}
// Original:
public LegendRecord(RecordInputStream in) {field_1_xAxisUpperLeft = in.readInt();field_2_yAxisUpperLeft = in.readInt();field_3_xSize          = in.readInt();field_4_ySize          = in.readInt();field_5_type           = in.readByte();field_6_spacing        = in.readByte();field_7_options        = in.readShort();}

// Translation:
public LegendRecord(RecordInputStream in1){field_1_xAxisUpperLeft = in1.ReadInt();field_2_yAxisUpperLeft = in1.ReadInt();field_3_xSize = in1.ReadInt();field_4_ySize = in1.ReadInt();field_5_type = (byte)in1.ReadByte();field_6_spacing = (byte)in1.ReadByte();field_7_options = in1.ReadShort();}
// Original:
public static byte[] encodedTypeString(int typeCode) {switch (typeCode) {case OBJ_COMMIT:return ENCODED_TYPE_COMMIT;case OBJ_TREE:return ENCODED_TYPE_TREE;case OBJ_BLOB:return ENCODED_TYPE_BLOB;case OBJ_TAG:return ENCODED_TYPE_TAG;default:throw new IllegalArgumentException(MessageFormat.format(JGitText.get().badObjectType, Integer.valueOf(typeCode)));}}

// Translation:
public static byte[] EncodedTypeString(int typeCode){switch (typeCode){case OBJ_COMMIT:{return ENCODED_TYPE_COMMIT;}case OBJ_TREE:{return ENCODED_TYPE_TREE;}case OBJ_BLOB:{return ENCODED_TYPE_BLOB;}case OBJ_TAG:{return ENCODED_TYPE_TAG;}default:{throw new ArgumentException(MessageFormat.Format(JGitText.Get().badObjectType, Sharpen.Extensions.ValueOf(typeCode)));}}}
// Original:
public ObjectId getCalulatedPatchId() {return ObjectId.fromRaw(digest.digest());}

// Translation:
public virtual ObjectId GetCalulatedPatchId(){return ObjectId.FromRaw(digest.Digest());}
// Original:
public DefaultRowHeightRecord() {field_1_option_flags = 0x0000;field_2_row_height = DEFAULT_ROW_HEIGHT;}

// Translation:
public DefaultRowHeightRecord(){field_1_option_flags = 0x0000;field_2_row_height = DEFAULT_ROW_HEIGHT;}
// Original:
public final ByteBuffer encode(CharBuffer buffer) {try {return newEncoder().onMalformedInput(CodingErrorAction.REPLACE).onUnmappableCharacter(CodingErrorAction.REPLACE).encode(buffer);} catch (CharacterCodingException ex) {throw new Error(ex.getMessage(), ex);}}

// Translation:
public java.nio.ByteBuffer encode(java.nio.CharBuffer buffer){try{return newEncoder().onMalformedInput(java.nio.charset.CodingErrorAction.REPLACE).onUnmappableCharacter(java.nio.charset.CodingErrorAction.REPLACE).encode(buffer);}catch (java.nio.charset.CharacterCodingException ex){throw new System.Exception(ex.Message, ex);}}
// Original:
public final FloatBuffer get(float[] dst, int dstOffset, int floatCount) {if (floatCount > remaining()) {throw new BufferUnderflowException();}System.arraycopy(backingArray, offset + position, dst, dstOffset, floatCount);position += floatCount;return this;}

// Translation:
public sealed override java.nio.FloatBuffer get(float[] dst, int dstOffset, int floatCount){if (floatCount > remaining()){throw new java.nio.BufferUnderflowException();}System.Array.Copy(backingArray, offset + _position, dst, dstOffset, floatCount);_position += floatCount;return this;}
// Original:
public boolean hasNext() {return nextEntry != null;}

// Translation:
public virtual bool hasNext(){return this._nextEntry != null;}
// Original:
public DeleteNatGatewayResult deleteNatGateway(DeleteNatGatewayRequest request) {request = beforeClientExecution(request);return executeDeleteNatGateway(request);}

// Translation:
public virtual DeleteNatGatewayResponse DeleteNatGateway(DeleteNatGatewayRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteNatGatewayRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteNatGatewayResponseUnmarshaller.Instance;return Invoke<DeleteNatGatewayResponse>(request, options);}
// Original:
public String resolveNameXText(int refIndex, int definedNameIndex) {return linkTable.resolveNameXText(refIndex, definedNameIndex, this);}

// Translation:
public String ResolveNameXText(int reFindex, int definedNameIndex){return linkTable.ResolveNameXText(reFindex, definedNameIndex, this);}
// Original:
public void setMultiFields(CharSequence[] fields) {if (fields == null) {fields = new CharSequence[0];}getQueryConfigHandler().set(ConfigurationKeys.MULTI_FIELDS, fields);}

// Translation:
public virtual void SetMultiFields(string[] fields){if (fields == null){fields = new string[0];}QueryConfigHandler.Set(ConfigurationKeys.MULTI_FIELDS, fields);}
// Original:
public boolean isCancelled() {lock.lock();try {return pm.isCancelled();} finally {lock.unlock();}}

// Translation:
public override bool IsCancelled(){Lock.Lock();try{return pm.IsCancelled();}finally{Lock.Unlock();}}
// Original:
public RemoveTargetsResult removeTargets(RemoveTargetsRequest request) {request = beforeClientExecution(request);return executeRemoveTargets(request);}

// Translation:
public virtual RemoveTargetsResponse RemoveTargets(RemoveTargetsRequest request){var options = new InvokeOptions();options.RequestMarshaller = RemoveTargetsRequestMarshaller.Instance;options.ResponseUnmarshaller = RemoveTargetsResponseUnmarshaller.Instance;return Invoke<RemoveTargetsResponse>(request, options);}
// Original:
public FuzzyQuery(Term term, int maxEdits, int prefixLength, int maxExpansions, boolean transpositions) {super(term.field());if (maxEdits < 0 || maxEdits > LevenshteinAutomata.MAXIMUM_SUPPORTED_DISTANCE) {throw new IllegalArgumentException("maxEdits must be between 0 and " + LevenshteinAutomata.MAXIMUM_SUPPORTED_DISTANCE);}if (prefixLength < 0) {throw new IllegalArgumentException("prefixLength cannot be negative.");}if (maxExpansions <= 0) {throw new IllegalArgumentException("maxExpansions must be positive.");}this.term = term;this.maxEdits = maxEdits;this.prefixLength = prefixLength;this.transpositions = transpositions;this.maxExpansions = maxExpansions;int[] codePoints = FuzzyTermsEnum.stringToUTF32(term.text());this.termLength = codePoints.length;this.automata = FuzzyTermsEnum.buildAutomata(term.text(), codePoints, prefixLength, transpositions, maxEdits);setRewriteMethod(new MultiTermQuery.TopTermsBlendedFreqScoringRewrite(maxExpansions));this.ramBytesUsed = calculateRamBytesUsed(term, this.automata);}

// Translation:
public FuzzyQuery(Term term, int maxEdits, int prefixLength, int maxExpansions, bool transpositions): base(term.Field){if (maxEdits < 0 || maxEdits > LevenshteinAutomata.MAXIMUM_SUPPORTED_DISTANCE){throw new System.ArgumentException("maxEdits must be between 0 and " + LevenshteinAutomata.MAXIMUM_SUPPORTED_DISTANCE);}if (prefixLength < 0){throw new System.ArgumentException("prefixLength cannot be negative.");}if (maxExpansions < 0){throw new System.ArgumentException("maxExpansions cannot be negative.");}this.term = term;this.maxEdits = maxEdits;this.prefixLength = prefixLength;this.transpositions = transpositions;this.maxExpansions = maxExpansions;MultiTermRewriteMethod = new MultiTermQuery.TopTermsScoringBooleanQueryRewrite(maxExpansions);}
// Original:
public CheckoutCommand checkout() {return new CheckoutCommand(repo);}

// Translation:
public virtual CheckoutCommand Checkout(){return new CheckoutCommand(repo);}
// Original:
public ValueEval evaluate(String sheetName, int rowIndex, int columnIndex) {EvaluationCell cell = _sewb.getEvaluationCell(sheetName, rowIndex, columnIndex);switch (cell.getCellType()) {case BOOLEAN:return BoolEval.valueOf(cell.getBooleanCellValue());case ERROR:return ErrorEval.valueOf(cell.getErrorCellValue());case FORMULA:return _evaluator.evaluate(cell);case NUMERIC:return new NumberEval(cell.getNumericCellValue());case STRING:return new StringEval(cell.getStringCellValue());case BLANK:return null;default:throw new IllegalStateException("Bad cell type (" + cell.getCellType() + ")");}}

// Translation:
public ValueEval Evaluate(String sheetName, int rowIndex, int columnIndex){IEvaluationCell cell = _sewb.GetEvaluationCell(sheetName, rowIndex, columnIndex);switch (cell.CellType){case CellType.Boolean:return BoolEval.ValueOf(cell.BooleanCellValue);case CellType.Error:return ErrorEval.ValueOf(cell.ErrorCellValue);case CellType.Formula:return _evaluator.Evaluate(cell);case CellType.Numeric:return new NumberEval(cell.NumericCellValue);case CellType.String:return new StringEval(cell.StringCellValue);case CellType.Blank:return null;}throw new InvalidOperationException("Bad cell type (" + cell.CellType + ")");}
// Original:
public PutFileSystemPolicyResult putFileSystemPolicy(PutFileSystemPolicyRequest request) {request = beforeClientExecution(request);return executePutFileSystemPolicy(request);}

// Translation:
public virtual PutFileSystemPolicyResponse PutFileSystemPolicy(PutFileSystemPolicyRequest request){var options = new InvokeOptions();options.RequestMarshaller = PutFileSystemPolicyRequestMarshaller.Instance;options.ResponseUnmarshaller = PutFileSystemPolicyResponseUnmarshaller.Instance;return Invoke<PutFileSystemPolicyResponse>(request, options);}
// Original:
public long fileLength(String name) throws IOException {ensureOpen();FileEntry e = entries.get(IndexFileNames.stripSegmentName(name));if (e == null)throw new FileNotFoundException(name);return e.length;}

// Translation:
public override long FileLength(string name){EnsureOpen();if (this.writer != null){return writer.FileLength(name);}FileEntry e = entries[IndexFileNames.StripSegmentName(name)];if (e == null){throw new FileNotFoundException(name);}return e.Length;}
// Original:
public DescribeCacheClustersResult describeCacheClusters() {return describeCacheClusters(new DescribeCacheClustersRequest());}

// Translation:
public virtual DescribeCacheClustersResponse DescribeCacheClusters(){return DescribeCacheClusters(new DescribeCacheClustersRequest());}
// Original:
public void setObjectId(RevObject obj) {setObjectId(obj, obj.getType());}

// Translation:
public virtual void SetObjectId(RevObject obj){SetObjectId(obj, obj.Type);}
// Original:
public boolean rowHasCells(int row) {if (row >= records.length) {return false;}CellValueRecordInterface[] rowCells=records[row];if(rowCells==null) return false;for(int col=0;col<rowCells.length;col++) {if(rowCells[col]!=null) return true;}return false;}

// Translation:
public bool RowHasCells(int row){if (row > records.Length - 1) return false;  CellValueRecordInterface[] rowCells = records[row]; if (rowCells == null) return false;for (int col = 0; col < rowCells.Length; col++){if (rowCells[col] != null) return true;}return false;}
// Original:
public TokenStream create(TokenStream input) {return new SpanishLightStemFilter(input);}

// Translation:
public override TokenStream Create(TokenStream input){return new SpanishLightStemFilter(input);}
// Original:
public StoredField(String name, double value) {super(name, TYPE);fieldsData = value;}

// Translation:
public StoredField(string name, int value): base(name, TYPE){FieldsData = new Int32(value);}
// Original:
public DescribePublicIpv4PoolsResult describePublicIpv4Pools(DescribePublicIpv4PoolsRequest request) {request = beforeClientExecution(request);return executeDescribePublicIpv4Pools(request);}

// Translation:
public virtual DescribePublicIpv4PoolsResponse DescribePublicIpv4Pools(DescribePublicIpv4PoolsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribePublicIpv4PoolsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribePublicIpv4PoolsResponseUnmarshaller.Instance;return Invoke<DescribePublicIpv4PoolsResponse>(request, options);}
// Original:
public IndexRevision(IndexWriter writer) throws IOException {IndexDeletionPolicy delPolicy = writer.getConfig().getIndexDeletionPolicy();if (!(delPolicy instanceof SnapshotDeletionPolicy)) {throw new IllegalArgumentException("IndexWriter must be created with SnapshotDeletionPolicy");}this.writer = writer;this.sdp = (SnapshotDeletionPolicy) delPolicy;this.commit = sdp.snapshot();this.version = revisionVersion(commit);this.sourceFiles = revisionFiles(commit);}

// Translation:
public IndexRevision(IndexWriter writer){sdp = writer.Config.IndexDeletionPolicy as SnapshotDeletionPolicy;if (sdp == null)throw new ArgumentException("IndexWriter must be created with SnapshotDeletionPolicy", "writer");this.writer = writer;this.commit = sdp.Snapshot();this.version = RevisionVersion(commit);this.sourceFiles = RevisionFiles(commit);}
// Original:
public void setTabIdArray(short[] array) {_tabids = array.clone();}

// Translation:
public void SetTabIdArray(short[] array){_tabids = array;}
// Original:
public UpdateObjectAttributesResult updateObjectAttributes(UpdateObjectAttributesRequest request) {request = beforeClientExecution(request);return executeUpdateObjectAttributes(request);}

// Translation:
public virtual UpdateObjectAttributesResponse UpdateObjectAttributes(UpdateObjectAttributesRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateObjectAttributesRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateObjectAttributesResponseUnmarshaller.Instance;return Invoke<UpdateObjectAttributesResponse>(request, options);}
// Original:
public GetGameSessionLogUrlResult getGameSessionLogUrl(GetGameSessionLogUrlRequest request) {request = beforeClientExecution(request);return executeGetGameSessionLogUrl(request);}

// Translation:
public virtual GetGameSessionLogUrlResponse GetGameSessionLogUrl(GetGameSessionLogUrlRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetGameSessionLogUrlRequestMarshaller.Instance;options.ResponseUnmarshaller = GetGameSessionLogUrlResponseUnmarshaller.Instance;return Invoke<GetGameSessionLogUrlResponse>(request, options);}
// Original:
public RefCount(T object) {this.object = object;}

// Translation:
public RefCount(T @object){this.m_object = @object;}
// Original:
public ByteBuffer put(int index, byte b) {checkIndex(index);backingArray[offset + index] = b;return this;}

// Translation:
public override java.nio.ByteBuffer put(int index, byte b){checkIndex(index);backingArray[offset + index] = b;return this;}
// Original:
public IntervalSet LOOK(ATNState s, ATNState stopState, RuleContext ctx) {IntervalSet r = new IntervalSet();boolean seeThruPreds = true; PredictionContext lookContext = ctx != null ? PredictionContext.fromRuleContext(s.atn, ctx) : null;_LOOK(s, stopState, lookContext,r, new HashSet<ATNConfig>(), new BitSet(), seeThruPreds, true);return r;}

// Translation:
public virtual IntervalSet Look(ATNState s, ATNState stopState, RuleContext ctx){IntervalSet r = new IntervalSet();bool seeThruPreds = true;PredictionContext lookContext = ctx != null ? PredictionContext.FromRuleContext(s.atn, ctx) : null;Look(s, stopState, lookContext, r, new HashSet<ATNConfig>(), new BitSet(), seeThruPreds, true);return r;}
// Original:
public int getValidationType() {return _validationType;}

// Translation:
public int GetValidationType(){return _validationType;}
// Original:
public DeleteTagCommand tagDelete() {return new DeleteTagCommand(repo);}

// Translation:
public virtual DeleteTagCommand TagDelete(){return new DeleteTagCommand(repo);}
// Original:
public SortRescorer(Sort sort) {this.sort = sort;}

// Translation:
public SortRescorer(Sort sort){this.sort = sort;}