yijunyu/c-to-rust huggingface dataset:
// Original:
public GetMirrorListRequest() {super("cr", "2016-06-07", "GetMirrorList", "cr");setUriPattern("/mirrors");setMethod(MethodType.GET);}

// Translation:
public GetMirrorListRequest(): base("cr", "2016-06-07", "GetMirrorList", "cr", "openAPI"){UriPattern = "/mirrors";Method = MethodType.GET;}
// Original:
public DescribeDomainEndpointOptionsResult describeDomainEndpointOptions(DescribeDomainEndpointOptionsRequest request) {request = beforeClientExecution(request);return executeDescribeDomainEndpointOptions(request);}

// Translation:
public virtual DescribeDomainEndpointOptionsResponse DescribeDomainEndpointOptions(DescribeDomainEndpointOptionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeDomainEndpointOptionsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeDomainEndpointOptionsResponseUnmarshaller.Instance;return Invoke<DescribeDomainEndpointOptionsResponse>(request, options);}
// Original:
public CommonToken(Pair<TokenSource, CharStream> source, int type, int channel, int start, int stop) {this.source = source;this.type = type;this.channel = channel;this.start = start;this.stop = stop;if (source.a != null) {this.line = source.a.getLine();this.charPositionInLine = source.a.getCharPositionInLine();}}

// Translation:
public CommonToken(Tuple<ITokenSource, ICharStream> source, int type, int channel, int start, int stop){this.source = source;this._type = type;this._channel = channel;this.start = start;this.stop = stop;if (source.Item1 != null){this._line = source.Item1.Line;this.charPositionInLine = source.Item1.Column;}}
// Original:
public boolean get(URIish uri, CredentialItem... items)throws UnsupportedCredentialItem {for (CredentialItem i : items) {if (i instanceof CredentialItem.Username) {((CredentialItem.Username) i).setValue(username);continue;}if (i instanceof CredentialItem.Password) {((CredentialItem.Password) i).setValue(password);continue;}if (i instanceof CredentialItem.StringType) {if (i.getPromptText().equals("Password: ")) { ((CredentialItem.StringType) i).setValue(new String(password));continue;}}throw new UnsupportedCredentialItem(uri, i.getClass().getName()+ ":" + i.getPromptText()); }return true;}

// Translation:
public override bool Get(URIish uri, params CredentialItem[] items){foreach (CredentialItem i in items){if (i is CredentialItem.Username){((CredentialItem.Username)i).SetValue(username);continue;}if (i is CredentialItem.Password){((CredentialItem.Password)i).SetValue(password);continue;}if (i is CredentialItem.StringType){if (i.GetPromptText().Equals("Password: ")){((CredentialItem.StringType)i).SetValue(new string(password));continue;}}throw new UnsupportedCredentialItem(uri, i.GetType().FullName + ":" + i.GetPromptText());}return true;}
// Original:
public boolean get(String name, boolean dflt) {boolean vals[] = (boolean[]) valByRound.get(name);if (vals != null) {return vals[roundNumber % vals.length];}String sval = props.getProperty(name, "" + dflt);if (sval.indexOf(":") < 0) {return Boolean.valueOf(sval).booleanValue();}int k = sval.indexOf(":");String colName = sval.substring(0, k);sval = sval.substring(k + 1);colForValByRound.put(name, colName);vals = propToBooleanArray(sval);valByRound.put(name, vals);return vals[roundNumber % vals.length];}

// Translation:
public virtual double Get(string name, double dflt){double[] vals;object temp;if (valByRound.TryGetValue(name, out temp) && temp != null){vals = (double[])temp;return vals[roundNumber % vals.Length];}string sval;if (!props.TryGetValue(name, out sval)){sval = dflt.ToString(CultureInfo.InvariantCulture);}if (sval.IndexOf(':') < 0){return double.Parse(sval, CultureInfo.InvariantCulture);}int k = sval.IndexOf(':');string colName = sval.Substring(0, k - 0);sval = sval.Substring(k + 1);colForValByRound[name] = colName;vals = PropToDoubleArray(sval);valByRound[name] = vals;return vals[roundNumber % vals.Length];}
// Original:
public UpdateDocumentationVersionResult updateDocumentationVersion(UpdateDocumentationVersionRequest request) {request = beforeClientExecution(request);return executeUpdateDocumentationVersion(request);}

