yijunyu/c-to-rust huggingface dataset:
// Original:
public void serialize(LittleEndianOutput out) {out.writeShort(field_1_row);out.writeShort(field_2_col);out.writeShort(field_3_flags);out.writeShort(field_4_shapeid);out.writeShort(field_6_author.length());out.writeByte(field_5_hasMultibyte ? 0x01 : 0x00);if (field_5_hasMultibyte) {StringUtil.putUnicodeLE(field_6_author, out);} else {StringUtil.putCompressedUnicode(field_6_author, out);}if (field_7_padding != null) {out.writeByte(field_7_padding.intValue());}}

// Translation:
public override void Serialize(ILittleEndianOutput out1){out1.WriteShort(field_1_row);out1.WriteShort(field_2_col);out1.WriteShort(field_3_flags);out1.WriteShort(field_4_shapeid);out1.WriteShort(field_6_author.Length);out1.WriteByte(field_5_hasMultibyte ? 0x01 : 0x00);if (field_5_hasMultibyte) {StringUtil.PutUnicodeLE(field_6_author, out1);} else {StringUtil.PutCompressedUnicode(field_6_author, out1);}if (field_7_padding != null) {out1.WriteByte(Convert.ToInt32(field_7_padding, CultureInfo.InvariantCulture));}}
// Original:
public int lastIndexOf(String string) {return lastIndexOf(string, count);}

// Translation:
public virtual int lastIndexOf(string @string){return lastIndexOf(@string, count);}
// Original:
public boolean add(E object) {return addLastImpl(object);}

// Translation:
public override bool add(E @object){return addLastImpl(@object);}
// Original:
public void unsetSection(String section, String subsection) {ConfigSnapshot src, res;do {src = state.get();res = unsetSection(src, section, subsection);} while (!state.compareAndSet(src, res));}

// Translation:
public virtual void UnsetSection(string section, string subsection){ConfigSnapshot src;ConfigSnapshot res;do{src = state.Get();res = UnsetSection(src, section, subsection);}while (!state.CompareAndSet(src, res));}
// Original:
public final String getTagName() {return tagName;}

// Translation:
public string GetTagName(){return tagName;}
// Original:
public void addSubRecord(int index, SubRecord element) {subrecords.add(index, element);}

// Translation:
public void AddSubRecord(int index, SubRecord element){subrecords.Insert(index, element);}
// Original:
public boolean remove(Object o) {synchronized (mutex) {return delegate().remove(o);}}

// Translation:
public virtual bool remove(object @object){lock (mutex){return c.remove(@object);}}
// Original:
public DoubleMetaphoneFilter create(TokenStream input) {return new DoubleMetaphoneFilter(input, maxCodeLength, inject);}

// Translation:
public override TokenStream Create(TokenStream input){return new DoubleMetaphoneFilter(input, maxCodeLength, inject);}
// Original:
public long length() {return inCoreLength();}

// Translation:
public virtual long Length(){return InCoreLength();}
// Original:
public void setValue(boolean newValue) {value = newValue;}

// Translation:
public virtual void SetValue(bool newValue){value = newValue;}
// Original:
public Pair(ContentSource oldSource, ContentSource newSource) {this.oldSource = oldSource;this.newSource = newSource;}

// Translation:
public Pair(ContentSource oldSource, ContentSource newSource){this.oldSource = oldSource;this.newSource = newSource;}
// Original:
public int get(int i) {if (count <= i)throw new ArrayIndexOutOfBoundsException(i);return entries[i];}

// Translation:
public virtual int Get(int i){if (count <= i){throw Sharpen.Extensions.CreateIndexOutOfRangeException(i);}return entries[i];}
// Original:
public CreateRepoRequest() {super("cr", "2016-06-07", "CreateRepo", "cr");setUriPattern("/repos");setMethod(MethodType.PUT);}

