yijunyu/c-to-rust huggingface dataset:
// Original:
public void copyRawTo(int[] b, int o) {b[o] = w1;b[o + 1] = w2;b[o + 2] = w3;b[o + 3] = w4;b[o + 4] = w5;}

// Translation:
public virtual void CopyRawTo(byte[] b, int o){NB.EncodeInt32(b, o, w1);NB.EncodeInt32(b, o + 4, w2);NB.EncodeInt32(b, o + 8, w3);NB.EncodeInt32(b, o + 12, w4);NB.EncodeInt32(b, o + 16, w5);}
// Original:
public SetStackPolicyResult setStackPolicy(SetStackPolicyRequest request) {request = beforeClientExecution(request);return executeSetStackPolicy(request);}

// Translation:
public virtual SetStackPolicyResponse SetStackPolicy(SetStackPolicyRequest request){var options = new InvokeOptions();options.RequestMarshaller = SetStackPolicyRequestMarshaller.Instance;options.ResponseUnmarshaller = SetStackPolicyResponseUnmarshaller.Instance;return Invoke<SetStackPolicyResponse>(request, options);}
// Original:
public String toString() {StringBuilder s = new StringBuilder();append(s, oldRef, "CREATE"); s.append(' ');append(s, newRef, "DELETE"); s.append(' ').append(getRefName());s.append(' ').append(getResult());if (getMessage() != null) {s.append(' ').append(getMessage());}return s.toString();}

// Translation:
public override string ToString(){StringBuilder sb = new StringBuilder();sb.Append("TrackingRefUpdate[");sb.Append(remoteName);sb.Append(" -> ");sb.Append(localName);if (forceUpdate){sb.Append(" (forced)");}sb.Append(" ");sb.Append(oldObjectId == null ? string.Empty : oldObjectId.Abbreviate(7).Name);sb.Append("..");sb.Append(newObjectId == null ? string.Empty : newObjectId.Abbreviate(7).Name);sb.Append("]");return sb.ToString();}
// Original:
public short getXFAt(int coffset) {return field_3_rks[coffset].xf;}

// Translation:
public short GetXFAt(int coffset){return field_3_rks[coffset].xf;}
// Original:
public ByteBuffer put(byte[] src, int srcOffset, int byteCount) {Arrays.checkOffsetAndCount(src.length, srcOffset, byteCount);if (byteCount > remaining()) {throw new BufferOverflowException();}for (int i = srcOffset; i < srcOffset + byteCount; ++i) {put(src[i]);}return this;}

// Translation:
public virtual java.nio.ByteBuffer put(byte[] src, int srcOffset, int byteCount){java.util.Arrays.checkOffsetAndCount(src.Length, srcOffset, byteCount);if (byteCount > remaining()){throw new java.nio.BufferOverflowException();}{for (int i = srcOffset; i < srcOffset + byteCount; ++i){put(src[i]);}}return this;}
// Original:
public ReceiveMessageResult receiveMessage(String queueUrl) {return receiveMessage(new ReceiveMessageRequest().withQueueUrl(queueUrl));}

// Translation:
public virtual ReceiveMessageResponse ReceiveMessage(string queueUrl){var request = new ReceiveMessageRequest();request.QueueUrl = queueUrl;return ReceiveMessage(request);}
// Original:
public NativeUnixIndexInput(NativeUnixIndexInput other) throws IOException {super(other.toString());this.fis = null;channel = other.channel;this.bufferSize = other.bufferSize;buffer = ByteBuffer.allocateDirect(bufferSize);filePos = -bufferSize;bufferPos = bufferSize;isOpen = true;isClone = true;seek(other.getFilePointer());}

// Translation:
public NativeUnixIndexInput(NativeUnixIndexInput other) throws IOException{base(other.ToString());this.fis = null;channel = other.channel;this.bufferSize = other.bufferSize;buffer = ByteBuffer.allocateDirect(bufferSize);filePos = -bufferSize;bufferPos = bufferSize;isOpen = true;isClone = true;seek(other.FilePointer);}
// Original:
public Merger newMerger(Repository db, boolean inCore) {return new OneSide(db, treeIndex);}

// Translation:
public override Merger NewMerger(Repository db, bool inCore){return new StrategyOneSided.OneSide(db, treeIndex);}
// Original:
public void flush() {synchronized (lock) {if (out != null) {try {out.flush();} catch (IOException e) {setError();}} else {setError();}}}

