yijunyu/c-to-rust huggingface dataset:
// Original:
public final int getByte(int index) {int w;switch (index >> 2) {case 0:w = w1;break;case 1:w = w2;break;case 2:w = w3;break;case 3:w = w4;break;case 4:w = w5;break;default:throw new ArrayIndexOutOfBoundsException(index);}return (w >>> (8 * (3 - (index & 3)))) & 0xff;}

// Translation:
public int GetByte(int index){int w;switch (index >> 2){case 0:{w = w1;break;}case 1:{w = w2;break;}case 2:{w = w3;break;}case 3:{w = w4;break;}case 4:{w = w5;break;}default:{throw Sharpen.Extensions.CreateIndexOutOfRangeException(index);}}return ((int)(((uint)w) >> (8 * (3 - (index & 3))))) & unchecked((int)(0xff));}
// Original:
public SpanFirstBuilder(SpanQueryBuilder factory) {this.factory = factory;}

// Translation:
public SpanFirstBuilder(ISpanQueryBuilder factory){this.factory = factory;}
// Original:
public DescribeInstancesResult describeInstances(DescribeInstancesRequest request) {request = beforeClientExecution(request);return executeDescribeInstances(request);}

// Translation:
public virtual DescribeInstancesResponse DescribeInstances(DescribeInstancesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeInstancesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeInstancesResponseUnmarshaller.Instance;return Invoke<DescribeInstancesResponse>(request, options);}
// Original:
public DescribeProjectsResult describeProjects(DescribeProjectsRequest request) {request = beforeClientExecution(request);return executeDescribeProjects(request);}

// Translation:
public virtual DescribeProjectsResponse DescribeProjects(DescribeProjectsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeProjectsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeProjectsResponseUnmarshaller.Instance;return Invoke<DescribeProjectsResponse>(request, options);}
// Original:
public static String toHexString(String s) {StringBuilder sb = new StringBuilder();for(int i=0;i<s.length();i++) {char ch = s.charAt(i);if (i > 0) {sb.append(' ');}if (ch < 128) {sb.append(ch);} else {if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {sb.append("H:");} else if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {sb.append("L:");} else if (ch > UNI_SUR_LOW_END) {if (ch == 0xffff) {sb.append("F:");} else {sb.append("E:");}}sb.append("0x").append(Integer.toHexString(ch));}}return sb.toString();}

// Translation:
public static string ToHexString(string s){var sb = new StringBuilder();for (int i = 0; i < s.Length; i++){char ch = s[i];if (i > 0){sb.Append(' ');}if (ch < 128){sb.Append(ch);}else{if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END){sb.Append("H:");}else if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END){sb.Append("L:");}else if (ch > UNI_SUR_LOW_END){if (ch == 0xffff){sb.Append("F:");}else{sb.Append("E:");}}sb.Append("0x" + ((short)ch).ToString("X"));}}return sb.ToString();}
// Original:
public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0) {double result;try {double d0 = NumericFunction.singleOperandEvaluate(arg0, srcRowIndex, srcColumnIndex);result = Math.log(d0) / LOG_10_TO_BASE_e;NumericFunction.checkValue(result);} catch (EvaluationException e) {return e.getErrorEval();}return new NumberEval(result);}

// Translation:
public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0){double result;try{double d0 = NumericFunction.SingleOperandEvaluate(arg0, srcRowIndex, srcColumnIndex);result = Math.Log(d0) / NumericFunction.LOG_10_TO_BASE_e;NumericFunction.CheckValue(result);}catch (EvaluationException e){return e.GetErrorEval();}return new NumberEval(result);}
// Original:
public long byteCount(int packedIntsVersion, int valueCount, int bitsPerValue) {assert bitsPerValue >= 0 && bitsPerValue <= 64 : bitsPerValue;return 8L * longCount(packedIntsVersion, valueCount, bitsPerValue);}

// Translation:
public virtual long ByteCount(int packedIntsVersion, int valueCount, int bitsPerValue){return 8L * Int64Count(packedIntsVersion, valueCount, bitsPerValue);}
// Original:
public Policy(String id, Collection<Statement> statements) {this(id);setStatements(statements);}