// Translation:
public CreateRepoRequest(): base("cr", "2016-06-07", "CreateRepo", "cr", "openAPI"){UriPattern = "/repos";Method = MethodType.PUT;}
// Original:
public boolean isDeltaBaseAsOffset() {return deltaBaseAsOffset;}

// Translation:
public virtual bool IsDeltaBaseAsOffset(){return deltaBaseAsOffset;}
// Original:
public void remove() {if (expectedModCount == list.modCount) {if (lastLink != null) {Link<ET> next = lastLink.next;Link<ET> previous = lastLink.previous;next.previous = previous;previous.next = next;if (lastLink == link) {pos--;}link = previous;lastLink = null;expectedModCount++;list.size--;list.modCount++;} else {throw new IllegalStateException();}} else {throw new ConcurrentModificationException();}}

// Translation:
public void remove(){if (expectedModCount == list.modCount){if (lastLink != null){java.util.LinkedList.Link<ET> next_1 = lastLink.next;java.util.LinkedList.Link<ET> previous_1 = lastLink.previous;next_1.previous = previous_1;previous_1.next = next_1;if (lastLink == link){pos--;}link = previous_1;lastLink = null;expectedModCount++;list._size--;list.modCount++;}else{throw new System.InvalidOperationException();}}else{throw new java.util.ConcurrentModificationException();}}
// Original:
public MergeShardsResult mergeShards(MergeShardsRequest request) {request = beforeClientExecution(request);return executeMergeShards(request);}

// Translation:
public virtual MergeShardsResponse MergeShards(MergeShardsRequest request){var options = new InvokeOptions();options.RequestMarshaller = MergeShardsRequestMarshaller.Instance;options.ResponseUnmarshaller = MergeShardsResponseUnmarshaller.Instance;return Invoke<MergeShardsResponse>(request, options);}
// Original:
public AllocateHostedConnectionResult allocateHostedConnection(AllocateHostedConnectionRequest request) {request = beforeClientExecution(request);return executeAllocateHostedConnection(request);}

// Translation:
public virtual AllocateHostedConnectionResponse AllocateHostedConnection(AllocateHostedConnectionRequest request){var options = new InvokeOptions();options.RequestMarshaller = AllocateHostedConnectionRequestMarshaller.Instance;options.ResponseUnmarshaller = AllocateHostedConnectionResponseUnmarshaller.Instance;return Invoke<AllocateHostedConnectionResponse>(request, options);}
// Original:
public int getBeginIndex() {return start;}

// Translation:
public int getBeginIndex(){return start;}
// Original:
public static final WeightedTerm[] getTerms(Query query){return getTerms(query,false);}

// Translation:
public static WeightedTerm[] GetTerms(Query query){return GetTerms(query, false);}
// Original:
public ByteBuffer compact() {throw new ReadOnlyBufferException();}

// Translation:
public override java.nio.ByteBuffer compact(){throw new java.nio.ReadOnlyBufferException();}
// Original:
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {for (int i = 0; i < iterations; ++i) {final long byte0 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = byte0 >>> 2;final long byte1 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte0 & 3) << 4) | (byte1 >>> 4);final long byte2 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte1 & 15) << 2) | (byte2 >>> 6);values[valuesOffset++] = byte2 & 63;}}

// Translation:
public override void Decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations){for (int i = 0; i < iterations; ++i){int byte0 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = (int)((uint)byte0 >> 2);int byte1 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte0 & 3) << 4) | ((int)((uint)byte1 >> 4));int byte2 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte1 & 15) << 2) | ((int)((uint)byte2 >> 6));values[valuesOffset++] = byte2 & 63;}}
// Original:
public String getHumanishName() throws IllegalArgumentException {String s = getPath();if ("/".equals(s) || "".equals(s)) s = getHost();if (s == null) throw new IllegalArgumentException();String[] elements;if ("file".equals(scheme) || LOCAL_FILE.matcher(s).matches()) elements = s.split("[\\" + File.separatorChar + "/]"); elseelements = s.split("/+"); if (elements.length == 0)throw new IllegalArgumentException();String result = elements[elements.length - 1];if (Constants.DOT_GIT.equals(result))result = elements[elements.length - 2];else if (result.endsWith(Constants.DOT_GIT_EXT))result = result.substring(0, result.length()- Constants.DOT_GIT_EXT.length());return result;}

