yijunyu/c-to-rust huggingface dataset:
// Original:
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {for (int i = 0; i < iterations; ++i) {final long block0 = blocks[blocksOffset++];values[valuesOffset++] = block0 >>> 40;values[valuesOffset++] = (block0 >>> 16) & 16777215L;final long block1 = blocks[blocksOffset++];values[valuesOffset++] = ((block0 & 65535L) << 8) | (block1 >>> 56);values[valuesOffset++] = (block1 >>> 32) & 16777215L;values[valuesOffset++] = (block1 >>> 8) & 16777215L;final long block2 = blocks[blocksOffset++];values[valuesOffset++] = ((block1 & 255L) << 16) | (block2 >>> 48);values[valuesOffset++] = (block2 >>> 24) & 16777215L;values[valuesOffset++] = block2 & 16777215L;}}

// Translation:
public override void Decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations){for (int i = 0; i < iterations; ++i){long block0 = blocks[blocksOffset++];values[valuesOffset++] = (long)((ulong)block0 >> 40);values[valuesOffset++] = ((long)((ulong)block0 >> 16)) & 16777215L;long block1 = blocks[blocksOffset++];values[valuesOffset++] = ((block0 & 65535L) << 8) | ((long)((ulong)block1 >> 56));values[valuesOffset++] = ((long)((ulong)block1 >> 32)) & 16777215L;values[valuesOffset++] = ((long)((ulong)block1 >> 8)) & 16777215L;long block2 = blocks[blocksOffset++];values[valuesOffset++] = ((block1 & 255L) << 16) | ((long)((ulong)block2 >> 48));values[valuesOffset++] = ((long)((ulong)block2 >> 24)) & 16777215L;values[valuesOffset++] = block2 & 16777215L;}}
// Original:
public FieldInfo fieldInfo(int fieldNumber) {if (fieldNumber < 0) {throw new IllegalArgumentException("Illegal field number: " + fieldNumber);}if (fieldNumber >= byNumber.length) {return null;}return byNumber[fieldNumber];}

// Translation:
public virtual FieldInfo FieldInfo(int fieldNumber){if (fieldNumber < 0){throw new System.ArgumentException("Illegal field number: " + fieldNumber);}Index.FieldInfo ret;byNumber.TryGetValue(fieldNumber, out ret);return ret;}
// Original:
public DescribeIdentityPoolResult describeIdentityPool(DescribeIdentityPoolRequest request) {request = beforeClientExecution(request);return executeDescribeIdentityPool(request);}

// Translation:
public virtual DescribeIdentityPoolResponse DescribeIdentityPool(DescribeIdentityPoolRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeIdentityPoolRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeIdentityPoolResponseUnmarshaller.Instance;return Invoke<DescribeIdentityPoolResponse>(request, options);}
// Original:
public static String getText(Node e) {StringBuilder sb = new StringBuilder();getTextBuffer(e, sb);return sb.toString();}

// Translation:
public static string GetText(XmlNode e){StringBuilder sb = new StringBuilder();GetTextBuffer(e, sb);return sb.ToString();}
// Original:
public void delete(int key) {int i = binarySearch(mKeys, 0, mSize, key);if (i >= 0) {removeAt(i);}}

// Translation:
public virtual void delete(int key){int i = binarySearch(mKeys, 0, mSize, key);if (i >= 0){removeAt(i);}}
// Original:
public GetCurrentMetricDataResult getCurrentMetricData(GetCurrentMetricDataRequest request) {request = beforeClientExecution(request);return executeGetCurrentMetricData(request);}

// Translation:
public virtual GetCurrentMetricDataResponse GetCurrentMetricData(GetCurrentMetricDataRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetCurrentMetricDataRequestMarshaller.Instance;options.ResponseUnmarshaller = GetCurrentMetricDataResponseUnmarshaller.Instance;return Invoke<GetCurrentMetricDataResponse>(request, options);}
// Original:
public void append(String name, FileMode mode, AnyObjectId id) {append(encode(name), mode, id);}

// Translation:
public virtual void Append(string name, FileMode mode, AnyObjectId id){Append(Constants.Encode(name), mode, id);}
// Original:
public final String replacement() {return replacementChars;}

