yijunyu/c-to-rust huggingface dataset:
// Original:
public ListRulesPackagesResult listRulesPackages(ListRulesPackagesRequest request) {request = beforeClientExecution(request);return executeListRulesPackages(request);}

// Translation:
public virtual ListRulesPackagesResponse ListRulesPackages(ListRulesPackagesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListRulesPackagesRequestMarshaller.Instance;options.ResponseUnmarshaller = ListRulesPackagesResponseUnmarshaller.Instance;return Invoke<ListRulesPackagesResponse>(request, options);}
// Original:
public DisableMetricsCollectionResult disableMetricsCollection(DisableMetricsCollectionRequest request) {request = beforeClientExecution(request);return executeDisableMetricsCollection(request);}

// Translation:
public virtual DisableMetricsCollectionResponse DisableMetricsCollection(DisableMetricsCollectionRequest request){var options = new InvokeOptions();options.RequestMarshaller = DisableMetricsCollectionRequestMarshaller.Instance;options.ResponseUnmarshaller = DisableMetricsCollectionResponseUnmarshaller.Instance;return Invoke<DisableMetricsCollectionResponse>(request, options);}
// Original:
public static FloatBuffer wrap(float[] array) {return wrap(array, 0, array.length);}

// Translation:
public static java.nio.FloatBuffer wrap(float[] array_1){return wrap(array_1, 0, array_1.Length);}
// Original:
public void set(int index, long value) {final int o = index / 7;final int b = index % 7;final int shift = b * 9;blocks[o] = (blocks[o] & ~(511L << shift)) | (value << shift);}

// Translation:
public override void Set(int index, long value){int o = index / 7;int b = index % 7;int shift = b * 9;blocks[o] = (blocks[o] & ~(511L << shift)) | (value << shift);}
// Original:
public synchronized boolean containsKey(Object key) {int hash = key.hashCode();hash ^= (hash >>> 20) ^ (hash >>> 12);hash ^= (hash >>> 7) ^ (hash >>> 4);HashtableEntry<K, V>[] tab = table;for (HashtableEntry<K, V> e = tab[hash & (tab.length - 1)];e != null; e = e.next) {K eKey = e.key;if (eKey == key || (e.hash == hash && key.equals(eKey))) {return true;}}return false;}

// Translation:
public virtual bool containsKey(object key){lock (this){int hash = key.GetHashCode();hash ^= ((int)(((uint)hash) >> 20)) ^ ((int)(((uint)hash) >> 12));hash ^= ((int)(((uint)hash) >> 7)) ^ ((int)(((uint)hash) >> 4));java.util.Hashtable.HashtableEntry<K, V>[] tab = table;{for (java.util.Hashtable.HashtableEntry<K, V> e = tab[hash & (tab.Length - 1)]; e!= null; e = e.next){K eKey = e.key;if (Sharpen.Util.Equals(eKey, key) || (e.hash == hash && key.Equals(eKey))){return true;}}}return false;}}
// Original:
public void close() throws IOException {Throwable thrown = null;try {flush();} catch (Throwable e) {thrown = e;}try {out.close();} catch (Throwable e) {if (thrown == null) {thrown = e;}}if (thrown != null) {SneakyThrow.sneakyThrow(thrown);}}

// Translation:
public override void close(){System.Exception thrown = null;try{flush();}catch (System.Exception e){thrown = e;}try{@out.close();}catch (System.Exception e){if (thrown == null){thrown = e;}}if (thrown != null){Sharpen.Util.Throw(thrown);}}
// Original:
public List<String> getConflictList() {return conflictList;}

// Translation:
public virtual IList<string> GetConflictList(){return conflictList;}
// Original:
public ListOrganizationAdminAccountsResult listOrganizationAdminAccounts(ListOrganizationAdminAccountsRequest request) {request = beforeClientExecution(request);return executeListOrganizationAdminAccounts(request);}

// Translation:
public virtual ListOrganizationAdminAccountsResponse ListOrganizationAdminAccounts(ListOrganizationAdminAccountsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListOrganizationAdminAccountsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListOrganizationAdminAccountsResponseUnmarshaller.Instance;return Invoke<ListOrganizationAdminAccountsResponse>(request, options);}
// Original:
public static double min(double[] values) {double min = Double.POSITIVE_INFINITY;for (double value : values) {min = Math.min(min, value);}return min;}