// Translation:
public virtual string GetHumanishName(){if (string.Empty.Equals(GetPath()) || GetPath() == null){throw new ArgumentException();}string s = GetPath();string[] elements;if ("file".Equals(scheme) || LOCAL_FILE.Matcher(s).Matches()){elements = s.Split("[\\" + FilePath.separatorChar + "/]");}else{elements = s.Split("/");}if (elements.Length == 0){throw new ArgumentException();}string result = elements[elements.Length - 1];if (Constants.DOT_GIT.Equals(result)){result = elements[elements.Length - 2];}else{if (result.EndsWith(Constants.DOT_GIT_EXT)){result = Sharpen.Runtime.Substring(result, 0, result.Length - Constants.DOT_GIT_EXT.Length);}}return result;}
// Original:
public DescribeNotebookInstanceLifecycleConfigResult describeNotebookInstanceLifecycleConfig(DescribeNotebookInstanceLifecycleConfigRequest request) {request = beforeClientExecution(request);return executeDescribeNotebookInstanceLifecycleConfig(request);}

// Translation:
public virtual DescribeNotebookInstanceLifecycleConfigResponse DescribeNotebookInstanceLifecycleConfig(DescribeNotebookInstanceLifecycleConfigRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeNotebookInstanceLifecycleConfigRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeNotebookInstanceLifecycleConfigResponseUnmarshaller.Instance;return Invoke<DescribeNotebookInstanceLifecycleConfigResponse>(request, options);}
// Original:
public String getAccessKeySecret() {return this.accessKeySecret;}

// Translation:
public string GetAccessKeySecret(){return AccessSecret;}
// Original:
public CreateVpnConnectionResult createVpnConnection(CreateVpnConnectionRequest request) {request = beforeClientExecution(request);return executeCreateVpnConnection(request);}

// Translation:
public virtual CreateVpnConnectionResponse CreateVpnConnection(CreateVpnConnectionRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateVpnConnectionRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateVpnConnectionResponseUnmarshaller.Instance;return Invoke<CreateVpnConnectionResponse>(request, options);}
// Original:
public DescribeVoicesResult describeVoices(DescribeVoicesRequest request) {request = beforeClientExecution(request);return executeDescribeVoices(request);}

// Translation:
public virtual DescribeVoicesResponse DescribeVoices(DescribeVoicesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeVoicesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeVoicesResponseUnmarshaller.Instance;return Invoke<DescribeVoicesResponse>(request, options);}
// Original:
public ListMonitoringExecutionsResult listMonitoringExecutions(ListMonitoringExecutionsRequest request) {request = beforeClientExecution(request);return executeListMonitoringExecutions(request);}

// Translation:
public virtual ListMonitoringExecutionsResponse ListMonitoringExecutions(ListMonitoringExecutionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListMonitoringExecutionsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListMonitoringExecutionsResponseUnmarshaller.Instance;return Invoke<ListMonitoringExecutionsResponse>(request, options);}
// Original:
public DescribeJobRequest(String vaultName, String jobId) {setVaultName(vaultName);setJobId(jobId);}

// Translation:
public DescribeJobRequest(string vaultName, string jobId){_vaultName = vaultName;_jobId = jobId;}
// Original:
public EscherRecord getEscherRecord(int index){return escherRecords.get(index);}

// Translation:
public EscherRecord GetEscherRecord(int index){return escherRecords[index];}
// Original:
public GetApisResult getApis(GetApisRequest request) {request = beforeClientExecution(request);return executeGetApis(request);}