// Translation:
public string replacement(){return replacementChars;}
// Original:
public WindowProtectRecord(boolean protect) {this(0);setProtect(protect);}

// Translation:
public WindowProtectRecord(bool protect):this(0){Protect = (protect);}
// Original:
public static boolean equals(long[] array1, long[] array2) {if (array1 == array2) {return true;}if (array1 == null || array2 == null || array1.length != array2.length) {return false;}for (int i = 0; i < array1.length; i++) {if (array1[i] != array2[i]) {return false;}}return true;}

// Translation:
public static bool equals(long[] array1, long[] array2){if (array1 == array2){return true;}if (array1 == null || array2 == null || array1.Length != array2.Length){return false;}{for (int i = 0; i < array1.Length; i++){if (array1[i] != array2[i]){return false;}}}return true;}
// Original:
public PredictionContext getParent(int index) {assert index == 0;return parent;}

// Translation:
public override PredictionContext GetParent(int index){System.Diagnostics.Debug.Assert(index == 0);return parent;}
// Original:
public CharSequence toQueryString(EscapeQuerySyntax escapeSyntaxParser) {return "*:*";}

// Translation:
public override string ToQueryString(IEscapeQuerySyntax escapeSyntaxParser){return "*:*";}
// Original:
public SeekStatus seekCeil(BytesRef term) throws IOException {throw new UnsupportedOperationException(getClass().getName()+" does not support seeking");}

// Translation:
public override SeekStatus SeekCeil(BytesRef term){throw new System.NotSupportedException(this.GetType().Name + " does not support seeking");}
// Original:
public BindInstance2VpcRequest() {super("Ots", "2016-06-20", "BindInstance2Vpc", "ots");setMethod(MethodType.POST);}

// Translation:
public BindInstance2VpcRequest(): base("Ots", "2016-06-20", "BindInstance2Vpc", "ots", "openAPI"){Method = MethodType.POST;}
// Original:
public UpdateTableResult updateTable(String tableName, ProvisionedThroughput provisionedThroughput) {return updateTable(new UpdateTableRequest().withTableName(tableName).withProvisionedThroughput(provisionedThroughput));}

// Translation:
public virtual UpdateTableResponse UpdateTable(string tableName, ProvisionedThroughput provisionedThroughput){var request = new UpdateTableRequest();request.TableName = tableName;request.ProvisionedThroughput = provisionedThroughput;return UpdateTable(request);}
// Original:
public boolean get(int index) {return in.get(docMap.newToOld(index));}

// Translation:
public bool Get(int index){return @in.Get(docMap.NewToOld(index));}
// Original:
public GetQueueAttributesResult getQueueAttributes(GetQueueAttributesRequest request) {request = beforeClientExecution(request);return executeGetQueueAttributes(request);}

// Translation:
public virtual GetQueueAttributesResponse GetQueueAttributes(GetQueueAttributesRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetQueueAttributesRequestMarshaller.Instance;options.ResponseUnmarshaller = GetQueueAttributesResponseUnmarshaller.Instance;return Invoke<GetQueueAttributesResponse>(request, options);}
// Original:
public UpdateUserRoutingProfileResult updateUserRoutingProfile(UpdateUserRoutingProfileRequest request) {request = beforeClientExecution(request);return executeUpdateUserRoutingProfile(request);}

// Translation:
public virtual UpdateUserRoutingProfileResponse UpdateUserRoutingProfile(UpdateUserRoutingProfileRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateUserRoutingProfileRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateUserRoutingProfileResponseUnmarshaller.Instance;return Invoke<UpdateUserRoutingProfileResponse>(request, options);}
// Original:
public int getMidIx() {int ixDiff = _highIx - _lowIx;if(ixDiff < 2) {return -1;}return _lowIx + (ixDiff / 2);}

// Translation:
public int GetMidIx(){int ixDiff = _highIx - _lowIx;if (ixDiff < 2){return -1;}return _lowIx + (ixDiff / 2);}
// Original:
public MergeResult getMergeResult() {return this.mergeResult;}

// Translation:
public virtual MergeCommandResult GetMergeResult(){return this.mergeResult;}
// Original:
public void setAsActiveCell(){int row=_record.getRow();short col=_record.getColumn();_sheet.getSheet().setActiveCellRow(row);_sheet.getSheet().setActiveCellCol(col);}