// Translation:
public static double Min(double[] values){double min = double.PositiveInfinity;for (int i = 0, iSize = values.Length; i < iSize; i++){min = Math.Min(min, values[i]);}return min;}
// Original:
@Override public int read() throws IOException {return Streams.readSingleByte(this);}

// Translation:
public override int read(){throw new System.NotImplementedException();}
// Original:
public void removeLineCount() {remove1stProperty(PropertyIDMap.PID_LINECOUNT);}

// Translation:
public void RemoveLineCount(){MutableSection s = (MutableSection)FirstSection;s.RemoveProperty(PropertyIDMap.PID_LINECOUNT);}
// Original:
public RowRecordsAggregate(RecordStream rs, SharedValueManager svm) {this(svm);while(rs.hasNext()) {Record rec = rs.getNext();switch (rec.getSid()) {case RowRecord.sid:insertRow((RowRecord) rec);continue;case DConRefRecord.sid:addUnknownRecord(rec);continue;case DBCellRecord.sid:continue;}if (rec instanceof UnknownRecord) {addUnknownRecord(rec);while (rs.peekNextSid() == ContinueRecord.sid) {addUnknownRecord(rs.getNext());}continue;}if (rec instanceof MulBlankRecord) {_valuesAgg.addMultipleBlanks((MulBlankRecord) rec);continue;}if (!(rec instanceof CellValueRecordInterface)) {throw new RuntimeException("Unexpected record type (" + rec.getClass().getName() + ")");}_valuesAgg.construct((CellValueRecordInterface)rec, rs, svm);}}

// Translation:
public RowRecordsAggregate(RecordStream rs, SharedValueManager svm): this(svm){while (rs.HasNext()){Record rec = rs.GetNext();switch (rec.Sid){case RowRecord.sid:InsertRow((RowRecord)rec);continue;case DConRefRecord.sid:AddUnknownRecord(rec);continue;case DBCellRecord.sid:continue;}if (rec is UnknownRecord){AddUnknownRecord((UnknownRecord)rec);while (rs.PeekNextSid() == ContinueRecord.sid){AddUnknownRecord(rs.GetNext());}continue;}if (rec is MulBlankRecord) {_valuesAgg.AddMultipleBlanks((MulBlankRecord) rec);continue;}if (!(rec is CellValueRecordInterface)){if (rec.Sid == SeriesIndexRecord.sid){AddUnknownRecord(rec);continue;}throw new InvalidOperationException("Unexpected record type (" + rec.GetType().Name + ")");}_valuesAgg.Construct((CellValueRecordInterface)rec, rs, svm);}}
// Original:
public CreateRepoSyncTaskRequest() {super("cr", "2016-06-07", "CreateRepoSyncTask", "cr");setUriPattern("/repos/[RepoNamespace]/[RepoName]/syncTasks");setMethod(MethodType.PUT);}

// Translation:
public CreateRepoSyncTaskRequest(): base("cr", "2016-06-07", "CreateRepoSyncTask", "cr", "openAPI"){UriPattern = "/repos/[RepoNamespace]/[RepoName]/syncTasks";Method = MethodType.PUT;}
// Original:
public SharedFormula(SpreadsheetVersion ssVersion){_columnWrappingMask = ssVersion.getLastColumnIndex(); _rowWrappingMask = ssVersion.getLastRowIndex();}

// Translation:
public SharedFormula(SpreadsheetVersion ssVersion){_columnWrappingMask = ssVersion.LastColumnIndex; _rowWrappingMask = ssVersion.LastRowIndex;}
// Original:
public LexerTypeAction(int type) {this.type = type;}

// Translation:
public LexerTypeAction(int type){this.type = type;}
// Original:
public char first() {if (start == end) {return DONE;}offset = start;return string.charAt(offset);}

// Translation:
public char first(){if (start == end){return java.text.CharacterIteratorClass.DONE;}offset = start;return @string[offset];}
// Original:
public ShortBuffer slice() {return new ReadOnlyShortArrayBuffer(remaining(), backingArray, offset + position);}

// Translation:
public override java.nio.ShortBuffer slice(){return new java.nio.ReadOnlyShortArrayBuffer(remaining(), backingArray, offset +_position);}
// Original:
public RenameBranchCommand setNewName(String newName) {checkCallable();this.newName = newName;return this;}