// Translation:
public virtual UpdateDocumentationVersionResponse UpdateDocumentationVersion(UpdateDocumentationVersionRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateDocumentationVersionRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateDocumentationVersionResponseUnmarshaller.Instance;return Invoke<UpdateDocumentationVersionResponse>(request, options);}
// Original:
public DeleteApplicationInputProcessingConfigurationResult deleteApplicationInputProcessingConfiguration(DeleteApplicationInputProcessingConfigurationRequest request) {request = beforeClientExecution(request);return executeDeleteApplicationInputProcessingConfiguration(request);}

// Translation:
public virtual DeleteApplicationInputProcessingConfigurationResponse DeleteApplicationInputProcessingConfiguration(DeleteApplicationInputProcessingConfigurationRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteApplicationInputProcessingConfigurationRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteApplicationInputProcessingConfigurationResponseUnmarshaller.Instance;return Invoke<DeleteApplicationInputProcessingConfigurationResponse>(request, options);}
// Original:
public PurchaseScheduledInstancesResult purchaseScheduledInstances(PurchaseScheduledInstancesRequest request) {request = beforeClientExecution(request);return executePurchaseScheduledInstances(request);}

// Translation:
public virtual PurchaseScheduledInstancesResponse PurchaseScheduledInstances(PurchaseScheduledInstancesRequest request){var options = new InvokeOptions();options.RequestMarshaller = PurchaseScheduledInstancesRequestMarshaller.Instance;options.ResponseUnmarshaller = PurchaseScheduledInstancesResponseUnmarshaller.Instance;return Invoke<PurchaseScheduledInstancesResponse>(request, options);}
// Original:
public String getHost() {return host;}

// Translation:
public virtual string GetHost(){return host;}
// Original:
public DeleteNetworkProfileResult deleteNetworkProfile(DeleteNetworkProfileRequest request) {request = beforeClientExecution(request);return executeDeleteNetworkProfile(request);}

// Translation:
public virtual DeleteNetworkProfileResponse DeleteNetworkProfile(DeleteNetworkProfileRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteNetworkProfileRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteNetworkProfileResponseUnmarshaller.Instance;return Invoke<DeleteNetworkProfileResponse>(request, options);}
// Original:
public ListSchemasResult listSchemas(ListSchemasRequest request) {request = beforeClientExecution(request);return executeListSchemas(request);}

// Translation:
public virtual ListSchemasResponse ListSchemas(ListSchemasRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListSchemasRequestMarshaller.Instance;options.ResponseUnmarshaller = ListSchemasResponseUnmarshaller.Instance;return Invoke<ListSchemasResponse>(request, options);}
// Original:
public void write(LittleEndianOutput out) {out.writeByte(sid + getPtgClass());out.writeShort(field_1_first_row);out.writeShort(field_2_first_col);}

// Translation:
public override void Write(ILittleEndianOutput out1){out1.WriteByte(sid + PtgClass);out1.WriteShort(field_1_first_row);out1.WriteShort(field_2_first_col);}
// Original:
public ByteSliceWriter(ByteBlockPool pool) {this.pool = pool;}

// Translation:
public ByteSliceWriter(ByteBlockPool pool){this.pool = pool;}
// Original:
public void replace(int start, int limit, char[] text, int charsStart,int charsLen) {final int newLength = shiftForReplace(start, limit, charsLen);System.arraycopy(text, charsStart, buffer, start, charsLen);token.setLength(length = newLength);}

// Translation:
public void Replace(int start, int length, char[] text, int charsStart,int charsLen){int newLength = ShiftForReplace(start, length + start, charsLen); System.Array.Copy(text, charsStart, buffer, start, charsLen);token.Length = (this.length = newLength);}
// Original:
public synchronized void getChars(int start, int end, char[] buffer, int idx) {super.getChars(start, end, buffer, idx);}

