yijunyu/c-to-rust huggingface dataset:
// Original:
public void map(K key, V value) {List<V> elementsForKey = get(key);if ( elementsForKey==null ) {elementsForKey = new ArrayList<V>();super.put(key, elementsForKey);}elementsForKey.add(value);}

// Translation:
public virtual void Map(K key, V value){IList<V> elementsForKey;if (!TryGetValue(key, out elementsForKey)){elementsForKey = new ArrayList<V>();this[key] = elementsForKey;}elementsForKey.Add(value);}
// Original:
public DescribeImportSnapshotTasksResult describeImportSnapshotTasks(DescribeImportSnapshotTasksRequest request) {request = beforeClientExecution(request);return executeDescribeImportSnapshotTasks(request);}

// Translation:
public virtual DescribeImportSnapshotTasksResponse DescribeImportSnapshotTasks(DescribeImportSnapshotTasksRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeImportSnapshotTasksRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeImportSnapshotTasksResponseUnmarshaller.Instance;return Invoke<DescribeImportSnapshotTasksResponse>(request, options);}
// Original:
public ListEventSourcesResult listEventSources(ListEventSourcesRequest request) {request = beforeClientExecution(request);return executeListEventSources(request);}

// Translation:
public virtual ListEventSourcesResponse ListEventSources(ListEventSourcesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListEventSourcesRequestMarshaller.Instance;options.ResponseUnmarshaller = ListEventSourcesResponseUnmarshaller.Instance;return Invoke<ListEventSourcesResponse>(request, options);}
// Original:
public static double getExcelDate(Calendar date, boolean use1904windowing) {int year = date.get(Calendar.YEAR);int dayOfYear = date.get(Calendar.DAY_OF_YEAR);int hour = date.get(Calendar.HOUR_OF_DAY);int minute = date.get(Calendar.MINUTE);int second = date.get(Calendar.SECOND);int milliSecond = date.get(Calendar.MILLISECOND);return internalGetExcelDate(year, dayOfYear, hour, minute, second, milliSecond, use1904windowing);}

// Translation:
public static double GetExcelDate(DateTime date, bool use1904windowing){if ((!use1904windowing && date.Year < 1900)  || (use1904windowing && date.Year < 1904))   {return BAD_DATE;}DateTime startdate;if (use1904windowing){startdate = new DateTime(1904, 1, 1);}else{startdate = new DateTime(1900, 1, 1);}double value = (date - startdate).TotalDays + 1;if (!use1904windowing && value >= 60){value++;}else if (use1904windowing){value--;}return value;}
// Original:
public TimeSpec(char type, int pos, int len, double factor) {this.type = type;this.pos = pos;this.len = len;this.factor = factor;modBy = 0;}

// Translation:
public TimeSpec(char type, int pos, int len, double factor){this.type = type;this.pos = pos;this.len = len;this.factor = factor;modBy = 0;}
// Original:
public DeleteApiMappingResult deleteApiMapping(DeleteApiMappingRequest request) {request = beforeClientExecution(request);return executeDeleteApiMapping(request);}

// Translation:
public virtual DeleteApiMappingResponse DeleteApiMapping(DeleteApiMappingRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteApiMappingRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteApiMappingResponseUnmarshaller.Instance;return Invoke<DeleteApiMappingResponse>(request, options);}
// Original:
public static String typeString(int typeCode) {switch (typeCode) {case OBJ_COMMIT:return TYPE_COMMIT;case OBJ_TREE:return TYPE_TREE;case OBJ_BLOB:return TYPE_BLOB;case OBJ_TAG:return TYPE_TAG;default:throw new IllegalArgumentException(MessageFormat.format(JGitText.get().badObjectType, Integer.valueOf(typeCode)));}}

// Translation:
public static string TypeString(int typeCode){switch (typeCode){case OBJ_COMMIT:{return TYPE_COMMIT;}case OBJ_TREE:{return TYPE_TREE;}case OBJ_BLOB:{return TYPE_BLOB;}case OBJ_TAG:{return TYPE_TAG;}default:{throw new ArgumentException(MessageFormat.Format(JGitText.Get().badObjectType, Sharpen.Extensions.ValueOf(typeCode)));}}}
// Original:
public long addAndGet(long delta) {return count.addAndGet(delta);}