// Translation:
public virtual NGit.Api.RenameBranchCommand SetNewName(string newName){CheckCallable();this.newName = newName;return this;}
// Original:
public void serialize(LittleEndianOutput out) {out.writeShort(getOptions());out.writeInt(getHorizontalPos());out.writeInt(getVerticalPos());out.writeInt(getObjectID());out.writeInt(getDVRecNo());}

// Translation:
public override void Serialize(ILittleEndianOutput out1){out1.WriteShort(Options);out1.WriteInt(HorizontalPos);out1.WriteInt(VerticalPos);out1.WriteInt(ObjectID);out1.WriteInt(DVRecNo);}
// Original:
public SheetBuilder setCreateEmptyCells(boolean shouldCreateEmptyCells) {this.shouldCreateEmptyCells = shouldCreateEmptyCells;return this;}

// Translation:
public SheetBuilder SetCreateEmptyCells(bool shouldCreateEmptyCells){this.shouldCreateEmptyCells = shouldCreateEmptyCells;return this;}
// Original:
public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval serialNumVE, ValueEval returnTypeVE) {double serialNum;try {serialNum = NumericFunction.singleOperandEvaluate(serialNumVE, srcRowIndex, srcColumnIndex);} catch (EvaluationException e) {return ErrorEval.VALUE_INVALID;}Calendar serialNumCalendar = LocaleUtil.getLocaleCalendar();serialNumCalendar.setTime(DateUtil.getJavaDate(serialNum, false));int returnType;try {ValueEval ve = OperandResolver.getSingleValue(returnTypeVE, srcRowIndex, srcColumnIndex);returnType = OperandResolver.coerceValueToInt(ve);} catch (EvaluationException e) {return ErrorEval.NUM_ERROR;}if (returnType != 1 && returnType != 2) {return ErrorEval.NUM_ERROR;}return new NumberEval(this.getWeekNo(serialNumCalendar, returnType));}

// Translation:
public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval serialNumVE, ValueEval returnTypeVE){double serialNum = 0.0;try{serialNum = NumericFunction.SingleOperandEvaluate(serialNumVE, srcRowIndex, srcColumnIndex);}catch (EvaluationException){return ErrorEval.VALUE_INVALID;}DateTime serialNumCalendar = DateUtil.GetJavaDate(serialNum, false);int returnType = 0;try{ValueEval ve = OperandResolver.GetSingleValue(returnTypeVE, srcRowIndex, srcColumnIndex);returnType = OperandResolver.CoerceValueToInt(ve);}catch (EvaluationException){return ErrorEval.NUM_ERROR;}if (returnType != 1 && returnType != 2){return ErrorEval.NUM_ERROR;}return new NumberEval(this.getWeekNo(serialNumCalendar, returnType));}
// Original:
public static int checkHeader(DataInput in, String codec, int minVersion, int maxVersion) throws IOException {final int actualHeader = in.readInt();if (actualHeader != CODEC_MAGIC) {throw new CorruptIndexException("codec header mismatch: actual header=" + actualHeader + " vs expected header=" + CODEC_MAGIC, in);}return checkHeaderNoMagic(in, codec, minVersion, maxVersion);}

// Translation:
public static int CheckHeader(DataInput @in, string codec, int minVersion, int maxVersion){int actualHeader = @in.ReadInt32();if (actualHeader != CODEC_MAGIC){throw new System.IO.IOException("codec header mismatch: actual header=" + actualHeader + " vs expected header=" + CODEC_MAGIC + " (resource: " + @in + ")");}return CheckHeaderNoMagic(@in, codec, minVersion, maxVersion);}
// Original:
public String getErrorDisplay(String s) {StringBuilder buf = new StringBuilder();for (char c : s.toCharArray()) {buf.append(getErrorDisplay(c));}return buf.toString();}

// Translation:
public virtual string GetErrorDisplay(string s){StringBuilder buf = new StringBuilder();for (var i = 0; i < s.Length; ) {var codePoint = Char.ConvertToUtf32(s, i);buf.Append(GetErrorDisplay(codePoint));i += (codePoint > 0xFFFF) ? 2 : 1;}return buf.ToString();}
// Original:
public boolean seekExact(BytesRef text) {termUpto = binarySearch(text, br, 0, info.terms.size()-1, info.terms, info.sortedTerms);return termUpto >= 0;}