// Translation:
public override void getChars(int start, int end, char[] buffer, int idx){lock (this){base.getChars(start, end, buffer, idx);}}
// Original:
public RestoreAddressToClassicResult restoreAddressToClassic(RestoreAddressToClassicRequest request) {request = beforeClientExecution(request);return executeRestoreAddressToClassic(request);}

// Translation:
public virtual RestoreAddressToClassicResponse RestoreAddressToClassic(RestoreAddressToClassicRequest request){var options = new InvokeOptions();options.RequestMarshaller = RestoreAddressToClassicRequestMarshaller.Instance;options.ResponseUnmarshaller = RestoreAddressToClassicResponseUnmarshaller.Instance;return Invoke<RestoreAddressToClassicResponse>(request, options);}
// Original:
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {for (int j = 0; j < iterations; ++j) {values[valuesOffset++] = ((blocks[blocksOffset++] & 0xFFL) << 8) | (blocks[blocksOffset++] & 0xFFL);}}

// Translation:
public override void Decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations){for (int j = 0; j < iterations; ++j){values[valuesOffset++] = ((blocks[blocksOffset++] & 0xFFL) << 8) | (blocks[blocksOffset++] & 0xFFL);}}
// Original:
public CreateNamespaceRequest() {super("cr", "2016-06-07", "CreateNamespace", "cr");setUriPattern("/namespace");setMethod(MethodType.PUT);}

// Translation:
public CreateNamespaceRequest(): base("cr", "2016-06-07", "CreateNamespace", "cr", "openAPI"){UriPattern = "/namespace";Method = MethodType.PUT;}
// Original:
public ShortBuffer compact() {System.arraycopy(backingArray, position + offset, backingArray, offset, remaining());position = limit - position;limit = capacity;mark = UNSET_MARK;return this;}

// Translation:
public override java.nio.ShortBuffer compact(){System.Array.Copy(backingArray, _position + offset, backingArray, offset, remaining());_position = _limit - _position;_limit = _capacity;_mark = UNSET_MARK;return this;}
// Original:
public GetEventsConfigurationResult getEventsConfiguration(GetEventsConfigurationRequest request) {request = beforeClientExecution(request);return executeGetEventsConfiguration(request);}

// Translation:
public virtual GetEventsConfigurationResponse GetEventsConfiguration(GetEventsConfigurationRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetEventsConfigurationRequestMarshaller.Instance;options.ResponseUnmarshaller = GetEventsConfigurationResponseUnmarshaller.Instance;return Invoke<GetEventsConfigurationResponse>(request, options);}
// Original:
public String toString() {return "docFreq=" + docFreq + " totalTermFreq=" + totalTermFreq + " termBlockOrd=" + termBlockOrd + " blockFP=" + blockFilePointer;}

// Translation:
public override string ToString(){return "docFreq=" + DocFreq + " totalTermFreq=" + TotalTermFreq + " termBlockOrd=" + TermBlockOrd + " blockFP=" + BlockFilePointer;}
// Original:
public EstimateTemplateCostResult estimateTemplateCost(EstimateTemplateCostRequest request) {request = beforeClientExecution(request);return executeEstimateTemplateCost(request);}

// Translation:
public virtual EstimateTemplateCostResponse EstimateTemplateCost(EstimateTemplateCostRequest request){var options = new InvokeOptions();options.RequestMarshaller = EstimateTemplateCostRequestMarshaller.Instance;options.ResponseUnmarshaller = EstimateTemplateCostResponseUnmarshaller.Instance;return Invoke<EstimateTemplateCostResponse>(request, options);}
// Original:
public TreeFilter clone() {return new Binary(a.clone(), b.clone());}

// Translation:
public override TreeFilter Clone(){return new OrTreeFilter.Binary(a.Clone(), b.Clone());}
// Original:
public ValueEval evaluate(ValueEval[] args, int srcRowIndex, int srcColumnIndex) {switch (args.length) {case 1:return evaluate(srcRowIndex, srcColumnIndex, args[0]);case 0:return new NumberEval(srcColumnIndex+1);}return ErrorEval.VALUE_INVALID;}

// Translation:
public ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0){int rnum;if (arg0 is AreaEval){rnum = ((AreaEval)arg0).FirstColumn;}else if (arg0 is RefEval){rnum = ((RefEval)arg0).Column;}else{return ErrorEval.VALUE_INVALID;}return new NumberEval(rnum + 1);}
// Original:
public ByteOrder order() {return ByteOrder.nativeOrder();}