// Translation:
public void SetAsActiveCell(){int row = _record.Row;int col = _record.Column;this._sheet.Sheet.SetActiveCell(row, col);}
// Original:
public InviteMembersResult inviteMembers(InviteMembersRequest request) {request = beforeClientExecution(request);return executeInviteMembers(request);}

// Translation:
public virtual InviteMembersResponse InviteMembers(InviteMembersRequest request){var options = new InvokeOptions();options.RequestMarshaller = InviteMembersRequestMarshaller.Instance;options.ResponseUnmarshaller = InviteMembersResponseUnmarshaller.Instance;return Invoke<InviteMembersResponse>(request, options);}
// Original:
public FormatTrackingHSSFListener(HSSFListener childListener) {this(childListener, LocaleUtil.getUserLocale());}

// Translation:
public FormatTrackingHSSFListener(IHSSFListener childListener){this.childListener = childListener;}
// Original:
public UpdateDistributionRequest(DistributionConfig distributionConfig, String id, String ifMatch) {setDistributionConfig(distributionConfig);setId(id);setIfMatch(ifMatch);}

// Translation:
public UpdateDistributionRequest(string id, string ifMatch, DistributionConfig distributionConfig){_id = id;_ifMatch = ifMatch;_distributionConfig = distributionConfig;}
// Original:
public GetLogEventsRequest(String logGroupName, String logStreamName) {setLogGroupName(logGroupName);setLogStreamName(logStreamName);}

// Translation:
public GetLogEventsRequest(string logGroupName, string logStreamName){_logGroupName = logGroupName;_logStreamName = logStreamName;}
// Original:
public String toString() {return "FlushInfo [numDocs=" + numDocs + ", estimatedSegmentSize="+ estimatedSegmentSize + "]";}

// Translation:
public override string ToString(){return "FlushInfo [numDocs=" + NumDocs + ", estimatedSegmentSize=" + EstimatedSegmentSize + "]";}
// Original:
public GrowableWriter resize(int newSize) {GrowableWriter next = new GrowableWriter(getBitsPerValue(), newSize, acceptableOverheadRatio);final int limit = Math.min(size(), newSize);PackedInts.copy(current, 0, next, 0, limit, PackedInts.DEFAULT_BUFFER_SIZE);return next;}

// Translation:
public virtual GrowableWriter Resize(int newSize){GrowableWriter next = new GrowableWriter(BitsPerValue, newSize, acceptableOverheadRatio);int limit = Math.Min(Count, newSize);PackedInt32s.Copy(current, 0, next, 0, limit, PackedInt32s.DEFAULT_BUFFER_SIZE);return next;}
// Original:
public Analyzer(ReuseStrategy reuseStrategy) {this.reuseStrategy = reuseStrategy;}

// Translation:
public Analyzer(ReuseStrategy reuseStrategy){this.reuseStrategy = reuseStrategy;}
// Original:
public void reset() {prevAccept.reset();startIndex = -1;line = 1;charPositionInLine = 0;mode = Lexer.DEFAULT_MODE;}

// Translation:
public void Reset(){index = -1;line = 0;charPos = -1;dfaState = null;}
// Original:
public EmbeddedObjectRefSubRecord() {field_2_unknownFormulaData = new byte[] { 0x02, 0x6C, 0x6A, 0x16, 0x01, }; field_6_unknown = EMPTY_BYTE_ARRAY;field_4_ole_classname = null;}

// Translation:
public EmbeddedObjectRefSubRecord(){field_2_unknownFormulaData = new byte[] { 0x02, 0x6C, 0x6A, 0x16, 0x01, }; field_6_unknown = EMPTY_BYTE_ARRAY;field_4_ole_classname = null;field_4_unknownByte = null;}
// Original:
public String toString() {return "doc=" + doc + " score=" + score + " shardIndex=" + shardIndex;}

// Translation:
public override string ToString(){return "doc=" + Doc + " score=" + Score + " shardIndex=" + ShardIndex;}
// Original:
public static double kthLargest(double[] v, int k) {double r = Double.NaN;int index = k-1; if (v!=null && v.length > index && index >= 0) {Arrays.sort(v);r = v[v.length-index-1];}return r;}