// Translation:
public override bool SeekExact(BytesRef text){termUpto = BinarySearch(text, br, 0, info.terms.Count - 1, info.terms, info.sortedTerms, BytesRef.UTF8SortedAsUnicodeComparer);return termUpto >= 0;}
// Original:
public CacheSecurityGroup createCacheSecurityGroup(CreateCacheSecurityGroupRequest request) {request = beforeClientExecution(request);return executeCreateCacheSecurityGroup(request);}

// Translation:
public virtual CreateCacheSecurityGroupResponse CreateCacheSecurityGroup(CreateCacheSecurityGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateCacheSecurityGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateCacheSecurityGroupResponseUnmarshaller.Instance;return Invoke<CreateCacheSecurityGroupResponse>(request, options);}
// Original:
public FetchMomentPhotosRequest() {super("CloudPhoto", "2017-07-11", "FetchMomentPhotos", "cloudphoto");setProtocol(ProtocolType.HTTPS);}

// Translation:
public FetchMomentPhotosRequest(): base("CloudPhoto", "2017-07-11", "FetchMomentPhotos", "cloudphoto", "openAPI"){Protocol = ProtocolType.HTTPS;}
// Original:
public int getRuleIndex(String ruleName) {Integer ruleIndex = getRuleIndexMap().get(ruleName);if ( ruleIndex!=null ) return ruleIndex;return -1;}

// Translation:
public virtual int GetRuleIndex(string ruleName){int ruleIndex;if (RuleIndexMap.TryGetValue(ruleName, out ruleIndex)){return ruleIndex;}return -1;}
// Original:
public RebootInstanceRequest() {super("Ens", "2017-11-10", "RebootInstance", "ens");setMethod(MethodType.POST);}

// Translation:
public RebootInstanceRequest(): base("HPC", "2016-06-03", "RebootInstance"){Method = MethodType.POST;}
// Original:
public RevokeClientVpnIngressResult revokeClientVpnIngress(RevokeClientVpnIngressRequest request) {request = beforeClientExecution(request);return executeRevokeClientVpnIngress(request);}

// Translation:
public virtual RevokeClientVpnIngressResponse RevokeClientVpnIngress(RevokeClientVpnIngressRequest request){var options = new InvokeOptions();options.RequestMarshaller = RevokeClientVpnIngressRequestMarshaller.Instance;options.ResponseUnmarshaller = RevokeClientVpnIngressResponseUnmarshaller.Instance;return Invoke<RevokeClientVpnIngressResponse>(request, options);}
// Original:
public boolean supportsExecute() {return false;}

// Translation:
public override bool SupportsExecute(){return false;}
// Original:
public String toString(){StringBuilder buffer = new StringBuilder();buffer.append("[SHARED FORMULA (").append(HexDump.intToHex(sid)).append("]\n");buffer.append("    .range      = ").append(getRange()).append("\n");buffer.append("    .reserved    = ").append(HexDump.shortToHex(field_5_reserved)).append("\n");Ptg[] ptgs = field_7_parsed_expr.getTokens();for (int k = 0; k < ptgs.length; k++ ) {buffer.append("Formula[").append(k).append("]");Ptg ptg = ptgs[k];buffer.append(ptg).append(ptg.getRVAType()).append("\n");}buffer.append("[/SHARED FORMULA]\n");return buffer.toString();}

// Translation:
public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append("[SHARED FORMULA (").Append(HexDump.IntToHex(sid)).Append("]\n");buffer.Append("    .range      = ").Append(Range.ToString()).Append("\n");buffer.Append("    .reserved    = ").Append(HexDump.ShortToHex(field_5_reserved)).Append("\n");Ptg[] ptgs = field_7_parsed_expr.Tokens;for (int k = 0; k < ptgs.Length; k++){buffer.Append("Formula[").Append(k).Append("]");Ptg ptg = ptgs[k];buffer.Append(ptg.ToString()).Append(ptg.RVAType).Append("\n");}buffer.Append("[/SHARED FORMULA]\n");return buffer.ToString();}
// Original:
public LexerPushModeAction(int mode) {this.mode = mode;}

// Translation:
public LexerPushModeAction(int mode){this.mode = mode;}
// Original:
public void mark(int readlimit) {mark = ptr;}

// Translation:
public override void Mark(int readlimit){mark = ptr;}
// Original:
public ClusterParameterGroup createClusterParameterGroup(CreateClusterParameterGroupRequest request) {request = beforeClientExecution(request);return executeCreateClusterParameterGroup(request);}