// Translation:
public override java.nio.ByteOrder order(){return java.nio.ByteOrder.nativeOrder();}
// Original:
public void insert(char[] key, int start, char val) {int len = strlen(key) + 1;if (freenode + len > eq.length) {redimNodeArrays(eq.length + BLOCK_SIZE);}root = insert(root, key, start, val);}

// Translation:
public virtual void Insert(char[] key, int start, char val){int len = StrLen(key) + 1;if (m_freenode + len > m_eq.Length){RedimNodeArrays(m_eq.Length + BLOCK_SIZE);}m_root = Insert(m_root, key, start, val);}
// Original:
public final DFAState getPrecedenceStartState(int precedence) {if (!isPrecedenceDfa()) {throw new IllegalStateException("Only precedence DFAs may contain a precedence start state.");}if (precedence < 0 || precedence >= s0.edges.length) {return null;}return s0.edges[precedence];}

// Translation:
public DFAState GetPrecedenceStartState(int precedence){if (!IsPrecedenceDfa){throw new Exception("Only precedence DFAs may contain a precedence start state.");}if (precedence < 0 || precedence >= s0.edges.Length){return null;}return s0.edges[precedence];}
// Original:
public SetActiveReceiptRuleSetResult setActiveReceiptRuleSet(SetActiveReceiptRuleSetRequest request) {request = beforeClientExecution(request);return executeSetActiveReceiptRuleSet(request);}

// Translation:
public virtual SetActiveReceiptRuleSetResponse SetActiveReceiptRuleSet(SetActiveReceiptRuleSetRequest request){var options = new InvokeOptions();options.RequestMarshaller = SetActiveReceiptRuleSetRequestMarshaller.Instance;options.ResponseUnmarshaller = SetActiveReceiptRuleSetResponseUnmarshaller.Instance;return Invoke<SetActiveReceiptRuleSetResponse>(request, options);}
// Original:
public CreateLaunchTemplateResult createLaunchTemplate(CreateLaunchTemplateRequest request) {request = beforeClientExecution(request);return executeCreateLaunchTemplate(request);}

// Translation:
public virtual CreateLaunchTemplateResponse CreateLaunchTemplate(CreateLaunchTemplateRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateLaunchTemplateRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateLaunchTemplateResponseUnmarshaller.Instance;return Invoke<CreateLaunchTemplateResponse>(request, options);}
// Original:
public ListTrafficPolicyVersionsResult listTrafficPolicyVersions(ListTrafficPolicyVersionsRequest request) {request = beforeClientExecution(request);return executeListTrafficPolicyVersions(request);}

// Translation:
public virtual ListTrafficPolicyVersionsResponse ListTrafficPolicyVersions(ListTrafficPolicyVersionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListTrafficPolicyVersionsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListTrafficPolicyVersionsResponseUnmarshaller.Instance;return Invoke<ListTrafficPolicyVersionsResponse>(request, options);}
// Original:
public Locale effectiveLocale() {return effectiveLocale;}

// Translation:
public virtual CultureInfo EffectiveLocale(){return effectiveLocale;}
// Original:
public void encode(long[] values, int valuesOffset, long[] blocks,int blocksOffset, int iterations) {for (int i = 0; i < iterations; ++i) {blocks[blocksOffset++] = encode(values, valuesOffset);valuesOffset += valueCount;}}

// Translation:
public override void Encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations){for (int i = 0; i < iterations; ++i){blocks[blocksOffset++] = Encode(values, valuesOffset);valuesOffset += valueCount;}}
// Original:
public static String revisionVersion(IndexCommit commit) {return Long.toString(commit.getGeneration(), RADIX);}

// Translation:
public static string RevisionVersion(IndexCommit commit){return commit.Generation.ToString("X");}
// Original:
public ListServicesResult listServices(ListServicesRequest request) {request = beforeClientExecution(request);return executeListServices(request);}