// Translation:
public virtual GetApisResponse GetApis(GetApisRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetApisRequestMarshaller.Instance;options.ResponseUnmarshaller = GetApisResponseUnmarshaller.Instance;return Invoke<GetApisResponse>(request, options);}
// Original:
public DeleteSmsChannelResult deleteSmsChannel(DeleteSmsChannelRequest request) {request = beforeClientExecution(request);return executeDeleteSmsChannel(request);}

// Translation:
public virtual DeleteSmsChannelResponse DeleteSmsChannel(DeleteSmsChannelRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteSmsChannelRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteSmsChannelResponseUnmarshaller.Instance;return Invoke<DeleteSmsChannelResponse>(request, options);}
// Original:
public TrackingRefUpdate getTrackingRefUpdate() {return trackingRefUpdate;}

// Translation:
public virtual TrackingRefUpdate GetTrackingRefUpdate(){return trackingRefUpdate;}
// Original:
public void print(boolean b) {print(String.valueOf(b));}

// Translation:
public virtual void print(bool b){print(b.ToString());}
// Original:
public QueryNode getChild() {return getChildren().get(0);}

// Translation:
public virtual IQueryNode GetChild(){return GetChildren()[0];}
// Original:
public NotIgnoredFilter(int workdirTreeIndex) {this.index = workdirTreeIndex;}

// Translation:
public NotIgnoredFilter(int workdirTreeIndex){this.index = workdirTreeIndex;}
// Original:
public AreaRecord(RecordInputStream in) {field_1_formatFlags            = in.readShort();}

// Translation:
public AreaRecord(RecordInputStream in1){field_1_formatFlags = in1.ReadShort();}
// Original:
public GetThumbnailRequest() {super("CloudPhoto", "2017-07-11", "GetThumbnail", "cloudphoto");setProtocol(ProtocolType.HTTPS);}

// Translation:
public GetThumbnailRequest(): base("CloudPhoto", "2017-07-11", "GetThumbnail", "cloudphoto", "openAPI"){Protocol = ProtocolType.HTTPS;}
// Original:
public DescribeTransitGatewayVpcAttachmentsResult describeTransitGatewayVpcAttachments(DescribeTransitGatewayVpcAttachmentsRequest request) {request = beforeClientExecution(request);return executeDescribeTransitGatewayVpcAttachments(request);}

// Translation:
public virtual DescribeTransitGatewayVpcAttachmentsResponse DescribeTransitGatewayVpcAttachments(DescribeTransitGatewayVpcAttachmentsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeTransitGatewayVpcAttachmentsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeTransitGatewayVpcAttachmentsResponseUnmarshaller.Instance;return Invoke<DescribeTransitGatewayVpcAttachmentsResponse>(request, options);}
// Original:
public PutVoiceConnectorStreamingConfigurationResult putVoiceConnectorStreamingConfiguration(PutVoiceConnectorStreamingConfigurationRequest request) {request = beforeClientExecution(request);return executePutVoiceConnectorStreamingConfiguration(request);}

// Translation:
public virtual PutVoiceConnectorStreamingConfigurationResponse PutVoiceConnectorStreamingConfiguration(PutVoiceConnectorStreamingConfigurationRequest request){var options = new InvokeOptions();options.RequestMarshaller = PutVoiceConnectorStreamingConfigurationRequestMarshaller.Instance;options.ResponseUnmarshaller = PutVoiceConnectorStreamingConfigurationResponseUnmarshaller.Instance;return Invoke<PutVoiceConnectorStreamingConfigurationResponse>(request, options);}
// Original:
public OrdRange getOrdRange(String dim) {return prefixToOrdRange.get(dim);}

// Translation:
public override OrdRange GetOrdRange(string dim){OrdRange result;prefixToOrdRange.TryGetValue(dim, out result);return result;}
// Original:
public String toString() {String symbol = "";if (startIndex >= 0 && startIndex < getInputStream().size()) {symbol = getInputStream().getText(Interval.of(startIndex,startIndex));symbol = Utils.escapeWhitespace(symbol, false);}return String.format(Locale.getDefault(), "%s('%s')", LexerNoViableAltException.class.getSimpleName(), symbol);}