// Translation:
public override void flush(){lock (@lock){if (@out != null){try{@out.flush();}catch (System.IO.IOException){setError();}}else{setError();}}}
// Original:
public DisassociateIamInstanceProfileResult disassociateIamInstanceProfile(DisassociateIamInstanceProfileRequest request) {request = beforeClientExecution(request);return executeDisassociateIamInstanceProfile(request);}

// Translation:
public virtual DisassociateIamInstanceProfileResponse DisassociateIamInstanceProfile(DisassociateIamInstanceProfileRequest request){var options = new InvokeOptions();options.RequestMarshaller = DisassociateIamInstanceProfileRequestMarshaller.Instance;options.ResponseUnmarshaller = DisassociateIamInstanceProfileResponseUnmarshaller.Instance;return Invoke<DisassociateIamInstanceProfileResponse>(request, options);}
// Original:
public void beginTask(String title, int totalWork) {if (!isMainThread())throw new IllegalStateException();pm.beginTask(title, totalWork);}

// Translation:
public override void BeginTask(string title, int totalWork){if (!IsMainThread()){throw new InvalidOperationException();}pm.BeginTask(title, totalWork);}
// Original:
public void run() {try {count = task.runAndMaybeStats(letChildReport);} catch (Exception e) {throw new RuntimeException(e);}}

// Translation:
public override void Run(){try{count = task.RunAndMaybeStats(letChildReport);}catch (Exception e){throw new Exception(e.ToString(), e);}}
// Original:
public TokenFilter create(TokenStream input) {return new EdgeNGramTokenFilter(input, minGramSize, maxGramSize, preserveOriginal);}