// Translation:
public static double kthLargest(double[] v, int k){double r = double.NaN;k--; if (v != null && v.Length > k && k >= 0){Array.Sort(v);r = v[v.Length - k - 1];}return r;}
// Original:
public int get(int forwardId, int backwardId) {int offset = (backwardId * forwardSize + forwardId) * 2;return buffer.getShort(offset);}

// Translation:
public int Get(int forwardId, int backwardId){return costs[backwardId][forwardId];}
// Original:
public void sort() {Arrays.sort(entries, 0, count);}

// Translation:
public virtual void Sort(){Arrays.Sort(entries, 0, count);}
// Original:
public BM25FQuery build() {int size = fieldAndWeights.size() * termsSet.size();if (size > IndexSearcher.getMaxClauseCount()) {throw new IndexSearcher.TooManyClauses();}BytesRef[] terms = termsSet.toArray(new BytesRef[0]);return new BM25FQuery(similarity, new TreeMap<>(fieldAndWeights), terms);}

// Translation:
public virtual StemmerOverrideMap Build(){ByteSequenceOutputs outputs = ByteSequenceOutputs.Singleton;Builder<BytesRef> builder = new Builder<BytesRef>(FST.INPUT_TYPE.BYTE4, outputs);int[] sort = hash.Sort(BytesRef.UTF8SortedAsUnicodeComparer);Int32sRef intsSpare = new Int32sRef();int size = hash.Count;for (int i = 0; i < size; i++){int id = sort[i];BytesRef bytesRef = hash.Get(id, spare);UnicodeUtil.UTF8toUTF32(bytesRef, intsSpare);builder.Add(intsSpare, new BytesRef(outputValues[id]));}return new StemmerOverrideMap(builder.Finish(), ignoreCase);}
// Original:
public LexerCustomAction(int ruleIndex, int actionIndex) {this.ruleIndex = ruleIndex;this.actionIndex = actionIndex;}

// Translation:
public LexerCustomAction(int ruleIndex, int actionIndex){this.ruleIndex = ruleIndex;this.actionIndex = actionIndex;}
// Original:
public DescribeDevicePolicyConfigurationResult describeDevicePolicyConfiguration(DescribeDevicePolicyConfigurationRequest request) {request = beforeClientExecution(request);return executeDescribeDevicePolicyConfiguration(request);}

// Translation:
public virtual DescribeDevicePolicyConfigurationResponse DescribeDevicePolicyConfiguration(DescribeDevicePolicyConfigurationRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeDevicePolicyConfigurationRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeDevicePolicyConfigurationResponseUnmarshaller.Instance;return Invoke<DescribeDevicePolicyConfigurationResponse>(request, options);}
// Original:
public CreateLBCookieStickinessPolicyRequest(String loadBalancerName, String policyName) {setLoadBalancerName(loadBalancerName);setPolicyName(policyName);}

// Translation:
public CreateLBCookieStickinessPolicyRequest(string loadBalancerName, string policyName){_loadBalancerName = loadBalancerName;_policyName = policyName;}
// Original:
public static short[] grow(short[] array) {return grow(array, 1 + array.length);}

// Translation:
public static short[] Grow(short[] array){return Grow(array, 1 + array.Length);}
// Original:
public static AttrPtg createSpace(int type, int count) {int data = type & 0x00FF | (count << 8) & 0x00FFFF;return new AttrPtg(space.set(0), data, null, -1);}

// Translation:
public static AttrPtg CreateSpace(SpaceType type, int count){int data = ((int) type) & 0x00FF | (count << 8) & 0x00FFFF;return new AttrPtg(space.Set(0), data, null, -1);}
// Original:
public boolean equals(Object o) {return (o instanceof FontRecord) && sameProperties((FontRecord) o);}

// Translation:
public override bool Equals(Object obj){if (this == obj)return true;return false;}
// Original:
public void setDSTSavings(int milliseconds) {if (milliseconds > 0) {dstSavings = milliseconds;} else {throw new IllegalArgumentException();}}