// Translation:
public virtual CreateClusterParameterGroupResponse CreateClusterParameterGroup(CreateClusterParameterGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateClusterParameterGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateClusterParameterGroupResponseUnmarshaller.Instance;return Invoke<CreateClusterParameterGroupResponse>(request, options);}
// Original:
public String distanceSubQueryNotAllowed() {Iterator<SrndQuery> sqi = getSubQueriesIterator();while (sqi.hasNext()) {SrndQuery leq = sqi.next();if (leq instanceof DistanceSubQuery) {String m = ((DistanceSubQuery)leq).distanceSubQueryNotAllowed();if (m != null) {return m;}} else {return "subquery not allowed: " + leq.toString();}}return null;}

// Translation:
public virtual string DistanceSubQueryNotAllowed(){var sqi = GetSubQueriesEnumerator();while (sqi.MoveNext()){SrndQuery leq = sqi.Current;if (leq is IDistanceSubQuery){string m = ((IDistanceSubQuery)leq).DistanceSubQueryNotAllowed();if (m != null){return m;}}else{return "subquery not allowed: " + leq.ToString();}}return null;}
// Original:
public DescribeBrokerEngineTypesResult describeBrokerEngineTypes(DescribeBrokerEngineTypesRequest request) {request = beforeClientExecution(request);return executeDescribeBrokerEngineTypes(request);}

// Translation:
public virtual DescribeBrokerEngineTypesResponse DescribeBrokerEngineTypes(DescribeBrokerEngineTypesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeBrokerEngineTypesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeBrokerEngineTypesResponseUnmarshaller.Instance;return Invoke<DescribeBrokerEngineTypesResponse>(request, options);}
// Original:
public DescribeReservedDBInstancesOfferingsResult describeReservedDBInstancesOfferings(DescribeReservedDBInstancesOfferingsRequest request) {request = beforeClientExecution(request);return executeDescribeReservedDBInstancesOfferings(request);}

// Translation:
public virtual DescribeReservedDBInstancesOfferingsResponse DescribeReservedDBInstancesOfferings(DescribeReservedDBInstancesOfferingsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeReservedDBInstancesOfferingsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeReservedDBInstancesOfferingsResponseUnmarshaller.Instance;return Invoke<DescribeReservedDBInstancesOfferingsResponse>(request, options);}
// Original:
public ByteBuffer slice() {return new ReadWriteHeapByteBuffer(backingArray, remaining(), offset + position);}

// Translation:
public override java.nio.ByteBuffer slice(){return new java.nio.ReadWriteHeapByteBuffer(backingArray, remaining(), offset + _position);}
// Original:
public GetCollectionRequest() {super("cr", "2016-06-07", "GetCollection", "cr");setUriPattern("/collections");setMethod(MethodType.GET);}

// Translation:
public GetCollectionRequest(): base("cr", "2016-06-07", "GetCollection", "cr", "openAPI"){UriPattern = "/collections";Method = MethodType.GET;}
// Original:
public DeleteApplicationVersionRequest(String applicationName, String versionLabel) {setApplicationName(applicationName);setVersionLabel(versionLabel);}

// Translation:
public DeleteApplicationVersionRequest(string applicationName, string versionLabel){_applicationName = applicationName;_versionLabel = versionLabel;}
// Original:
public int last() {return (current = end);}

// Translation:
public override int Last(){return (current = end);}
// Original:
public DeleteFleetResult deleteFleet(DeleteFleetRequest request) {request = beforeClientExecution(request);return executeDeleteFleet(request);}

// Translation:
public virtual DeleteFleetResponse DeleteFleet(DeleteFleetRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteFleetRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteFleetResponseUnmarshaller.Instance;return Invoke<DeleteFleetResponse>(request, options);}
// Original:
public void sync(Collection<String> names) {throw new UnsupportedOperationException();}

// Translation:
public override void Sync(ICollection<string> names){throw new NotSupportedException();}
// Original:
public DescribeWorkteamResult describeWorkteam(DescribeWorkteamRequest request) {request = beforeClientExecution(request);return executeDescribeWorkteam(request);}

// Translation:
public virtual DescribeWorkteamResponse DescribeWorkteam(DescribeWorkteamRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeWorkteamRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeWorkteamResponseUnmarshaller.Instance;return Invoke<DescribeWorkteamResponse>(request, options);}
// Original:
public StatusCommand status() {return new StatusCommand(repo);}