// Translation:
public Policy(string id, IList<Statement> statements){this.id = id;this.statements = statements;}
// Original:
public FunctionQuery(ValueSource func) {this.func=func;}

// Translation:
public FunctionQuery(ValueSource func){this.func = func;}
// Original:
public UpdateGameServerResult updateGameServer(UpdateGameServerRequest request) {request = beforeClientExecution(request);return executeUpdateGameServer(request);}

// Translation:
public virtual UpdateGameServerResponse UpdateGameServer(UpdateGameServerRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateGameServerRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateGameServerResponseUnmarshaller.Instance;return Invoke<UpdateGameServerResponse>(request, options);}
// Original:
public GetDetectorVersionResult getDetectorVersion(GetDetectorVersionRequest request) {request = beforeClientExecution(request);return executeGetDetectorVersion(request);}

// Translation:
public virtual GetDetectorVersionResponse GetDetectorVersion(GetDetectorVersionRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetDetectorVersionRequestMarshaller.Instance;options.ResponseUnmarshaller = GetDetectorVersionResponseUnmarshaller.Instance;return Invoke<GetDetectorVersionResponse>(request, options);}
// Original:
public void addField(String fieldName, String text, Analyzer analyzer) {if (fieldName == null)throw new IllegalArgumentException("fieldName must not be null");if (text == null)throw new IllegalArgumentException("text must not be null");if (analyzer == null)throw new IllegalArgumentException("analyzer must not be null");TokenStream stream = analyzer.tokenStream(fieldName, text);storeTerms(getInfo(fieldName, defaultFieldType), stream,analyzer.getPositionIncrementGap(fieldName), analyzer.getOffsetGap(fieldName));}

// Translation:
public virtual void AddField(string fieldName, string text, Analyzer analyzer){if (fieldName == null){throw new System.ArgumentException("fieldName must not be null");}if (text == null){throw new System.ArgumentException("text must not be null");}if (analyzer == null){throw new System.ArgumentException("analyzer must not be null");}TokenStream stream;try{stream = analyzer.GetTokenStream(fieldName, text);}catch (IOException ex){throw new Exception(ex.ToString(), ex);}AddField(fieldName, stream, 1.0f, analyzer.GetPositionIncrementGap(fieldName), analyzer.GetOffsetGap(fieldName));}
// Original:
public boolean isEnabled(String component) {return false;}

// Translation:
public override bool IsEnabled(string component){return false;}
// Original:
public long next() {final long idx = 1 + (ord / indexInterval);if (idx >= fieldIndex.numIndexTerms) {return -1;}ord += indexInterval;final long offset = fieldIndex.termOffsets.get(idx);final int length = (int) (fieldIndex.termOffsets.get(1+idx) - offset);termBytesReader.fillSlice(term, fieldIndex.termBytesStart + offset, length);return fieldIndex.termsStart + fieldIndex.termsDictOffsets.get(idx);}

// Translation:
public override long Next(){int idx = 1 + (int)(ord / outerInstance.totalIndexInterval);if (idx >= fieldIndex.numIndexTerms){return -1;}ord += outerInstance.totalIndexInterval;long offset = fieldIndex.termOffsets.Get(idx);int length = (int)(fieldIndex.termOffsets.Get(1 + idx) - offset);outerInstance.termBytesReader.FillSlice(term, fieldIndex.termBytesStart + offset, length);return fieldIndex.termsStart + fieldIndex.termsDictOffsets.Get(idx);}
// Original:
public DisassociateMemberFromGroupResult disassociateMemberFromGroup(DisassociateMemberFromGroupRequest request) {request = beforeClientExecution(request);return executeDisassociateMemberFromGroup(request);}