// Translation:
public override TokenStream Create(TokenStream input){#pragma warning disable 612, 618return new EdgeNGramTokenFilter(m_luceneMatchVersion, input, side, minGramSize, maxGramSize);#pragma warning restore 612, 618}
// Original:
public String toString() {return "RemoteRefUpdate[remoteName="+ remoteName+ ", "+ status+ ", "+ (expectedOldObjectId != null ? expectedOldObjectId.name(): "(null)") + "..."+ (newObjectId != null ? newObjectId.name() : "(null)")+ (fastForward ? ", fastForward" : "")+ ", srcRef=" + srcRef+ (forceUpdate ? ", forceUpdate" : "") + ", message="+ (message != null ? "\"" + message + "\"" : "null") + "]";}

// Translation:
public override string ToString(){return "RemoteRefUpdate[remoteName=" + remoteName + ", " + status + ", " + (expectedOldObjectId!= null ? expectedOldObjectId.Name : "(null)") + "..." + (newObjectId != null ?newObjectId.Name : "(null)") + (fastForward ? ", fastForward" : string.Empty) +", srcRef=" + srcRef + (forceUpdate ? ", forceUpdate" : string.Empty) + ", message="+ (message != null ? "\"" + message + "\"" : "null") + "]";}
// Original:
public ListJournalS3ExportsResult listJournalS3Exports(ListJournalS3ExportsRequest request) {request = beforeClientExecution(request);return executeListJournalS3Exports(request);}

// Translation:
public virtual ListJournalS3ExportsResponse ListJournalS3Exports(ListJournalS3ExportsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListJournalS3ExportsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListJournalS3ExportsResponseUnmarshaller.Instance;return Invoke<ListJournalS3ExportsResponse>(request, options);}
// Original:
public boolean lookingAt() {matchFound = lookingAtImpl(address, input, matchOffsets);if (matchFound) {findPos = matchOffsets[1];}return matchFound;}

// Translation:
public bool lookingAt(){matchFound = lookingAtImpl(address, input, matchOffsets);if (matchFound){findPos = matchOffsets[1];}return matchFound;}
// Original:
public DescribeIdentityUsageResult describeIdentityUsage(DescribeIdentityUsageRequest request) {request = beforeClientExecution(request);return executeDescribeIdentityUsage(request);}

// Translation:
public virtual DescribeIdentityUsageResponse DescribeIdentityUsage(DescribeIdentityUsageRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeIdentityUsageRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeIdentityUsageResponseUnmarshaller.Instance;return Invoke<DescribeIdentityUsageResponse>(request, options);}
// Original:
public void carry(RevFlag flag) {final int carry = flags & flag.mask;if (carry != 0)carryFlags(this, carry);}

// Translation:
public virtual void Carry(RevFlag flag){int carry = flags & flag.mask;if (carry != 0){CarryFlags(this, carry);}}
// Original:
public Count(){_predicate = defaultPredicate;}

// Translation:
public Count(){_predicate = defaultPredicate;}
// Original:
public ShowNoteCommand notesShow() {return new ShowNoteCommand(repo);}

// Translation:
public virtual ShowNoteCommand NotesShow(){return new ShowNoteCommand(repo);}
// Original:
public ResolveRoomResult resolveRoom(ResolveRoomRequest request) {request = beforeClientExecution(request);return executeResolveRoom(request);}

// Translation:
public virtual ResolveRoomResponse ResolveRoom(ResolveRoomRequest request){var options = new InvokeOptions();options.RequestMarshaller = ResolveRoomRequestMarshaller.Instance;options.ResponseUnmarshaller = ResolveRoomResponseUnmarshaller.Instance;return Invoke<ResolveRoomResponse>(request, options);}
// Original:
public ValueEval getArea3DEval(Area3DPxg aptg) {SheetRangeEvaluator sre = createExternSheetRefEvaluator(aptg.getSheetName(), aptg.getLastSheetName(), aptg.getExternalWorkbookNumber());return new LazyAreaEval(aptg.getFirstRow(), aptg.getFirstColumn(),aptg.getLastRow(), aptg.getLastColumn(), sre);}

// Translation:
public ValueEval GetArea3DEval(Area3DPxg aptg){SheetRangeEvaluator sre = CreateExternSheetRefEvaluator(aptg.SheetName, aptg.LastSheetName, aptg.ExternalWorkbookNumber);return new LazyAreaEval(aptg.FirstRow, aptg.FirstColumn,aptg.LastRow, aptg.LastColumn, sre);}
// Original:
public DoubleMetaphoneFilterFactory(Map<String,String> args) {super(args);inject = getBoolean(args, INJECT, true);maxCodeLength = getInt(args, MAX_CODE_LENGTH, DEFAULT_MAX_CODE_LENGTH);if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

// Translation:
public DoubleMetaphoneFilterFactory(IDictionary<string, string> args): base(args){inject = GetBoolean(args, INJECT, true);maxCodeLength = GetInt32(args, MAX_CODE_LENGTH, DEFAULT_MAX_CODE_LENGTH);if (!(args.Count == 0)){throw new ArgumentException("Unknown parameters: " + args);}}
// Original:
public String toString() {StringBuilder buffer = new StringBuilder();buffer.append("[PALETTE]\n");buffer.append("  numcolors     = ").append(_colors.size()).append('\n');for (int i = 0; i < _colors.size(); i++) {PColor c = _colors.get(i);buffer.append("* colornum      = ").append(i).append('\n');buffer.append(c);buffer.append("

// Translation:
public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append("  red           = ").Append(_red & 0xff).Append('\n');buffer.Append("  green         = ").Append(_green & 0xff).Append('\n');buffer.Append("  blue          = ").Append(_blue & 0xff).Append('\n');return buffer.ToString();}
// Original:
public DocOffsetSorter(int maxDoc) {super(maxDoc / 64);this.tmpDocs = new int[maxDoc / 64];this.tmpOffsets = new long[maxDoc / 64];}

// Translation:
public DocOffsetSorter(int maxDoc): base(maxDoc / 64){this.tmpDocs = new int[maxDoc / 64];this.tmpOffsets = new long[maxDoc / 64];}
// Original:
public EnableInsightRulesResult enableInsightRules(EnableInsightRulesRequest request) {request = beforeClientExecution(request);return executeEnableInsightRules(request);}

// Translation:
public virtual EnableInsightRulesResponse EnableInsightRules(EnableInsightRulesRequest request){var options = new InvokeOptions();options.RequestMarshaller = EnableInsightRulesRequestMarshaller.Instance;options.ResponseUnmarshaller = EnableInsightRulesResponseUnmarshaller.Instance;return Invoke<EnableInsightRulesResponse>(request, options);}
// Original:
public boolean equals(Object obj) {if ( this==obj ) return true;if ( !(obj instanceof AND) ) return false;AND other = (AND)obj;return Arrays.equals(this.opnds, other.opnds);}

// Translation:
public override bool Equals(object obj){if (this == obj){return true;}if (!(obj is SemanticContext.AND)){return false;}SemanticContext.AND other = (SemanticContext.AND)obj;return Arrays.Equals(this.opnds, other.opnds);}
// Original:
public static int getEncodedSize(Ptg[] ptgs) {int result = 0;for (Ptg ptg : ptgs) {result += ptg.getSize();}return result;}

// Translation:
public static int GetEncodedSize(Ptg[] ptgs){int result = 0;for (int i = 0; i < ptgs.Length; i++){result += ptgs[i].Size;}return result;}
// Original:
public IterationRecord(boolean iterateOn) {_flags = iterationOn.setBoolean(0, iterateOn);}

// Translation:
public IterationRecord(bool iterateOn){_flags = iterationOn.SetBoolean(0, iterateOn);}
// Original:
public UnlinkIdentityResult unlinkIdentity(UnlinkIdentityRequest request) {request = beforeClientExecution(request);return executeUnlinkIdentity(request);}

// Translation:
public virtual UnlinkIdentityResponse UnlinkIdentity(UnlinkIdentityRequest request){var options = new InvokeOptions();options.RequestMarshaller = UnlinkIdentityRequestMarshaller.Instance;options.ResponseUnmarshaller = UnlinkIdentityResponseUnmarshaller.Instance;return Invoke<UnlinkIdentityResponse>(request, options);}
// Original:
public CreateThreatIntelSetResult createThreatIntelSet(CreateThreatIntelSetRequest request) {request = beforeClientExecution(request);return executeCreateThreatIntelSet(request);}

// Translation:
public virtual CreateThreatIntelSetResponse CreateThreatIntelSet(CreateThreatIntelSetRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateThreatIntelSetRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateThreatIntelSetResponseUnmarshaller.Instance;return Invoke<CreateThreatIntelSetResponse>(request, options);}
// Original:
public TokenizedPhraseQueryNode() {setLeaf(false);allocate();}

// Translation:
public TokenizedPhraseQueryNode(){IsLeaf = false;Allocate();}
// Original:
public DataItemRecord(RecordInputStream in) {isxvdData = in.readUShort();iiftab = in.readUShort();df = in.readUShort();isxvd = in.readUShort();isxvi = in.readUShort();ifmt = in.readUShort();name = in.readString();}

// Translation:
public DataItemRecord(RecordInputStream in1){isxvdData = in1.ReadUShort();iiftab = in1.ReadUShort();df = in1.ReadUShort();isxvd = in1.ReadUShort();isxvi = in1.ReadUShort();ifmt = in1.ReadUShort();name = in1.ReadString();}
// Original:
public DeleteDBParameterGroupResult deleteDBParameterGroup(DeleteDBParameterGroupRequest request) {request = beforeClientExecution(request);return executeDeleteDBParameterGroup(request);}

// Translation:
public virtual DeleteDBParameterGroupResponse DeleteDBParameterGroup(DeleteDBParameterGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteDBParameterGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteDBParameterGroupResponseUnmarshaller.Instance;return Invoke<DeleteDBParameterGroupResponse>(request, options);}
// Original:
public GetReservedNodeExchangeOfferingsResult getReservedNodeExchangeOfferings(GetReservedNodeExchangeOfferingsRequest request) {request = beforeClientExecution(request);return executeGetReservedNodeExchangeOfferings(request);}

// Translation:
public virtual GetReservedNodeExchangeOfferingsResponse GetReservedNodeExchangeOfferings(GetReservedNodeExchangeOfferingsRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetReservedNodeExchangeOfferingsRequestMarshaller.Instance;options.ResponseUnmarshaller = GetReservedNodeExchangeOfferingsResponseUnmarshaller.Instance;return Invoke<GetReservedNodeExchangeOfferingsResponse>(request, options);}
// Original:
public static long nextHighestPowerOfTwo(long v) {v--;v |= v >> 1;v |= v >> 2;v |= v >> 4;v |= v >> 8;v |= v >> 16;v |= v >> 32;v++;return v;}

// Translation:
public static int NextHighestPowerOfTwo(int v){v--;v |= v >> 1;v |= v >> 2;v |= v >> 4;v |= v >> 8;v |= v >> 16;v++;return v;}
// Original:
public RunInstancesResult runInstances(RunInstancesRequest request) {request = beforeClientExecution(request);return executeRunInstances(request);}

// Translation:
public virtual RunInstancesResponse RunInstances(RunInstancesRequest request){var options = new InvokeOptions();options.RequestMarshaller = RunInstancesRequestMarshaller.Instance;options.ResponseUnmarshaller = RunInstancesResponseUnmarshaller.Instance;return Invoke<RunInstancesResponse>(request, options);}
// Original:
public ChangeMessageVisibilityBatchResult changeMessageVisibilityBatch(String queueUrl, java.util.List<ChangeMessageVisibilityBatchRequestEntry> entries) {return changeMessageVisibilityBatch(new ChangeMessageVisibilityBatchRequest().withQueueUrl(queueUrl).withEntries(entries));}

// Translation:
public virtual ChangeMessageVisibilityBatchResponse ChangeMessageVisibilityBatch(string queueUrl, List<ChangeMessageVisibilityBatchRequestEntry> entries){var request = new ChangeMessageVisibilityBatchRequest();request.QueueUrl = queueUrl;request.Entries = entries;return ChangeMessageVisibilityBatch(request);}
// Original:
public DeleteRealtimeEndpointResult deleteRealtimeEndpoint(DeleteRealtimeEndpointRequest request) {request = beforeClientExecution(request);return executeDeleteRealtimeEndpoint(request);}

// Translation:
public virtual DeleteRealtimeEndpointResponse DeleteRealtimeEndpoint(DeleteRealtimeEndpointRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteRealtimeEndpointRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteRealtimeEndpointResponseUnmarshaller.Instance;return Invoke<DeleteRealtimeEndpointResponse>(request, options);}
// Original:
public CreateDiskSnapshotResult createDiskSnapshot(CreateDiskSnapshotRequest request) {request = beforeClientExecution(request);return executeCreateDiskSnapshot(request);}

// Translation:
public virtual CreateDiskSnapshotResponse CreateDiskSnapshot(CreateDiskSnapshotRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateDiskSnapshotRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateDiskSnapshotResponseUnmarshaller.Instance;return Invoke<CreateDiskSnapshotResponse>(request, options);}
// Original:
public void mark(int readLimit) throws IOException {if (readLimit < 0) {throw new IllegalArgumentException();}synchronized (lock) {checkNotClosed();markpos = pos;}}

// Translation:
public override void mark(int readLimit){if (readLimit < 0){throw new System.ArgumentException();}lock (@lock){checkNotClosed();markpos = pos;}}
// Original:
public TokenStream create(TokenStream input) {return new ICUNormalizer2Filter(input, normalizer);}

// Translation:
public override TokenStream Create(TokenStream input){return new ICUNormalizer2Filter(input, normalizer);}
// Original:
public ModifyImageAttributeResult modifyImageAttribute(ModifyImageAttributeRequest request) {request = beforeClientExecution(request);return executeModifyImageAttribute(request);}

// Translation:
public virtual ModifyImageAttributeResponse ModifyImageAttribute(ModifyImageAttributeRequest request){var options = new InvokeOptions();options.RequestMarshaller = ModifyImageAttributeRequestMarshaller.Instance;options.ResponseUnmarshaller = ModifyImageAttributeResponseUnmarshaller.Instance;return Invoke<ModifyImageAttributeResponse>(request, options);}
// Original:
public DescribeClusterSubnetGroupsResult describeClusterSubnetGroups(DescribeClusterSubnetGroupsRequest request) {request = beforeClientExecution(request);return executeDescribeClusterSubnetGroups(request);}

// Translation:
public virtual DescribeClusterSubnetGroupsResponse DescribeClusterSubnetGroups(DescribeClusterSubnetGroupsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeClusterSubnetGroupsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeClusterSubnetGroupsResponseUnmarshaller.Instance;return Invoke<DescribeClusterSubnetGroupsResponse>(request, options);}
// Original:
public StopQueryExecutionResult stopQueryExecution(StopQueryExecutionRequest request) {request = beforeClientExecution(request);return executeStopQueryExecution(request);}

// Translation:
public virtual StopQueryExecutionResponse StopQueryExecution(StopQueryExecutionRequest request){var options = new InvokeOptions();options.RequestMarshaller = StopQueryExecutionRequestMarshaller.Instance;options.ResponseUnmarshaller = StopQueryExecutionResponseUnmarshaller.Instance;return Invoke<StopQueryExecutionResponse>(request, options);}
// Original:
public UpdateUserInfoRequest() {super("cr", "2016-06-07", "UpdateUserInfo", "cr");setUriPattern("/users");setMethod(MethodType.POST);}

// Translation:
public UpdateUserInfoRequest(): base("cr", "2016-06-07", "UpdateUserInfo", "cr", "openAPI"){UriPattern = "/users";Method = MethodType.POST;}
// Original:
public DiscoverInputSchemaResult discoverInputSchema(DiscoverInputSchemaRequest request) {request = beforeClientExecution(request);return executeDiscoverInputSchema(request);}

// Translation:
public virtual DiscoverInputSchemaResponse DiscoverInputSchema(DiscoverInputSchemaRequest request){var options = new InvokeOptions();options.RequestMarshaller = DiscoverInputSchemaRequestMarshaller.Instance;options.ResponseUnmarshaller = DiscoverInputSchemaResponseUnmarshaller.Instance;return Invoke<DiscoverInputSchemaResponse>(request, options);}
// Original:
public GetEnvironmentResult getEnvironment(GetEnvironmentRequest request) {request = beforeClientExecution(request);return executeGetEnvironment(request);}

// Translation:
public virtual GetEnvironmentResponse GetEnvironment(GetEnvironmentRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetEnvironmentRequestMarshaller.Instance;options.ResponseUnmarshaller = GetEnvironmentResponseUnmarshaller.Instance;return Invoke<GetEnvironmentResponse>(request, options);}
// Original:
public UpdateCondition(String name, String value, Boolean exists) {setName(name);setValue(value);setExists(exists);}

// Translation:
public UpdateCondition(string name, string value, bool exists){_name = name;_value = value;_exists = exists;}
// Original:
public void serialize(LittleEndianOutput out) {out.writeShort(getCalcMode());}

// Translation:
public override void Serialize(ILittleEndianOutput out1){out1.WriteShort(GetCalcMode());}
// Original:
public AmazonS3EncryptionClient(EncryptionMaterials encryptionMaterials) {this(new StaticEncryptionMaterialsProvider(encryptionMaterials));}

// Translation:
public AmazonS3EncryptionClient(EncryptionMaterials materials): base(){this.EncryptionMaterials = materials;S3CryptoConfig = new AmazonS3CryptoConfiguration();}
// Original:
public void addRule(ConditionalFormattingRule cfRule){addRule((HSSFConditionalFormattingRule)cfRule);}

// Translation:
public void AddRule(HSSFConditionalFormattingRule cfRule){cfAggregate.AddRule(cfRule.CfRuleRecord);}
// Original:
public Iterator<E> descendingIterator() {return descendingSet().iterator();}

// Translation:
public virtual java.util.Iterator<E> descendingIterator(){return descendingSet().iterator();}
// Original:
public DescribeSubnetGroupsResult describeSubnetGroups(DescribeSubnetGroupsRequest request) {request = beforeClientExecution(request);return executeDescribeSubnetGroups(request);}

// Translation:
public virtual DescribeSubnetGroupsResponse DescribeSubnetGroups(DescribeSubnetGroupsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeSubnetGroupsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeSubnetGroupsResponseUnmarshaller.Instance;return Invoke<DescribeSubnetGroupsResponse>(request, options);}
// Original:
public void append(String name, RevBlob blob) {append(name, REGULAR_FILE, blob);}

// Translation:
public virtual void Append(string name, RevTree tree){Append(name, FileMode.TREE, tree);}
// Original:
public NavigableMap<K, V> subMap(K from, boolean fromInclusive, K to, boolean toInclusive) {Bound fromBound = fromInclusive ? INCLUSIVE : EXCLUSIVE;Bound toBound = toInclusive ? INCLUSIVE : EXCLUSIVE;return subMap(from, fromBound, to, toBound);}

// Translation:
public java.util.NavigableMap<K, V> subMap(K from, bool fromInclusive, K to, booltoInclusive){java.util.TreeMap.Bound fromBound = fromInclusive ? java.util.TreeMap.Bound.INCLUSIVE: java.util.TreeMap.Bound.EXCLUSIVE;java.util.TreeMap.Bound toBound = toInclusive ? java.util.TreeMap.Bound.INCLUSIVE: java.util.TreeMap.Bound.EXCLUSIVE;return this.subMap(from, fromBound, to, toBound);}