// Translation:
public virtual void setDSTSavings(int milliseconds){throw new System.NotImplementedException();}
// Original:
public DescribeAccountResult describeAccount(DescribeAccountRequest request) {request = beforeClientExecution(request);return executeDescribeAccount(request);}

// Translation:
public virtual DescribeAccountResponse DescribeAccount(DescribeAccountRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeAccountRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeAccountResponseUnmarshaller.Instance;return Invoke<DescribeAccountResponse>(request, options);}
// Original:
public int getCellsVal() {int size = 0;for (Row row : rows)size += row.getCellsVal();return size;}

// Translation:
public virtual int GetCellsVal(){int size = 0;foreach (Row row in rows)size += row.GetCellsVal();return size;}
// Original:
public boolean equalsSameType(Object other) {assert exists || (false == value);MutableValueBool b = (MutableValueBool)other;return value == b.value && exists == b.exists;}

// Translation:
public override bool EqualsSameType(object other){MutableValueBool b = (MutableValueBool)other;return Value == b.Value && Exists == b.Exists;}
// Original:
public K next() {Node<K,V> n = next;advance();return n.key;}

// Translation:
public override K next(){return this.nextEntry().key;}
// Original:
public DBCluster createDBCluster(CreateDBClusterRequest request) {request = beforeClientExecution(request);return executeCreateDBCluster(request);}

// Translation:
public virtual CreateDBClusterResponse CreateDBCluster(CreateDBClusterRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateDBClusterRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateDBClusterResponseUnmarshaller.Instance;return Invoke<CreateDBClusterResponse>(request, options);}
// Original:
public boolean equals(Object o) {if (!(o instanceof FormatRun)) {return false;}FormatRun other = (FormatRun) o;return _character == other._character && _fontIndex == other._fontIndex;}

// Translation:
public override bool Equals(Object o){if (!(o is FormatRun)){return false;}FormatRun other = (FormatRun)o;return _character == other._character && _fontIndex == other._fontIndex;}
// Original:
public static ValueEval getSingleValue(ValueEval arg, int srcCellRow, int srcCellCol)throws EvaluationException {final ValueEval result;if (arg instanceof RefEval) {result = chooseSingleElementFromRef((RefEval) arg);} else if (arg instanceof AreaEval) {result = chooseSingleElementFromArea((AreaEval) arg, srcCellRow, srcCellCol);} else {result = arg;}if (result instanceof ErrorEval) {throw new EvaluationException((ErrorEval) result);}return result;}