// Translation:
public virtual DisassociateMemberFromGroupResponse DisassociateMemberFromGroup(DisassociateMemberFromGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = DisassociateMemberFromGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = DisassociateMemberFromGroupResponseUnmarshaller.Instance;return Invoke<DisassociateMemberFromGroupResponse>(request, options);}
// Original:
public UnmergedPathException(DirCacheEntry dce) {super(MessageFormat.format(JGitText.get().unmergedPath, dce.getPathString()));entry = dce;}

// Translation:
public UnmergedPathException(DirCacheEntry dce) : base(MessageFormat.Format(JGitText.Get().unmergedPath, dce.PathString)){entry = dce;}
// Original:
public Name(NameRecord nameRecord, int index) {_nameRecord = nameRecord;_index = index;}

// Translation:
public Name(NameRecord nameRecord, int index){_nameRecord = nameRecord;_index = index;}
// Original:
public void add(ET object) {if (expectedModCount == list.modCount) {Link<ET> next = link.next;Link<ET> newLink = new Link<ET>(object, link, next);link.next = newLink;next.previous = newLink;link = newLink;lastLink = null;pos++;expectedModCount++;list.size++;list.modCount++;} else {throw new ConcurrentModificationException();}}

// Translation:
public void add(ET @object){if (expectedModCount == list.modCount){java.util.LinkedList.Link<ET> next_1 = link.next;java.util.LinkedList.Link<ET> newLink = new java.util.LinkedList.Link<ET>(@object, link, next_1);link.next = newLink;next_1.previous = newLink;link = newLink;lastLink = null;pos++;expectedModCount++;list._size++;list.modCount++;}else{throw new java.util.ConcurrentModificationException();}}
// Original:
public final ByteOrder order() {return order;}