// Translation:
public virtual StatusCommand Status(){return new StatusCommand(repo);}
// Original:
public StopInstancesResult stopInstances(StopInstancesRequest request) {request = beforeClientExecution(request);return executeStopInstances(request);}

// Translation:
public virtual StopInstancesResponse StopInstances(StopInstancesRequest request){var options = new InvokeOptions();options.RequestMarshaller = StopInstancesRequestMarshaller.Instance;options.ResponseUnmarshaller = StopInstancesResponseUnmarshaller.Instance;return Invoke<StopInstancesResponse>(request, options);}
// Original:
public boolean equals(Object obj) {if (obj == null)return false;if (obj == this)return true;if (obj.getClass() != getClass())return false;HSSFChildAnchor anchor = (HSSFChildAnchor) obj;return anchor.getDx1() == getDx1() && anchor.getDx2() == getDx2() && anchor.getDy1() == getDy1()&& anchor.getDy2() == getDy2();}

// Translation:
public override bool Equals(object obj){if (obj == null)return false;if (obj == this)return true;if (obj.GetType() != GetType())return false;HSSFChildAnchor anchor = (HSSFChildAnchor)obj;return anchor.Dx1 == Dx1 && anchor.Dx2 == Dx2 && anchor.Dy1 == Dy1&& anchor.Dy2 == Dy2;}
// Original:
public DescribeDBSubnetGroupsResult describeDBSubnetGroups() {return describeDBSubnetGroups(new DescribeDBSubnetGroupsRequest());}

// Translation:
public virtual DescribeDBSubnetGroupsResponse DescribeDBSubnetGroups(){return DescribeDBSubnetGroups(new DescribeDBSubnetGroupsRequest());}
// Original:
public PostingsEnum reset(int[] docIDs, int[] freqs) {this.docIDs = docIDs;this.freqs = freqs;docID = upto = -1;return this;}

// Translation:
public DocsEnum Reset(int[] docIDs, int[] freqs){this.docIDs = docIDs;this.freqs = freqs;docID_Renamed = upto = -1;return this;}
// Original:
public boolean hasNext() {return index < size;}

// Translation:
public override bool HasNext(){return this.index < this._enclosing.size;}
// Original:
public ListTagsForResourceResult listTagsForResource(ListTagsForResourceRequest request) {request = beforeClientExecution(request);return executeListTagsForResource(request);}

// Translation:
public virtual ListTagsForResourceResponse ListTagsForResource(ListTagsForResourceRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance;options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance;return Invoke<ListTagsForResourceResponse>(request, options);}
// Original:
public static String getBuiltinFormat(int index) {if (index < 0 || index >=_formats.length) {return null;}return _formats[index];}

// Translation:
public static String GetBuiltinFormat(int index){if (index < 0 || index >= _formats.Length){return null;}return _formats[index];}
// Original:
public ExpandedDouble(long rawBits) {int biasedExp = Math.toIntExact(rawBits >> 52);if (biasedExp == 0) {BigInteger frac = BigInteger.valueOf(rawBits).and(BI_FRAC_MASK);int expAdj = 64 - frac.bitLength();_significand = frac.shiftLeft(expAdj);_binaryExponent = (biasedExp & 0x07FF) - 1023 - expAdj;} else {_significand = getFrac(rawBits);_binaryExponent = (biasedExp & 0x07FF) - 1023;}}

// Translation:
public ExpandedDouble(long rawBits){int biasedExp = (int)(rawBits >> 52);if (biasedExp == 0){BigInteger frac = new BigInteger(rawBits)&BI_FRAC_MASK;int expAdj = 64 - frac.BitLength();_significand = frac<<expAdj;_binaryExponent = (biasedExp & 0x07FF) - 1023 - expAdj;}else{BigInteger frac = GetFrac(rawBits);_significand = frac;_binaryExponent = (biasedExp & 0x07FF) - 1023;}}
// Original:
public void serialize(LittleEndianOutput out) {out.writeShort(_codepage);}

// Translation:
public override void Serialize(ILittleEndianOutput out1){out1.WriteShort(_codepage);}
// Original:
public void add(RevCommit c) {throw new UnsupportedOperationException();}

// Translation:
public override void Add(RevCommit c){throw new NotSupportedException();}