// Translation:
public virtual ListServicesResponse ListServices(ListServicesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListServicesRequestMarshaller.Instance;options.ResponseUnmarshaller = ListServicesResponseUnmarshaller.Instance;return Invoke<ListServicesResponse>(request, options);}
// Original:
public BatchModifyClusterSnapshotsResult batchModifyClusterSnapshots(BatchModifyClusterSnapshotsRequest request) {request = beforeClientExecution(request);return executeBatchModifyClusterSnapshots(request);}

// Translation:
public virtual BatchModifyClusterSnapshotsResponse BatchModifyClusterSnapshots(BatchModifyClusterSnapshotsRequest request){var options = new InvokeOptions();options.RequestMarshaller = BatchModifyClusterSnapshotsRequestMarshaller.Instance;options.ResponseUnmarshaller = BatchModifyClusterSnapshotsResponseUnmarshaller.Instance;return Invoke<BatchModifyClusterSnapshotsResponse>(request, options);}
// Original:
public DeleteBackupResult deleteBackup(DeleteBackupRequest request) {request = beforeClientExecution(request);return executeDeleteBackup(request);}

// Translation:
public virtual DeleteBackupResponse DeleteBackup(DeleteBackupRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteBackupRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteBackupResponseUnmarshaller.Instance;return Invoke<DeleteBackupResponse>(request, options);}
// Original:
public DescribeDBParameterGroupsResult describeDBParameterGroups() {return describeDBParameterGroups(new DescribeDBParameterGroupsRequest());}

// Translation:
public virtual DescribeDBParameterGroupsResponse DescribeDBParameterGroups(){return DescribeDBParameterGroups(new DescribeDBParameterGroupsRequest());}
// Original:
public void reset(boolean zeroFillBuffers, boolean reuseFirst) {if (bufferUpto != -1) {if (zeroFillBuffers) {for(int i=0;i<bufferUpto;i++) {Arrays.fill(buffers[i], 0);}Arrays.fill(buffers[bufferUpto], 0, intUpto, 0);}if (bufferUpto > 0 || !reuseFirst) {final int offset = reuseFirst ? 1 : 0;allocator.recycleIntBlocks(buffers, offset, 1+bufferUpto);Arrays.fill(buffers, offset, bufferUpto+1, null);}if (reuseFirst) {bufferUpto = 0;intUpto = 0;intOffset = 0;buffer = buffers[0];} else {bufferUpto = -1;intUpto = INT_BLOCK_SIZE;intOffset = -INT_BLOCK_SIZE;buffer = null;}}}

// Translation:
public void Reset(bool zeroFillBuffers, bool reuseFirst){if (bufferUpto != -1){if (zeroFillBuffers){for (int i = 0; i < bufferUpto; i++){Arrays.Fill(buffers[i], 0);}Arrays.Fill(buffers[bufferUpto], 0, Int32Upto, 0);}if (bufferUpto > 0 || !reuseFirst){int offset = reuseFirst ? 1 : 0;allocator.RecycleInt32Blocks(buffers, offset, 1 + bufferUpto);Arrays.Fill(buffers, offset, bufferUpto + 1, null);}if (reuseFirst){bufferUpto = 0;Int32Upto = 0;Int32Offset = 0;buffer = buffers[0];}else{bufferUpto = -1;Int32Upto = INT32_BLOCK_SIZE;Int32Offset = -INT32_BLOCK_SIZE;buffer = null;}}}
// Original:
public SaveRecalcRecord clone() {return copy();}

// Translation:
public override Object Clone(){SaveRecalcRecord rec = new SaveRecalcRecord();rec.field_1_recalc = field_1_recalc;return rec;}
// Original:
public static void main(String[] args) {exec(args);}

// Translation:
public static void Main(string[] args){Exec(args);}
// Original:
public DeregisterImageResult deregisterImage(DeregisterImageRequest request) {request = beforeClientExecution(request);return executeDeregisterImage(request);}

// Translation:
public virtual DeregisterImageResponse DeregisterImage(DeregisterImageRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeregisterImageRequestMarshaller.Instance;options.ResponseUnmarshaller = DeregisterImageResponseUnmarshaller.Instance;return Invoke<DeregisterImageResponse>(request, options);}
// Original:
public DBSnapshot modifyDBSnapshot(ModifyDBSnapshotRequest request) {request = beforeClientExecution(request);return executeModifyDBSnapshot(request);}