// Translation:
public java.nio.ByteOrder order(){return _order;}
// Original:
public ValueFiller getValueFiller() {return new ValueFiller() {private final MutableValueStr mval = new MutableValueStr();@Override

// Translation:
public override ValueFiller GetValueFiller(){return new ValueFillerAnonymousInnerClassHelper(this);}
// Original:
public SubmoduleInitCommand addPath(String path) {paths.add(path);return this;}

// Translation:
public virtual NGit.Api.SubmoduleInitCommand AddPath(string path){paths.AddItem(path);return this;}
// Original:
public DeleteInterconnectResult deleteInterconnect(DeleteInterconnectRequest request) {request = beforeClientExecution(request);return executeDeleteInterconnect(request);}

// Translation:
public virtual DeleteInterconnectResponse DeleteInterconnect(DeleteInterconnectRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteInterconnectRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteInterconnectResponseUnmarshaller.Instance;return Invoke<DeleteInterconnectResponse>(request, options);}
// Original:
public Credential(String keyId, String secret) {this.accessKeyId = keyId;this.accessSecret = secret;this.refreshDate = new Date();}

// Translation:
public Credential(string keyId, string secret){AccessKeyId = keyId;AccessSecret = secret;RefreshDate = DateTime.UtcNow;}
// Original:
public DeleteRepoWebhookRequest() {super("cr", "2016-06-07", "DeleteRepoWebhook", "cr");setUriPattern("/repos/[RepoNamespace]/[RepoName]/webhooks/[WebhookId]");setMethod(MethodType.DELETE);}

// Translation:
public DeleteRepoWebhookRequest(): base("cr", "2016-06-07", "DeleteRepoWebhook", "cr", "openAPI"){UriPattern = "/repos/[RepoNamespace]/[RepoName]/webhooks/[WebhookId]";Method = MethodType.DELETE;}
// Original:
public DeleteDeviceResult deleteDevice(DeleteDeviceRequest request) {request = beforeClientExecution(request);return executeDeleteDevice(request);}

// Translation:
public virtual DeleteDeviceResponse DeleteDevice(DeleteDeviceRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteDeviceRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteDeviceResponseUnmarshaller.Instance;return Invoke<DeleteDeviceResponse>(request, options);}
// Original:
public CreateEventBusResult createEventBus(CreateEventBusRequest request) {request = beforeClientExecution(request);return executeCreateEventBus(request);}

// Translation:
public virtual CreateEventBusResponse CreateEventBus(CreateEventBusRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateEventBusRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateEventBusResponseUnmarshaller.Instance;return Invoke<CreateEventBusResponse>(request, options);}
// Original:
public boolean isEnabled() {return enabled;}

// Translation:
public virtual bool IsEnabled(){return enabled;}
// Original:
public boolean isSigned() {return signed;}

// Translation:
public virtual bool IsSigned(){return signed;}
// Original:
public DeleteRuleVersionResult deleteRuleVersion(DeleteRuleVersionRequest request) {request = beforeClientExecution(request);return executeDeleteRuleVersion(request);}

// Translation:
public virtual DeleteRuleVersionResponse DeleteRuleVersion(DeleteRuleVersionRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteRuleVersionRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteRuleVersionResponseUnmarshaller.Instance;return Invoke<DeleteRuleVersionResponse>(request, options);}
// Original:
public long seek(long ord) {throw new UnsupportedOperationException();}

// Translation:
public override long Seek(long ord){throw new NotSupportedException();}
// Original:
public CreateAppCookieStickinessPolicyRequest(String loadBalancerName, String policyName, String cookieName) {setLoadBalancerName(loadBalancerName);setPolicyName(policyName);setCookieName(cookieName);}

// Translation:
public CreateAppCookieStickinessPolicyRequest(string loadBalancerName, string policyName, string cookieName){_loadBalancerName = loadBalancerName;_policyName = policyName;_cookieName = cookieName;}
// Original:
public BlameCommand setDiffAlgorithm(DiffAlgorithm diffAlgorithm) {this.diffAlgorithm = diffAlgorithm;return this;}

// Translation:
public virtual NGit.Api.BlameCommand SetDiffAlgorithm(DiffAlgorithm diffAlgorithm){this.diffAlgorithm = diffAlgorithm;return this;}
// Original:
public DisassociateSkillFromUsersResult disassociateSkillFromUsers(DisassociateSkillFromUsersRequest request) {request = beforeClientExecution(request);return executeDisassociateSkillFromUsers(request);}

// Translation:
public virtual DisassociateSkillFromUsersResponse DisassociateSkillFromUsers(DisassociateSkillFromUsersRequest request){var options = new InvokeOptions();options.RequestMarshaller = DisassociateSkillFromUsersRequestMarshaller.Instance;options.ResponseUnmarshaller = DisassociateSkillFromUsersResponseUnmarshaller.Instance;return Invoke<DisassociateSkillFromUsersResponse>(request, options);}
// Original:
public PatchIdDiffFormatter() {super(new DigestOutputStream(NullOutputStream.INSTANCE,Constants.newMessageDigest()));digest = ((DigestOutputStream) getOutputStream()).getMessageDigest();}

// Translation:
public PatchIdDiffFormatter() : base(new DigestOutputStream(NullOutputStream.INSTANCE, Constants.NewMessageDigest())){digest = ((DigestOutputStream)GetOutputStream()).GetMessageDigest();}
// Original:
public SendMessageResult sendMessage(SendMessageRequest request) {request = beforeClientExecution(request);return executeSendMessage(request);}

// Translation:
public virtual SendMessageResponse SendMessage(SendMessageRequest request){var options = new InvokeOptions();options.RequestMarshaller = SendMessageRequestMarshaller.Instance;options.ResponseUnmarshaller = SendMessageResponseUnmarshaller.Instance;return Invoke<SendMessageResponse>(request, options);}
// Original:
public static ParsePathType pathType(Path f) {int pathLength = 0;while (f != null && f.getFileName() != null && ++pathLength < MAX_PATH_LENGTH) {ParsePathType ppt = pathName2Type.get(f.getFileName().toString().toUpperCase(Locale.ROOT));if (ppt!=null) {return ppt;}f = f.getParent();}return DEFAULT_PATH_TYPE;}

// Translation:
public static ParsePathType PathType(FileInfo f){int pathLength = 0;ParsePathType? ppt;if (pathName2Type.TryGetValue(f.Name.ToUpperInvariant(), out ppt) && ppt != null){return ppt.Value;}DirectoryInfo parentDir = f.Directory;while (parentDir != null && ++pathLength < MAX_PATH_LENGTH){if (pathName2Type.TryGetValue(parentDir.Name.ToUpperInvariant(), out ppt) && ppt != null){return ppt.Value;}parentDir = parentDir.Parent;}return DEFAULT_PATH_TYPE;}
// Original:
public static long estimateIndexSize(int sourceLength) {return sourceLength + (sourceLength * 3 / 4);}

// Translation:
public static long EstimateIndexSize(int sourceLength){return sourceLength + (sourceLength * 3 / 4);}
// Original:
public UpdateDashboardPermissionsResult updateDashboardPermissions(UpdateDashboardPermissionsRequest request) {request = beforeClientExecution(request);return executeUpdateDashboardPermissions(request);}

// Translation:
public virtual UpdateDashboardPermissionsResponse UpdateDashboardPermissions(UpdateDashboardPermissionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateDashboardPermissionsRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateDashboardPermissionsResponseUnmarshaller.Instance;return Invoke<UpdateDashboardPermissionsResponse>(request, options);}
// Original:
public String formatAsString() {switch (_cellType) {case NUMERIC:return String.valueOf(_numberValue);case STRING:return '"' + _textValue + '"';case BOOLEAN:return _booleanValue ? "TRUE" : "FALSE";case ERROR:return ErrorEval.getText(_errorCode);default:return "<error unexpected cell type " + _cellType + ">";}}

// Translation:
public String FormatAsString(){switch (_cellType){case CellType.Numeric:string result = _numberValue.ToString(CultureInfo.InvariantCulture);return result;case CellType.String:return '"' + _textValue + '"';case CellType.Boolean:return _boolValue ? "TRUE" : "FALSE";case CellType.Error:return ErrorEval.GetText(_errorCode);}return "<error unexpected cell type " + _cellType + ">";}
// Original:
public final void add(RevFlagSet set) {flags |= set.mask;}

// Translation:
public void Add(RevFlagSet set){flags |= set.mask;}
// Original:
public URIish setHost(String n) {final URIish r = new URIish(this);r.host = n;return r;}

// Translation:
public virtual NGit.Transport.URIish SetHost(string n){NGit.Transport.URIish r = new NGit.Transport.URIish(this);r.host = n;return r;}
// Original:
public void clearFormulaEntry() {CellCacheEntry[] usedCells = _sensitiveInputCells;if (usedCells != null) {for (int i = usedCells.length-1; i>=0; i--) {usedCells[i].clearConsumingCell(this);}}_sensitiveInputCells = null;clearValue();}

// Translation:
public void ClearFormulaEntry(){CellCacheEntry[] usedCells = _sensitiveInputCells;if (usedCells != null){for (int i = usedCells.Length - 1; i >= 0; i--){usedCells[i].ClearConsumingCell(this);}}_sensitiveInputCells = null;ClearValue();}
// Original:
public GetDiskSnapshotResult getDiskSnapshot(GetDiskSnapshotRequest request) {request = beforeClientExecution(request);return executeGetDiskSnapshot(request);}

// Translation:
public virtual GetDiskSnapshotResponse GetDiskSnapshot(GetDiskSnapshotRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetDiskSnapshotRequestMarshaller.Instance;options.ResponseUnmarshaller = GetDiskSnapshotResponseUnmarshaller.Instance;return Invoke<GetDiskSnapshotResponse>(request, options);}
// Original:
public DescribeIpv6PoolsResult describeIpv6Pools(DescribeIpv6PoolsRequest request) {request = beforeClientExecution(request);return executeDescribeIpv6Pools(request);}

// Translation:
public virtual DescribeIpv6PoolsResponse DescribeIpv6Pools(DescribeIpv6PoolsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeIpv6PoolsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeIpv6PoolsResponseUnmarshaller.Instance;return Invoke<DescribeIpv6PoolsResponse>(request, options);}
// Original:
public UpdateDetectorResult updateDetector(UpdateDetectorRequest request) {request = beforeClientExecution(request);return executeUpdateDetector(request);}

// Translation:
public virtual UpdateDetectorResponse UpdateDetector(UpdateDetectorRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateDetectorRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateDetectorResponseUnmarshaller.Instance;return Invoke<UpdateDetectorResponse>(request, options);}
// Original:
public DeleteInstanceResult deleteInstance(DeleteInstanceRequest request) {request = beforeClientExecution(request);return executeDeleteInstance(request);}

// Translation:
public virtual DeleteInstanceResponse DeleteInstance(DeleteInstanceRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteInstanceRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteInstanceResponseUnmarshaller.Instance;return Invoke<DeleteInstanceResponse>(request, options);}
// Original:
public ListThreatIntelSetsResult listThreatIntelSets(ListThreatIntelSetsRequest request) {request = beforeClientExecution(request);return executeListThreatIntelSets(request);}

// Translation:
public virtual ListThreatIntelSetsResponse ListThreatIntelSets(ListThreatIntelSetsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListThreatIntelSetsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListThreatIntelSetsResponseUnmarshaller.Instance;return Invoke<ListThreatIntelSetsResponse>(request, options);}
// Original:
public ExportClientVpnClientConfigurationResult exportClientVpnClientConfiguration(ExportClientVpnClientConfigurationRequest request) {request = beforeClientExecution(request);return executeExportClientVpnClientConfiguration(request);}

// Translation:
public virtual ExportClientVpnClientConfigurationResponse ExportClientVpnClientConfiguration(ExportClientVpnClientConfigurationRequest request){var options = new InvokeOptions();options.RequestMarshaller = ExportClientVpnClientConfigurationRequestMarshaller.Instance;options.ResponseUnmarshaller = ExportClientVpnClientConfigurationResponseUnmarshaller.Instance;return Invoke<ExportClientVpnClientConfigurationResponse>(request, options);}
// Original:
public float currentScore(int docId, String field, int start, int end, int numPayloadsSeen, float currentScore, float currentPayloadScore) {if (numPayloadsSeen == 0) {return currentPayloadScore;} else {return Math.max(currentPayloadScore, currentScore);}}

// Translation:
public override float CurrentScore(int docId, string field, int start, int end, int numPayloadsSeen, float currentScore, float currentPayloadScore){if (numPayloadsSeen == 0){return currentPayloadScore;}else{return Math.Max(currentPayloadScore, currentScore);}}
// Original:
public CreateDBParameterGroupRequest(String dBParameterGroupName, String dBParameterGroupFamily, String description) {setDBParameterGroupName(dBParameterGroupName);setDBParameterGroupFamily(dBParameterGroupFamily);setDescription(description);}

// Translation:
public CreateDBParameterGroupRequest(string dbParameterGroupName, string dbParameterGroupFamily, string description){_dbParameterGroupName = dbParameterGroupName;_dbParameterGroupFamily = dbParameterGroupFamily;_description = description;}
// Original:
public void add(int forwardId, int backwardId, int cost) {int offset = (backwardId * forwardSize + forwardId) * 2;costs.putShort(offset, (short) cost);}

// Translation:
public void Add(int forwardId, int backwardId, int cost){this.costs[backwardId][forwardId] = (short)cost;}
// Original:
public boolean isPeeled() {return true;}

// Translation:
public override bool IsPeeled(){return true;}
// Original:
public CreateTransitVirtualInterfaceResult createTransitVirtualInterface(CreateTransitVirtualInterfaceRequest request) {request = beforeClientExecution(request);return executeCreateTransitVirtualInterface(request);}

// Translation:
public virtual CreateTransitVirtualInterfaceResponse CreateTransitVirtualInterface(CreateTransitVirtualInterfaceRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateTransitVirtualInterfaceRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateTransitVirtualInterfaceResponseUnmarshaller.Instance;return Invoke<CreateTransitVirtualInterfaceResponse>(request, options);}