// Translation:
public override long AddAndGet(long delta){return count.AddAndGet(delta);}
// Original:
public String toString() {StringBuilder sb = new StringBuilder(super.toString());sb.append(" fields=");sb.append(Arrays.toString(fields));return sb.toString();}

// Translation:
public override string ToString(){StringBuilder sb = new StringBuilder(base.ToString());sb.Append(" fields=");sb.Append(Arrays.ToString(fields));return sb.ToString();}
// Original:
public UpdateTemplateActiveVersionResult updateTemplateActiveVersion(UpdateTemplateActiveVersionRequest request) {request = beforeClientExecution(request);return executeUpdateTemplateActiveVersion(request);}

// Translation:
public virtual UpdateTemplateActiveVersionResponse UpdateTemplateActiveVersion(UpdateTemplateActiveVersionRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateTemplateActiveVersionRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateTemplateActiveVersionResponseUnmarshaller.Instance;return Invoke<UpdateTemplateActiveVersionResponse>(request, options);}
// Original:
public int compareTo(FacetLabel other) {final int len = length < other.length ? length : other.length;for (int i = 0, j = 0; i < len; i++, j++) {int cmp = components[i].compareTo(other.components[j]);if (cmp < 0) {return -1; }if (cmp > 0) {return 1; }}return length - other.length;}

// Translation:
public virtual int CompareTo(FacetLabel other){int len = Length < other.Length ? Length : other.Length;for (int i = 0, j = 0; i < len; i++, j++){int cmp = Components[i].CompareToOrdinal(other.Components[j]);if (cmp < 0){return -1; }if (cmp > 0){return 1; }}return Length - other.Length;}
// Original:
public int find(String key) {int len = key.length();char strkey[] = new char[len + 1];key.getChars(0, len, strkey, 0);strkey[len] = 0;return find(strkey, 0);}

// Translation:
public virtual int Find(string key){int len = key.Length;char[] strkey = new char[len + 1];key.CopyTo(0, strkey, 0, len - 0);strkey[len] = (char)0;return Find(strkey, 0);}
// Original:
public final CharBuffer put(char[] src, int srcOffset, int charCount) {throw new ReadOnlyBufferException();}

// Translation:
public sealed override java.nio.CharBuffer put(char[] src, int srcOffset, int charCount){throw new java.nio.ReadOnlyBufferException();}
// Original:
public ListNodesResult listNodes(ListNodesRequest request) {request = beforeClientExecution(request);return executeListNodes(request);}

// Translation:
public virtual ListNodesResponse ListNodes(ListNodesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListNodesRequestMarshaller.Instance;options.ResponseUnmarshaller = ListNodesResponseUnmarshaller.Instance;return Invoke<ListNodesResponse>(request, options);}
// Original:
public DeleteVoiceConnectorStreamingConfigurationResult deleteVoiceConnectorStreamingConfiguration(DeleteVoiceConnectorStreamingConfigurationRequest request) {request = beforeClientExecution(request);return executeDeleteVoiceConnectorStreamingConfiguration(request);}

// Translation:
public virtual DeleteVoiceConnectorStreamingConfigurationResponse DeleteVoiceConnectorStreamingConfiguration(DeleteVoiceConnectorStreamingConfigurationRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteVoiceConnectorStreamingConfigurationRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteVoiceConnectorStreamingConfigurationResponseUnmarshaller.Instance;return Invoke<DeleteVoiceConnectorStreamingConfigurationResponse>(request, options);}
// Original:
public TokenStream create(TokenStream input) {return new SoraniNormalizationFilter(input);}

// Translation:
public override TokenStream Create(TokenStream input){return new SoraniNormalizationFilter(input);}
// Original:
public int following(int pos) {if (pos < start || pos > end) {throw new IllegalArgumentException("offset out of bounds");} else if (pos == end) {current = end;return DONE;} else {return last();}}

// Translation:
public override int Following(int pos){if (pos < start || pos > end){throw new ArgumentException("offset out of bounds");}else if (pos == end){current = end;return Done;}else{return Last();}}
// Original:
public SshSessionFactory getSshSessionFactory() {return sch;}