// Translation:
public virtual ModifyDBSnapshotResponse ModifyDBSnapshot(ModifyDBSnapshotRequest request){var options = new InvokeOptions();options.RequestMarshaller = ModifyDBSnapshotRequestMarshaller.Instance;options.ResponseUnmarshaller = ModifyDBSnapshotResponseUnmarshaller.Instance;return Invoke<ModifyDBSnapshotResponse>(request, options);}
// Original:
public String toString() {StringBuilder buffer = new StringBuilder();buffer.append("[BOUNDSHEET]\n");buffer.append("    .bof        = ").append(HexDump.intToHex(getPositionOfBof())).append("\n");buffer.append("    .options    = ").append(HexDump.shortToHex(field_2_option_flags)).append("\n");buffer.append("    .unicodeflag= ").append(HexDump.byteToHex(field_4_isMultibyteUnicode)).append("\n");buffer.append("    .sheetname  = ").append(field_5_sheetname).append("\n");buffer.append("[/BOUNDSHEET]\n");return buffer.toString();}

// Translation:
public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append("[BOUNDSHEET]\n");buffer.Append("    .bof        = ").Append(HexDump.IntToHex(PositionOfBof)).Append("\n");buffer.Append("    .options    = ").Append(HexDump.ShortToHex(field_2_option_flags)).Append("\n");buffer.Append("    .unicodeflag= ").Append(HexDump.ByteToHex(field_4_isMultibyteUnicode)).Append("\n");buffer.Append("    .sheetname  = ").Append(field_5_sheetname).Append("\n");buffer.Append("[/BOUNDSHEET]\n");return buffer.ToString();}
// Original:
public void setParams(String params) {this.params = params; fieldsToLoad = new HashSet<>();for (StringTokenizer tokenizer = new StringTokenizer(params, ","); tokenizer.hasMoreTokens();) {String s = tokenizer.nextToken();fieldsToLoad.add(s);}}

// Translation:
public override void SetParams(string @params){this.m_params = @params; m_fieldsToLoad = new JCG.HashSet<string>();for (StringTokenizer tokenizer = new StringTokenizer(@params, ","); tokenizer.MoveNext();){string s = tokenizer.Current;m_fieldsToLoad.Add(s);}}
// Original:
public GetNamedQueryResult getNamedQuery(GetNamedQueryRequest request) {request = beforeClientExecution(request);return executeGetNamedQuery(request);}

// Translation:
public virtual GetNamedQueryResponse GetNamedQuery(GetNamedQueryRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetNamedQueryRequestMarshaller.Instance;options.ResponseUnmarshaller = GetNamedQueryResponseUnmarshaller.Instance;return Invoke<GetNamedQueryResponse>(request, options);}
// Original:
public GermanStemFilter create(TokenStream in) {return new GermanStemFilter(in);}

// Translation:
public override TokenStream Create(TokenStream @in){return new GermanStemFilter(@in);}
// Original:
public ExtendedFormatRecord createCellXF() {ExtendedFormatRecord xf = createExtendedFormat();records.add(records.getXfpos()+1, xf);records.setXfpos( records.getXfpos() + 1 );numxfs++;return xf;}

// Translation:
public ExtendedFormatRecord CreateCellXF(){ExtendedFormatRecord xf = CreateExtendedFormat();records.Add(records.Xfpos + 1, xf);records.Xfpos=records.Xfpos + 1;numxfs++;return xf;}
// Original:
public Cluster modifyClusterMaintenance(ModifyClusterMaintenanceRequest request) {request = beforeClientExecution(request);return executeModifyClusterMaintenance(request);}

// Translation:
public virtual ModifyClusterMaintenanceResponse ModifyClusterMaintenance(ModifyClusterMaintenanceRequest request){var options = new InvokeOptions();options.RequestMarshaller = ModifyClusterMaintenanceRequestMarshaller.Instance;options.ResponseUnmarshaller = ModifyClusterMaintenanceResponseUnmarshaller.Instance;return Invoke<ModifyClusterMaintenanceResponse>(request, options);}