// Translation:
public override string ToString(){string symbol = string.Empty;if (startIndex >= 0 && startIndex < ((ICharStream)InputStream).Size){symbol = ((ICharStream)InputStream).GetText(Interval.Of(startIndex, startIndex));symbol = Utils.EscapeWhitespace(symbol, false);}return string.Format(CultureInfo.CurrentCulture, "{0}('{1}')", typeof(Antlr4.Runtime.LexerNoViableAltException).Name, symbol);}
// Original:
public E peek() {return peekFirstImpl();}

// Translation:
public virtual E peek(){return peekFirstImpl();}
// Original:
public CreateWorkspacesResult createWorkspaces(CreateWorkspacesRequest request) {request = beforeClientExecution(request);return executeCreateWorkspaces(request);}

// Translation:
public virtual CreateWorkspacesResponse CreateWorkspaces(CreateWorkspacesRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateWorkspacesRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateWorkspacesResponseUnmarshaller.Instance;return Invoke<CreateWorkspacesResponse>(request, options);}
// Original:
public NumberFormatIndexRecord clone() {return copy();}

// Translation:
public override Object Clone(){NumberFormatIndexRecord rec = new NumberFormatIndexRecord();rec.field_1_formatIndex = field_1_formatIndex;return rec;}
// Original:
public DescribeRepositoriesResult describeRepositories(DescribeRepositoriesRequest request) {request = beforeClientExecution(request);return executeDescribeRepositories(request);}

// Translation:
public virtual DescribeRepositoriesResponse DescribeRepositories(DescribeRepositoriesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeRepositoriesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeRepositoriesResponseUnmarshaller.Instance;return Invoke<DescribeRepositoriesResponse>(request, options);}
// Original:
public SparseIntArray(int initialCapacity) {initialCapacity = ArrayUtils.idealIntArraySize(initialCapacity);mKeys = new int[initialCapacity];mValues = new int[initialCapacity];mSize = 0;}

// Translation:
public SparseIntArray(int initialCapacity){initialCapacity = android.util.@internal.ArrayUtils.idealIntArraySize(initialCapacity);mKeys = new int[initialCapacity];mValues = new int[initialCapacity];mSize = 0;}
// Original:
public HyphenatedWordsFilter create(TokenStream input) {return new HyphenatedWordsFilter(input);}

// Translation:
public override TokenStream Create(TokenStream input){return new HyphenatedWordsFilter(input);}
// Original:
public CreateDistributionWithTagsResult createDistributionWithTags(CreateDistributionWithTagsRequest request) {request = beforeClientExecution(request);return executeCreateDistributionWithTags(request);}

// Translation:
public virtual CreateDistributionWithTagsResponse CreateDistributionWithTags(CreateDistributionWithTagsRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateDistributionWithTagsRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateDistributionWithTagsResponseUnmarshaller.Instance;return Invoke<CreateDistributionWithTagsResponse>(request, options);}
// Original:
public RandomAccessFile(String fileName, String mode) throws FileNotFoundException {this(new File(fileName), mode);}

// Translation:
public RandomAccessFile(string fileName, string mode) : this(new java.io.File(fileName), mode){throw new System.NotImplementedException();}
// Original:
public DeleteWorkspaceImageResult deleteWorkspaceImage(DeleteWorkspaceImageRequest request) {request = beforeClientExecution(request);return executeDeleteWorkspaceImage(request);}

// Translation:
public virtual DeleteWorkspaceImageResponse DeleteWorkspaceImage(DeleteWorkspaceImageRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteWorkspaceImageRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteWorkspaceImageResponseUnmarshaller.Instance;return Invoke<DeleteWorkspaceImageResponse>(request, options);}
// Original:
public static String toHex(long value) {StringBuilder sb = new StringBuilder(16);writeHex(sb, value, 16, "");return sb.toString();}