// Translation:
public virtual SshSessionFactory GetSshSessionFactory(){return sch;}
// Original:
@Override public boolean contains(Object o) {if (!(o instanceof Multiset.Entry)) {return false;}Multiset.Entry<?> entry = (Multiset.Entry<?>) o;Collection<V> collection = map.get(entry.getElement());return (collection != null) &&(collection.size() == entry.getCount());}

// Translation:
public override bool contains(object o){if (!(o is java.util.MapClass.Entry<K, V>)){return false;}java.util.MapClass.Entry<object, object> e = (java.util.MapClass.Entry<object, object>)o;return this._enclosing.containsMapping(e.getKey(), e.getValue());}
// Original:
public TokenFilter create(TokenStream input) {CommonGramsFilter commonGrams = new CommonGramsFilter(input, commonWords);return commonGrams;}

// Translation:
public override TokenStream Create(TokenStream input){var commonGrams = new CommonGramsFilter(m_luceneMatchVersion, input, commonWords);return commonGrams;}
// Original:
public DescribeWorkspaceImagesResult describeWorkspaceImages(DescribeWorkspaceImagesRequest request) {request = beforeClientExecution(request);return executeDescribeWorkspaceImages(request);}

// Translation:
public virtual DescribeWorkspaceImagesResponse DescribeWorkspaceImages(DescribeWorkspaceImagesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeWorkspaceImagesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeWorkspaceImagesResponseUnmarshaller.Instance;return Invoke<DescribeWorkspaceImagesResponse>(request, options);}
// Original:
public ValueEval getItem(int index) {if (index < 0 || index > _size) {throw new IllegalArgumentException("Specified index " + index+ " is outside range (0.." + (_size - 1) + ")");}return getItemInternal(index);}

// Translation:
public ValueEval GetItem(int index){if (index < 0 || index > _size){throw new ArgumentException("Specified index " + index+ " is outside range (0.." + (_size - 1) + ")");}return GetItemInternal(index);}
// Original:
public ListEventBusesResult listEventBuses(ListEventBusesRequest request) {request = beforeClientExecution(request);return executeListEventBuses(request);}

// Translation:
public virtual ListEventBusesResponse ListEventBuses(ListEventBusesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListEventBusesRequestMarshaller.Instance;options.ResponseUnmarshaller = ListEventBusesResponseUnmarshaller.Instance;return Invoke<ListEventBusesResponse>(request, options);}
// Original:
public QualityStats(double maxGoodPoints, long searchTime) {this.maxGoodPoints = maxGoodPoints;this.searchTime = searchTime;this.recallPoints = new ArrayList<>();pAt = new double[MAX_POINTS+1]; }

// Translation:
public QualityStats(double maxGoodPoints, long searchTime){this.maxGoodPoints = maxGoodPoints;this.searchTime = searchTime;this.recallPoints = new List<RecallPoint>();pAt = new double[MAX_POINTS + 1]; }
// Original:
public GetInvalidationRequest(String distributionId, String id) {setDistributionId(distributionId);setId(id);}

// Translation:
public GetInvalidationRequest(string distributionId, string id){_distributionId = distributionId;_id = id;}
// Original:
public int compareTo(ScoreTerm other) {if (this.boost == other.boost)return other.bytes.get().compareTo(this.bytes.get());elsereturn Float.compare(this.boost, other.boost);}

// Translation:
public int CompareTo(ScoreTerm other){if (this.Boost == other.Boost){return TermComp.Compare(other.Bytes, this.Bytes);}else{return this.Boost.CompareTo(other.Boost);}}
// Original:
public RegenerateSecurityTokenResult regenerateSecurityToken(RegenerateSecurityTokenRequest request) {request = beforeClientExecution(request);return executeRegenerateSecurityToken(request);}