// Translation:
public static ValueEval GetSingleValue(ValueEval arg, int srcCellRow, int srcCellCol){ValueEval result;if (arg is RefEval){result = ChooseSingleElementFromRef((RefEval)arg);}else if (arg is AreaEval){result = ChooseSingleElementFromArea((AreaEval)arg, srcCellRow, srcCellCol);}else{result = arg;}if (result is ErrorEval){throw new EvaluationException((ErrorEval)result);}return result;}
// Original:
public GermanStemFilterFactory(Map<String,String> args) {super(args);if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

// Translation:
public GermanStemFilterFactory(IDictionary<string, string> args): base(args){if (args.Count > 0){throw new System.ArgumentException("Unknown parameters: " + args);}}
// Original:
public ClusterSubnetGroup modifyClusterSubnetGroup(ModifyClusterSubnetGroupRequest request) {request = beforeClientExecution(request);return executeModifyClusterSubnetGroup(request);}

// Translation:
public virtual ModifyClusterSubnetGroupResponse ModifyClusterSubnetGroup(ModifyClusterSubnetGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = ModifyClusterSubnetGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = ModifyClusterSubnetGroupResponseUnmarshaller.Instance;return Invoke<ModifyClusterSubnetGroupResponse>(request, options);}
// Original:
public FacetLabel subpath(final int length) {if (length >= this.length || length < 0) {return this;} else {return new FacetLabel(this, length);}}

// Translation:
public virtual FacetLabel Subpath(int length){if (length >= this.Length || length < 0){return this;}else{return new FacetLabel(this, length);}}
// Original:
public DataValidationConstraint createDecimalConstraint(int operatorType, String formula1, String formula2) {return DVConstraint.createNumericConstraint(ValidationType.DECIMAL, operatorType, formula1, formula2);}

// Translation:
public IDataValidationConstraint CreateDecimalConstraint(int operatorType, String formula1, String formula2){return DVConstraint.CreateNumericConstraint(ValidationType.DECIMAL, operatorType, formula1, formula2);}
// Original:
public ByteBuffer put(byte b) {if (position == limit) {throw new BufferOverflowException();}backingArray[offset + position++] = b;return this;}

// Translation:
public override java.nio.ByteBuffer put(byte b){if (_position == _limit){throw new java.nio.BufferOverflowException();}backingArray[offset + _position++] = b;return this;}
// Original:
public DescribeUserProfileResult describeUserProfile(DescribeUserProfileRequest request) {request = beforeClientExecution(request);return executeDescribeUserProfile(request);}

// Translation:
public virtual DescribeUserProfileResponse DescribeUserProfile(DescribeUserProfileRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeUserProfileRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeUserProfileResponseUnmarshaller.Instance;return Invoke<DescribeUserProfileResponse>(request, options);}
// Original:
public K firstKey() {Entry<K, V> entry = endpoint(true);if (entry == null) {throw new NoSuchElementException();}return entry.getKey();}

// Translation:
public K firstKey(){java.util.MapClass.Entry<K, V> entry = this.endpoint(true);if (entry == null){throw new java.util.NoSuchElementException();}return entry.getKey();}
// Original:
public DescribeAutoScalingGroupsResult describeAutoScalingGroups(DescribeAutoScalingGroupsRequest request) {request = beforeClientExecution(request);return executeDescribeAutoScalingGroups(request);}

// Translation:
public virtual DescribeAutoScalingGroupsResponse DescribeAutoScalingGroups(DescribeAutoScalingGroupsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeAutoScalingGroupsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeAutoScalingGroupsResponseUnmarshaller.Instance;return Invoke<DescribeAutoScalingGroupsResponse>(request, options);}
// Original:
public Class<RefsChangedListener> getListenerType() {return RefsChangedListener.class;}

// Translation:
public override Type GetListenerType(){return typeof(RefsChangedListener);}
// Original:
public int getWordCost(int wordId) {return WORD_COST;}

// Translation:
public int GetWordCost(int wordId){return WORD_COST;}
// Original:
public void serialize(LittleEndianOutput out) {out.writeByte(field_1_horizontalAlignment);out.writeByte(field_2_verticalAlignment);out.writeShort(field_3_displayMode);out.writeInt(field_4_rgbColor);out.writeInt(field_5_x);out.writeInt(field_6_y);out.writeInt(field_7_width);out.writeInt(field_8_height);out.writeShort(field_9_options1);out.writeShort(field_10_indexOfColorValue);out.writeShort(field_11_options2);out.writeShort(field_12_textRotation);}

// Translation:
public override void Serialize(ILittleEndianOutput out1){out1.WriteByte(field_1_horizontalAlignment);out1.WriteByte(field_2_verticalAlignment);out1.WriteShort(field_3_DisplayMode);out1.WriteInt(field_4_rgbColor);out1.WriteInt(field_5_x);out1.WriteInt(field_6_y);out1.WriteInt(field_7_width);out1.WriteInt(field_8_height);out1.WriteShort(field_9_options1);out1.WriteShort(field_10_IndexOfColorValue);out1.WriteShort(field_11_options2);out1.WriteShort(field_12_textRotation);}
// Original:
public LinkedDataRecord getDataCategoryLabels(){return dataCategoryLabels;}

// Translation:
public BRAIRecord GetDataCategoryLabels(){return dataCategoryLabels;}
// Original:
public void setStringValue(String value) {collator.getRawCollationKey(value, key);bytes.bytes = key.bytes;bytes.offset = 0;bytes.length = key.size;}

// Translation:
public override void SetStringValue(string value){key = collator.GetRawCollationKey(value, key);bytes.Bytes = key.Bytes;bytes.Offset = 0;bytes.Length = key.Length;}
// Original:
public String toString() {return "FacetField(dim=" + dim + " path=" + Arrays.toString(path) + ")";}

// Translation:
public override string ToString(){return "FacetField(dim=" + Dim + " path=[" + Arrays.ToString(Path) + "])";}