// Translation:
public static string ToHex(int value){return ToHex((long)value, 8);}
// Original:
public UpdateDistributionResult updateDistribution(UpdateDistributionRequest request) {request = beforeClientExecution(request);return executeUpdateDistribution(request);}

// Translation:
public virtual UpdateDistributionResponse UpdateDistribution(UpdateDistributionRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateDistributionRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateDistributionResponseUnmarshaller.Instance;return Invoke<UpdateDistributionResponse>(request, options);}
// Original:
public HSSFColor getColor(short index){if (index == HSSFColorPredefined.AUTOMATIC.getIndex()) {return HSSFColorPredefined.AUTOMATIC.getColor();}byte[] b = _palette.getColor(index);return (b == null) ? null : new CustomColor(index, b);}

// Translation:
public HSSFColor GetColor(short index){if (index == HSSFColor.Automatic.Index)return HSSFColor.Automatic.GetInstance();else{byte[] b = palette.GetColor(index);if (b != null){return new CustomColor(index, b);}}return null;}
// Original:
public ValueEval evaluate(ValueEval[] operands, int srcRow, int srcCol) {throw new NotImplementedFunctionException(_functionName);}

// Translation:
public ValueEval Evaluate(ValueEval[] operands, int srcRow, int srcCol){throw new NotImplementedFunctionException(_functionName);}
// Original:
public void serialize(LittleEndianOutput out) {out.writeShort((short)field_1_number_crn_records);out.writeShort((short)field_2_sheet_table_index);}

// Translation:
public override void Serialize(ILittleEndianOutput out1){out1.WriteShort((short)field_1_number_crn_records);out1.WriteShort((short)field_2_sheet_table_index);}
// Original:
public DescribeDBEngineVersionsResult describeDBEngineVersions() {return describeDBEngineVersions(new DescribeDBEngineVersionsRequest());}

// Translation:
public virtual DescribeDBEngineVersionsResponse DescribeDBEngineVersions(){return DescribeDBEngineVersions(new DescribeDBEngineVersionsRequest());}
// Original:
public FormatRun(short character, short fontIndex) {this._character = character;this._fontIndex = fontIndex;}

// Translation:
public FormatRun(short character, short fontIndex){this._character = character;this._fontIndex = fontIndex;}
// Original:
public static byte[] toBigEndianUtf16Bytes(char[] chars, int offset, int length) {byte[] result = new byte[length * 2];int end = offset + length;int resultIndex = 0;for (int i = offset; i < end; ++i) {char ch = chars[i];result[resultIndex++] = (byte) (ch >> 8);result[resultIndex++] = (byte) ch;}return result;}

// Translation:
public static byte[] toBigEndianUtf16Bytes(char[] chars, int offset, int length){byte[] result = new byte[length * 2];int end = offset + length;int resultIndex = 0;{for (int i = offset; i < end; ++i){char ch = chars[i];result[resultIndex++] = unchecked((byte)(ch >> 8));result[resultIndex++] = unchecked((byte)ch);}}return result;}
// Original:
public UploadArchiveResult uploadArchive(UploadArchiveRequest request) {request = beforeClientExecution(request);return executeUploadArchive(request);}

// Translation:
public virtual UploadArchiveResponse UploadArchive(UploadArchiveRequest request){var options = new InvokeOptions();options.RequestMarshaller = UploadArchiveRequestMarshaller.Instance;options.ResponseUnmarshaller = UploadArchiveResponseUnmarshaller.Instance;return Invoke<UploadArchiveResponse>(request, options);}
// Original:
public List<Token> getHiddenTokensToLeft(int tokenIndex) {return getHiddenTokensToLeft(tokenIndex, -1);}

// Translation:
public virtual IList<IToken> GetHiddenTokensToLeft(int tokenIndex){return GetHiddenTokensToLeft(tokenIndex, -1);}