// Translation:
public virtual RegenerateSecurityTokenResponse RegenerateSecurityToken(RegenerateSecurityTokenRequest request){var options = new InvokeOptions();options.RequestMarshaller = RegenerateSecurityTokenRequestMarshaller.Instance;options.ResponseUnmarshaller = RegenerateSecurityTokenResponseUnmarshaller.Instance;return Invoke<RegenerateSecurityTokenResponse>(request, options);}
// Original:
public DescribeRootFoldersResult describeRootFolders(DescribeRootFoldersRequest request) {request = beforeClientExecution(request);return executeDescribeRootFolders(request);}

// Translation:
public virtual DescribeRootFoldersResponse DescribeRootFolders(DescribeRootFoldersRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeRootFoldersRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeRootFoldersResponseUnmarshaller.Instance;return Invoke<DescribeRootFoldersResponse>(request, options);}
// Original:
public DeactivateUserResult deactivateUser(DeactivateUserRequest request) {request = beforeClientExecution(request);return executeDeactivateUser(request);}

// Translation:
public virtual DeactivateUserResponse DeactivateUser(DeactivateUserRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeactivateUserRequestMarshaller.Instance;options.ResponseUnmarshaller = DeactivateUserResponseUnmarshaller.Instance;return Invoke<DeactivateUserResponse>(request, options);}
// Original:
public boolean contains(int el) {int n = intervals.size();int l = 0;int r = n - 1;while (l <= r) {int m = (l + r) / 2;Interval I = intervals.get(m);int a = I.a;int b = I.b;if ( b<el ) {l = m + 1;} else if ( a>el ) {r = m - 1;} else { return true;}}return false;}

// Translation:
public virtual bool Contains(int el){int n = intervals.Count;for (int i = 0; i < n; i++){Interval I = intervals[i];int a = I.a;int b = I.b;if (el < a){break;}if (el >= a && el <= b){return true;}}return false;}
// Original:
public ListJobsResult listJobs(ListJobsRequest request) {request = beforeClientExecution(request);return executeListJobs(request);}

// Translation:
public virtual ListJobsResponse ListJobs(ListJobsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListJobsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListJobsResponseUnmarshaller.Instance;return Invoke<ListJobsResponse>(request, options);}
// Original:
public RussianLightStemFilterFactory(Map<String,String> args) {super(args);if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

// Translation:
public RussianLightStemFilterFactory(IDictionary<string, string> args): base(args){if (args.Count > 0){throw new System.ArgumentException("Unknown parameters: " + args);}}
// Original:
public SearchSkillGroupsResult searchSkillGroups(SearchSkillGroupsRequest request) {request = beforeClientExecution(request);return executeSearchSkillGroups(request);}

// Translation:
public virtual SearchSkillGroupsResponse SearchSkillGroups(SearchSkillGroupsRequest request){var options = new InvokeOptions();options.RequestMarshaller = SearchSkillGroupsRequestMarshaller.Instance;options.ResponseUnmarshaller = SearchSkillGroupsResponseUnmarshaller.Instance;return Invoke<SearchSkillGroupsResponse>(request, options);}
// Original:
public SortField getSortField(Bindings bindings, boolean reverse) {return getDoubleValuesSource(bindings).getSortField(reverse);}

// Translation:
public virtual SortField GetSortField(Bindings bindings, bool reverse){return GetValueSource(bindings).GetSortField(reverse);}
// Original:
public ModifyHostsResult modifyHosts(ModifyHostsRequest request) {request = beforeClientExecution(request);return executeModifyHosts(request);}

// Translation:
public virtual ModifyHostsResponse ModifyHosts(ModifyHostsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ModifyHostsRequestMarshaller.Instance;options.ResponseUnmarshaller = ModifyHostsResponseUnmarshaller.Instance;return Invoke<ModifyHostsResponse>(request, options);}
// Original:
public void setDate(String date) {this.date = date;}

// Translation:
public virtual void SetDate(string date){this.date = date;}
// Original:
public ValueEval getAreaEval(int firstRowIndex, int firstColumnIndex,int lastRowIndex, int lastColumnIndex) {SheetRangeEvaluator sre = getRefEvaluatorForCurrentSheet();return new LazyAreaEval(firstRowIndex, firstColumnIndex, lastRowIndex, lastColumnIndex, sre);}

// Translation:
public ValueEval GetAreaEval(int firstRowIndex, int firstColumnIndex,int lastRowIndex, int lastColumnIndex){SheetRangeEvaluator sre = GetRefEvaluatorForCurrentSheet();return new LazyAreaEval(firstRowIndex, firstColumnIndex, lastRowIndex, lastColumnIndex, sre);}
// Original:
public CreateContactMethodResult createContactMethod(CreateContactMethodRequest request) {request = beforeClientExecution(request);return executeCreateContactMethod(request);}

// Translation:
public virtual CreateContactMethodResponse CreateContactMethod(CreateContactMethodRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateContactMethodRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateContactMethodResponseUnmarshaller.Instance;return Invoke<CreateContactMethodResponse>(request, options);}
// Original:
public static final RevFilter before(Date ts) {return before(ts.getTime());}

// Translation:
public static RevFilter Before(DateTime ts){return Before(ts.GetTime());}
// Original:
public String toString() { return toString(VocabularyImpl.EMPTY_VOCABULARY); }

// Translation:
public override String ToString() { return ToString(Vocabulary.EmptyVocabulary); }
// Original:
public void updateFormulasAfterCellShift(FormulaShifter shifter, int externSheetIndex) {for (int i = 0; i < _cfHeaders.size(); i++) {CFRecordsAggregate subAgg = _cfHeaders.get(i);boolean shouldKeep = subAgg.updateFormulasAfterCellShift(shifter, externSheetIndex);if (!shouldKeep) {_cfHeaders.remove(i);i--;}}}

// Translation:
public void UpdateFormulasAfterCellShift(FormulaShifter shifter, int externSheetIndex){for (int i = 0; i < _cfHeaders.Count; i++){CFRecordsAggregate subAgg = (CFRecordsAggregate)_cfHeaders[i];bool shouldKeep = subAgg.UpdateFormulasAfterCellShift(shifter, externSheetIndex);if (!shouldKeep){_cfHeaders.RemoveAt(i);i--;}}}
// Original:
public void insertCell(CellValueRecordInterface cvRec) {_valuesAgg.insertCell(cvRec);}

// Translation:
public void InsertCell(CellValueRecordInterface cvRec){_valuesAgg.InsertCell(cvRec);}
// Original:
public ShingleFilter create(TokenStream input) {ShingleFilter r = new ShingleFilter(input, minShingleSize, maxShingleSize);r.setOutputUnigrams(outputUnigrams);r.setOutputUnigramsIfNoShingles(outputUnigramsIfNoShingles);r.setTokenSeparator(tokenSeparator);r.setFillerToken(fillerToken);return r;}

// Translation:
public override TokenStream Create(TokenStream input){ShingleFilter r = new ShingleFilter(input, minShingleSize, maxShingleSize);r.SetOutputUnigrams(outputUnigrams);r.SetOutputUnigramsIfNoShingles(outputUnigramsIfNoShingles);r.SetTokenSeparator(tokenSeparator);r.SetFillerToken(fillerToken);return r;}
// Original:
public SlopQueryNode(QueryNode query, int value) {if (query == null) {throw new QueryNodeError(new MessageImpl(QueryParserMessages.NODE_ACTION_NOT_SUPPORTED, "query", "null"));}this.value = value;setLeaf(false);allocate();add(query);}

// Translation:
public SlopQueryNode(IQueryNode query, int value){if (query == null){throw new QueryNodeError(new Message(QueryParserMessages.NODE_ACTION_NOT_SUPPORTED, "query", "null"));}this.value = value;IsLeaf = false;Allocate();Add(query);}
// Original:
public ReplaceRouteTableAssociationResult replaceRouteTableAssociation(ReplaceRouteTableAssociationRequest request) {request = beforeClientExecution(request);return executeReplaceRouteTableAssociation(request);}

// Translation:
public virtual ReplaceRouteTableAssociationResponse ReplaceRouteTableAssociation(ReplaceRouteTableAssociationRequest request){var options = new InvokeOptions();options.RequestMarshaller = ReplaceRouteTableAssociationRequestMarshaller.Instance;options.ResponseUnmarshaller = ReplaceRouteTableAssociationResponseUnmarshaller.Instance;return Invoke<ReplaceRouteTableAssociationResponse>(request, options);}
// Original:
public void setObjectIdFromRaw(byte[] bs, int p) {final int n = Constants.OBJECT_ID_LENGTH;System.arraycopy(bs, p, idBuffer(), idOffset(), n);}

// Translation:
public virtual void SetObjectIdFromRaw(byte[] bs, int p){int n = Constants.OBJECT_ID_LENGTH;System.Array.Copy(bs, p, IdBuffer, IdOffset, n);}
// Original:
public ListTablesResult listTables(Integer limit) {return listTables(new ListTablesRequest().withLimit(limit));}

// Translation:
public virtual ListTablesResponse ListTables(int limit){var request = new ListTablesRequest();request.Limit = limit;return ListTables(request);}
// Original:
public DeleteDeviceGroupRequest() {super("LinkFace", "2018-07-20", "DeleteDeviceGroup");setProtocol(ProtocolType.HTTPS);setMethod(MethodType.POST);}

// Translation:
public DeleteDeviceGroupRequest(): base("LinkFace", "2018-07-20", "DeleteDeviceGroup"){Protocol = ProtocolType.HTTPS;Method = MethodType.POST;}
// Original:
public void addRecords(RecordStream rs) {while (true) {if (!readARecord(rs)) {break;}}}

// Translation:
public void AddRecords(RecordStream rs){while (true){if (!ReadARecord(rs)){break;}}}
// Original:
public static Collection<String> getSupportedFunctionNames() {Collection<String> lst = new TreeSet<>();for (int i = 0; i < functions.length; i++) {Function func = functions[i];FunctionMetadata metaData = FunctionMetadataRegistry.getFunctionByIndex(i);if (func != null && !(func instanceof NotImplementedFunction)) {lst.add(metaData.getName());}}lst.add("INDIRECT"); return Collections.unmodifiableCollection(lst);}

// Translation:
public static ReadOnlyCollection<String> GetSupportedFunctionNames(){List<String> lst = new List<String>();for (int i = 0; i < functions.Length; i++){Function func = functions[i];FunctionMetadata metaData = FunctionMetadataRegistry.GetFunctionByIndex(i);if (func != null && !(func is NotImplementedFunction)){lst.Add(metaData.Name);}}lst.Add("INDIRECT"); return lst.AsReadOnly(); }
// Original:
public PendingTaskCount countPendingActivityTasks(CountPendingActivityTasksRequest request) {request = beforeClientExecution(request);return executeCountPendingActivityTasks(request);}

// Translation:
public virtual CountPendingActivityTasksResponse CountPendingActivityTasks(CountPendingActivityTasksRequest request){var options = new InvokeOptions();options.RequestMarshaller = CountPendingActivityTasksRequestMarshaller.Instance;options.ResponseUnmarshaller = CountPendingActivityTasksResponseUnmarshaller.Instance;return Invoke<CountPendingActivityTasksResponse>(request, options);}
// Original:
public List<SegToken> process(String sentence) {SegGraph segGraph = createSegGraph(sentence);BiSegGraph biSegGraph = new BiSegGraph(segGraph);List<SegToken> shortPath = biSegGraph.getShortPath();return shortPath;}

// Translation:
public virtual IList<SegToken> Process(string sentence){SegGraph segGraph = CreateSegGraph(sentence);BiSegGraph biSegGraph = new BiSegGraph(segGraph);IList<SegToken> shortPath = biSegGraph.GetShortPath();return shortPath;}
// Original:
public Area3DPtg(AreaReference arearef, int externIdx) {super(arearef);setExternSheetIndex(externIdx);}

// Translation:
public Area3DPtg(AreaReference arearef, int externIdx):base(arearef){ExternSheetIndex=(externIdx);}
// Original:
public EnableRuleResult enableRule(EnableRuleRequest request) {request = beforeClientExecution(request);return executeEnableRule(request);}

// Translation:
public virtual EnableRuleResponse EnableRule(EnableRuleRequest request){var options = new InvokeOptions();options.RequestMarshaller = EnableRuleRequestMarshaller.Instance;options.ResponseUnmarshaller = EnableRuleResponseUnmarshaller.Instance;return Invoke<EnableRuleResponse>(request, options);}