yijunyu/c-to-rust huggingface dataset:
// Original:
public boolean isEmpty() {return ConcurrentHashMap.this.isEmpty();}

// Translation:
public override bool isEmpty(){return this._enclosing._size == 0;}
// Original:
public void addName(NameRecord name) {_definedNames.add(name);int idx = findFirstRecordLocBySid(ExternSheetRecord.sid);if (idx == -1) idx = findFirstRecordLocBySid(SupBookRecord.sid);if (idx == -1) idx = findFirstRecordLocBySid(CountryRecord.sid);int countNames = _definedNames.size();_workbookRecordList.add(idx + countNames, name);}

// Translation:
public void AddName(NameRecord name){_definedNames.Add(name);int idx = FindFirstRecordLocBySid(ExternSheetRecord.sid);if (idx == -1) idx = FindFirstRecordLocBySid(SupBookRecord.sid);if (idx == -1) idx = FindFirstRecordLocBySid(CountryRecord.sid);int countNames = _definedNames.Count;_workbookRecordList.Add(idx + countNames, name);}
// Original:
public void sort(RevSort s, boolean use) {assertNotStarted();if (use)sorting.add(s);elsesorting.remove(s);if (sorting.size() > 1)sorting.remove(RevSort.NONE);else if (sorting.isEmpty())sorting.add(RevSort.NONE);}

// Translation:
public virtual void Sort(RevSort s, bool use){AssertNotStarted();if (use){sorting.AddItem(s);}else{sorting.Remove(s);}if (sorting.Count > 1){sorting.Remove(RevSort.NONE);}else{if (sorting.Count == 0){sorting.AddItem(RevSort.NONE);}}}
// Original:
public String toString() {return "D";}

// Translation:
public override string ToString(){return "D";}
// Original:
public DisassociateSkillGroupFromRoomResult disassociateSkillGroupFromRoom(DisassociateSkillGroupFromRoomRequest request) {request = beforeClientExecution(request);return executeDisassociateSkillGroupFromRoom(request);}

// Translation:
public virtual DisassociateSkillGroupFromRoomResponse DisassociateSkillGroupFromRoom(DisassociateSkillGroupFromRoomRequest request){var options = new InvokeOptions();options.RequestMarshaller = DisassociateSkillGroupFromRoomRequestMarshaller.Instance;options.ResponseUnmarshaller = DisassociateSkillGroupFromRoomResponseUnmarshaller.Instance;return Invoke<DisassociateSkillGroupFromRoomResponse>(request, options);}
// Original:
public static byte[] encodeASCII(long s) {return encodeASCII(Long.toString(s));}

// Translation:
public static byte[] EncodeASCII(long s){return EncodeASCII(System.Convert.ToString(s));}
// Original:
public void setData(byte[] b) {setData(b,0,b.length);}

// Translation:
public void SetData(byte[] b){SetData(b, 0, b.Length);}
// Original:
public void removeLinksDirty() {remove1stProperty(PropertyIDMap.PID_LINKSDIRTY);}

// Translation:
public void RemoveLinksDirty(){MutableSection s = (MutableSection)FirstSection;s.RemoveProperty(PropertyIDMap.PID_LINKSDIRTY);}
// Original:
final public void OptionalWeights(SrndQuery q) throws ParseException {Token weight=null;label_8:while (true) {switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {case CARAT:;break;default:jj_la1[9] = jj_gen;break label_8;}jj_consume_token(CARAT);weight = jj_consume_token(NUMBER);float f;try {f = Float.parseFloat(weight.image);} catch (Exception floatExc) {{if (true) throw new ParseException(BOOST_ERROR_MESSAGE + weight.image + " (" + floatExc + ")");}}if (f <= 0.0) {{if (true) throw new ParseException(BOOST_ERROR_MESSAGE + weight.image);}}q.setWeight(f * q.getWeight()); }}

// Translation:
public void OptionalWeights(SrndQuery q){Token weight = null;while (true){switch ((jj_ntk == -1) ? Jj_ntk() : jj_ntk){case RegexpToken.CARAT:;break;default:jj_la1[9] = jj_gen;goto label_8;}Jj_consume_token(RegexpToken.CARAT);weight = Jj_consume_token(RegexpToken.NUMBER);float f;try{f = float.Parse(weight.Image);}catch (Exception floatExc){{ if (true) throw new ParseException(boostErrorMessage + weight.Image + " (" + floatExc + ")"); }}if (f <= 0.0){{ if (true) throw new ParseException(boostErrorMessage + weight.Image); }}q.Weight = (f * q.Weight); }label_8: ;}
// Original:
public ListLogPatternSetsResult listLogPatternSets(ListLogPatternSetsRequest request) {request = beforeClientExecution(request);return executeListLogPatternSets(request);}

// Translation:
public virtual ListLogPatternSetsResponse ListLogPatternSets(ListLogPatternSetsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListLogPatternSetsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListLogPatternSetsResponseUnmarshaller.Instance;return Invoke<ListLogPatternSetsResponse>(request, options);}
// Original:
public String toString() {return "<field start='" + this.begin + "' end='" + this.end + "' field='"+ this.field + "' text='" + this.text + "'/>";}

// Translation:
public override string ToString(){return "<field start='" + this.m_begin + "' end='" + this.m_end + "' field='"+ this.m_field + "' text='" + this.m_text + "'/>";}
// Original:
public ListAssessmentTargetsResult listAssessmentTargets(ListAssessmentTargetsRequest request) {request = beforeClientExecution(request);return executeListAssessmentTargets(request);}

// Translation:
public virtual ListAssessmentTargetsResponse ListAssessmentTargets(ListAssessmentTargetsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListAssessmentTargetsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListAssessmentTargetsResponseUnmarshaller.Instance;return Invoke<ListAssessmentTargetsResponse>(request, options);}
// Original:
public HSSFFontFormatting getFontFormatting() {return getFontFormatting(false);}

// Translation:
public IFontFormatting GetFontFormatting(){return GetFontFormatting(false);}
// Original:
public UpdateRoomResult updateRoom(UpdateRoomRequest request) {request = beforeClientExecution(request);return executeUpdateRoom(request);}

// Translation:
public virtual UpdateRoomResponse UpdateRoom(UpdateRoomRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateRoomRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateRoomResponseUnmarshaller.Instance;return Invoke<UpdateRoomResponse>(request, options);}
// Original:
public ListLexiconsResult listLexicons(ListLexiconsRequest request) {request = beforeClientExecution(request);return executeListLexicons(request);}

// Translation:
public virtual ListLexiconsResponse ListLexicons(ListLexiconsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListLexiconsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListLexiconsResponseUnmarshaller.Instance;return Invoke<ListLexiconsResponse>(request, options);}
// Original:
public boolean equals( Object o ) {return o instanceof KpStemmer;}

// Translation:
public override bool Equals(object o){return o is KpStemmer;}
// Original:
public void write(String str, int offset, int count) {String sub = str.substring(offset, offset + count);buf.append(sub);}

// Translation:
public override void write(string str, int offset, int count){string sub = Sharpen.StringHelper.Substring(str, offset, offset + count);buf.append(sub);}
// Original:
public PackLock(File packFile, FS fs) {final File p = packFile.getParentFile();final String n = packFile.getName();keepFile = new File(p, n.substring(0, n.length() - 5) + ".keep"); }

// Translation:
public PackLock(FilePath packFile, FS fs){FilePath p = packFile.GetParentFile();string n = packFile.GetName();keepFile = new FilePath(p, Sharpen.Runtime.Substring(n, 0, n.Length - 5) + ".keep");this.fs = fs;}
// Original:
public CreatePublicKeyResult createPublicKey(CreatePublicKeyRequest request) {request = beforeClientExecution(request);return executeCreatePublicKey(request);}

// Translation:
public virtual CreatePublicKeyResponse CreatePublicKey(CreatePublicKeyRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreatePublicKeyRequestMarshaller.Instance;options.ResponseUnmarshaller = CreatePublicKeyResponseUnmarshaller.Instance;return Invoke<CreatePublicKeyResponse>(request, options);}
// Original:
public PersonIdent getRefLogIdent() {return refLogIdent;}

// Translation:
public virtual PersonIdent GetRefLogIdent(){return refLogIdent;}
// Original:
public boolean equals(Object o) {if (this == o) {return true;}if (!(o instanceof EscherComplexProperty)) {return false;}EscherComplexProperty escherComplexProperty = (EscherComplexProperty) o;return Arrays.equals(complexData, escherComplexProperty.complexData);}

// Translation:
public override bool Equals(Object o){if (this == o) return true;if (!(o is EscherComplexProperty)) return false;EscherComplexProperty escherComplexProperty = (EscherComplexProperty)o;if (!Arrays.Equals(_complexData, escherComplexProperty._complexData)) return false;return true;}
// Original:
public void unread(int oneByte) throws IOException {if (buf == null) {throw new IOException();}if (pos == 0) {throw new IOException("Pushback buffer full");}buf[--pos] = (byte) oneByte;}

// Translation:
public virtual void unread(int oneByte){if (buf == null){throw new System.IO.IOException();}if (pos == 0){throw new System.IO.IOException("Pushback buffer full");}buf[--pos] = unchecked((byte)oneByte);}
// Original:
public GetSegmentImportJobsResult getSegmentImportJobs(GetSegmentImportJobsRequest request) {request = beforeClientExecution(request);return executeGetSegmentImportJobs(request);}

// Translation:
public virtual GetSegmentImportJobsResponse GetSegmentImportJobs(GetSegmentImportJobsRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetSegmentImportJobsRequestMarshaller.Instance;options.ResponseUnmarshaller = GetSegmentImportJobsResponseUnmarshaller.Instance;return Invoke<GetSegmentImportJobsResponse>(request, options);}
// Original:
public VerifyEmailAddressResult verifyEmailAddress(VerifyEmailAddressRequest request) {request = beforeClientExecution(request);return executeVerifyEmailAddress(request);}

// Translation:
public virtual VerifyEmailAddressResponse VerifyEmailAddress(VerifyEmailAddressRequest request){var options = new InvokeOptions();options.RequestMarshaller = VerifyEmailAddressRequestMarshaller.Instance;options.ResponseUnmarshaller = VerifyEmailAddressResponseUnmarshaller.Instance;return Invoke<VerifyEmailAddressResponse>(request, options);}
// Original:
public GetTagsResult getTags(GetTagsRequest request) {request = beforeClientExecution(request);return executeGetTags(request);}

// Translation:
public virtual GetTagsResponse GetTags(GetTagsRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetTagsRequestMarshaller.Instance;options.ResponseUnmarshaller = GetTagsResponseUnmarshaller.Instance;return Invoke<GetTagsResponse>(request, options);}
// Original:
public String toString(){StringBuilder sb = new StringBuilder();sb.append( text ).append( '(' );for( Toffs to : termsOffsets )sb.append( to.toString() );sb.append( ')' );return sb.toString();}

// Translation:
public override string ToString(){StringBuilder sb = new StringBuilder();sb.Append(text).Append('(');foreach (Toffs to in termsOffsets)sb.Append(to.ToString());sb.Append(')');return sb.ToString();}
// Original:
public RevFilter clone() {return new Binary(a.clone(), b.clone());}

// Translation:
public override TreeFilter Clone(){return new OrTreeFilter.Binary(a.Clone(), b.Clone());}
// Original:
public StandardTokenizerImpl(java.io.Reader in) {this.zzReader = in;}

// Translation:
public StandardTokenizerImpl(TextReader @in){this.zzReader = @in;}
// Original:
public MoPenFindGroupRequest() {super("MoPen", "2018-02-11", "MoPenFindGroup", "mopen");setProtocol(ProtocolType.HTTPS);setMethod(MethodType.POST);}

// Translation:
public MoPenFindGroupRequest(): base("MoPen", "2018-02-11", "MoPenFindGroup", "mopen", "openAPI"){Protocol = ProtocolType.HTTPS;Method = MethodType.POST;}
// Original:
public static BreakIterator getLineInstance() {return getLineInstance(Locale.getDefault());}

// Translation:
public static java.text.BreakIterator getLineInstance(){return getLineInstance(System.Globalization.CultureInfo.CurrentCulture);}
// Original:
public boolean exists() {return true;}

// Translation:
public virtual bool Exists(){return true;}
// Original:
public LongBuffer asReadOnlyBuffer() {LongToByteBufferAdapter buf = new LongToByteBufferAdapter(byteBuffer.asReadOnlyBuffer());buf.limit = limit;buf.position = position;buf.mark = mark;buf.byteBuffer.order = byteBuffer.order;return buf;}

// Translation:
public override java.nio.LongBuffer asReadOnlyBuffer(){java.nio.LongToByteBufferAdapter buf = new java.nio.LongToByteBufferAdapter(byteBuffer.asReadOnlyBuffer());buf._limit = _limit;buf._position = _position;buf._mark = _mark;buf.byteBuffer._order = byteBuffer._order;return buf;}
// Original:
public void writeBytes(byte[] b, int offset, int length) {assert b.length >= offset + length;if (length == 0) {return;}if (upto == blockSize) {if (currentBlock != null) {addBlock(currentBlock);}currentBlock = new byte[blockSize];upto = 0;}final int offsetEnd = offset + length;while(true) {final int left = offsetEnd - offset;final int blockLeft = blockSize - upto;if (blockLeft < left) {System.arraycopy(b, offset, currentBlock, upto, blockLeft);addBlock(currentBlock);currentBlock = new byte[blockSize];upto = 0;offset += blockLeft;} else {System.arraycopy(b, offset, currentBlock, upto, left);upto += left;break;}}}

// Translation:
public override void WriteBytes(byte[] b, int offset, int length){Debug.Assert(b.Length >= offset + length);if (length == 0){return;}if (outerInstance.upto == outerInstance.blockSize){if (outerInstance.currentBlock != null){outerInstance.blocks.Add(outerInstance.currentBlock);outerInstance.blockEnd.Add(outerInstance.upto);}outerInstance.currentBlock = new byte[outerInstance.blockSize];outerInstance.upto = 0;}int offsetEnd = offset + length;while (true){int left = offsetEnd - offset;int blockLeft = outerInstance.blockSize - outerInstance.upto;if (blockLeft < left){System.Buffer.BlockCopy(b, offset, outerInstance.currentBlock, outerInstance.upto, blockLeft);outerInstance.blocks.Add(outerInstance.currentBlock);outerInstance.blockEnd.Add(outerInstance.blockSize);outerInstance.currentBlock = new byte[outerInstance.blockSize];outerInstance.upto = 0;offset += blockLeft;}else{System.Buffer.BlockCopy(b, offset, outerInstance.currentBlock, outerInstance.upto, left);outerInstance.upto += left;break;}}}
// Original:
public ByteBuffer putFloat(float value) {throw new ReadOnlyBufferException();}

// Translation:
public override java.nio.ByteBuffer putFloat(float value){throw new System.NotImplementedException();}
// Original:
public Class<?> getArgumentClass() {return arg;}

// Translation:
public virtual System.Type getArgumentClass(){return arg;}
// Original:
public GetVaultAccessPolicyResult getVaultAccessPolicy(GetVaultAccessPolicyRequest request) {request = beforeClientExecution(request);return executeGetVaultAccessPolicy(request);}

// Translation:
public virtual GetVaultAccessPolicyResponse GetVaultAccessPolicy(GetVaultAccessPolicyRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetVaultAccessPolicyRequestMarshaller.Instance;options.ResponseUnmarshaller = GetVaultAccessPolicyResponseUnmarshaller.Instance;return Invoke<GetVaultAccessPolicyResponse>(request, options);}
// Original:
public GetReusableDelegationSetLimitResult getReusableDelegationSetLimit(GetReusableDelegationSetLimitRequest request) {request = beforeClientExecution(request);return executeGetReusableDelegationSetLimit(request);}

// Translation:
public virtual GetReusableDelegationSetLimitResponse GetReusableDelegationSetLimit(GetReusableDelegationSetLimitRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetReusableDelegationSetLimitRequestMarshaller.Instance;options.ResponseUnmarshaller = GetReusableDelegationSetLimitResponseUnmarshaller.Instance;return Invoke<GetReusableDelegationSetLimitResponse>(request, options);}
// Original:
public int compareTo( WeightedPhraseInfo other ) {int diff = getStartOffset() - other.getStartOffset();if ( diff != 0 ) {return diff;}diff = getEndOffset() - other.getEndOffset();if ( diff != 0 ) {return diff;}return (int) Math.signum( getBoost() - other.getBoost() );}

// Translation:
public virtual int CompareTo(WeightedPhraseInfo other){int diff = StartOffset - other.StartOffset;if (diff != 0){return diff;}diff = EndOffset - other.EndOffset;if (diff != 0){return diff;}return (int)Math.Sign(Boost - other.Boost);}
// Original:
public StopRelationalDatabaseResult stopRelationalDatabase(StopRelationalDatabaseRequest request) {request = beforeClientExecution(request);return executeStopRelationalDatabase(request);}

// Translation:
public virtual StopRelationalDatabaseResponse StopRelationalDatabase(StopRelationalDatabaseRequest request){var options = new InvokeOptions();options.RequestMarshaller = StopRelationalDatabaseRequestMarshaller.Instance;options.ResponseUnmarshaller = StopRelationalDatabaseResponseUnmarshaller.Instance;return Invoke<StopRelationalDatabaseResponse>(request, options);}
// Original:
public void clear() {Arrays.fill(blocks, 0L);}

// Translation:
public override void Clear(){Arrays.Fill(blocks, 0L);}
// Original:
public UpdateScriptResult updateScript(UpdateScriptRequest request) {request = beforeClientExecution(request);return executeUpdateScript(request);}

// Translation:
public virtual UpdateScriptResponse UpdateScript(UpdateScriptRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateScriptRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateScriptResponseUnmarshaller.Instance;return Invoke<UpdateScriptResponse>(request, options);}
// Original:
public InterpreterRuleContext(ParserRuleContext parent,int invokingStateNumber,int ruleIndex){super(parent, invokingStateNumber);this.ruleIndex = ruleIndex;}

// Translation:
public InterpreterRuleContext(ParserRuleContext parent, int invokingStateNumber, int ruleIndex): base(parent, invokingStateNumber){this.ruleIndex = ruleIndex;}
// Original:
public CreateFileSystemFromBackupResult createFileSystemFromBackup(CreateFileSystemFromBackupRequest request) {request = beforeClientExecution(request);return executeCreateFileSystemFromBackup(request);}

// Translation:
public virtual CreateFileSystemFromBackupResponse CreateFileSystemFromBackup(CreateFileSystemFromBackupRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateFileSystemFromBackupRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateFileSystemFromBackupResponseUnmarshaller.Instance;return Invoke<CreateFileSystemFromBackupResponse>(request, options);}
// Original:
public int getLevelForDistance(double dist) {if (dist == 0){return maxLevels;}int level =  S2Projections.MAX_WIDTH.getMinLevel(dist * DistanceUtils.DEGREES_TO_RADIANS);int roundLevel = level % arity != 0 ? 1 : 0;level = level/arity + roundLevel;return Math.min(maxLevels, level + 1);}

// Translation:
public override int GetLevelForDistance(double dist){if (dist == 0){return m_maxLevels;}int level = GeohashUtils.LookupHashLenForWidthHeight(dist, dist);return Math.Max(Math.Min(level, m_maxLevels), 1);}
// Original:
public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1) {ValueEval ve0;ValueEval ve1;try {ve0 = OperandResolver.getSingleValue(arg0, srcRowIndex, srcColumnIndex);ve1 = OperandResolver.getSingleValue(arg1, srcRowIndex, srcColumnIndex);} catch (EvaluationException e) {return e.getErrorEval();}StringBuilder sb = new StringBuilder();sb.append(getText(ve0));sb.append(getText(ve1));return new StringEval(sb.toString());}

// Translation:
public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1){ValueEval ve0;ValueEval ve1;try{ve0 = OperandResolver.GetSingleValue(arg0, srcRowIndex, srcColumnIndex);ve1 = OperandResolver.GetSingleValue(arg1, srcRowIndex, srcColumnIndex);}catch (EvaluationException e){return e.GetErrorEval();}StringBuilder sb = new StringBuilder();sb.Append(GetText(ve0));sb.Append(GetText(ve1));return new StringEval(sb.ToString());}
// Original:
public static ChartDataSource<Number> fromNumericCellRange(Sheet sheet, CellRangeAddress cellRangeAddress) {return new AbstractCellRangeDataSource<Number>(sheet, cellRangeAddress) {@Override

// Translation:
public static IChartDataSource<double> FromNumericCellRange(ISheet sheet, CellRangeAddress cellRangeAddress) {return new DoubleCellRangeDataSource(sheet, cellRangeAddress);}
// Original:
public static FuncPtg create(LittleEndianInput in) {return create(in.readUShort());}

// Translation:
public static FuncPtg Create(ILittleEndianInput in1) {return Create(in1.ReadUShort());}
// Original:
public InitiateVaultLockResult initiateVaultLock(InitiateVaultLockRequest request) {request = beforeClientExecution(request);return executeInitiateVaultLock(request);}

// Translation:
public virtual InitiateVaultLockResponse InitiateVaultLock(InitiateVaultLockRequest request){var options = new InvokeOptions();options.RequestMarshaller = InitiateVaultLockRequestMarshaller.Instance;options.ResponseUnmarshaller = InitiateVaultLockResponseUnmarshaller.Instance;return Invoke<InitiateVaultLockResponse>(request, options);}
// Original:
public final K getKey() {return key;}

// Translation:
public virtual K getKey(){return key;}
// Original:
public boolean isSet(final int holder){return (holder & _mask) != 0;}

// Translation:
public bool IsSet(int holder){return ((holder & this._mask) != 0);}
// Original:
public DoubleMetaphoneFilter(TokenStream input, int maxCodeLength, boolean inject) {super(input);this.encoder.setMaxCodeLen(maxCodeLength);this.inject = inject;}

// Translation:
public DoubleMetaphoneFilter(TokenStream input, int maxCodeLength, bool inject): base(input){this.encoder.MaxCodeLen = maxCodeLength;this.inject = inject;this.termAtt = AddAttribute<ICharTermAttribute>();this.posAtt = AddAttribute<IPositionIncrementAttribute>();}
// Original:
public boolean changeExternalReference(String oldUrl, String newUrl) {return workbook.changeExternalReference(oldUrl, newUrl);}

// Translation:
public bool ChangeExternalReference(String oldUrl, String newUrl){return workbook.ChangeExternalReference(oldUrl, newUrl);}
// Original:
public DescribeEngineDefaultParametersRequest(String cacheParameterGroupFamily) {setCacheParameterGroupFamily(cacheParameterGroupFamily);}

// Translation:
public DescribeEngineDefaultParametersRequest(string cacheParameterGroupFamily){_cacheParameterGroupFamily = cacheParameterGroupFamily;}
// Original:
public void extendB() {endB++;}

// Translation:
public virtual void ExtendB(){endB++;}
// Original:
public JapaneseReadingFormFilter(TokenStream input, boolean useRomaji) {super(input);this.useRomaji = useRomaji;}

// Translation:
public JapaneseReadingFormFilter(TokenStream input, bool useRomaji): base(input){this.useRomaji = useRomaji;this.termAttr = AddAttribute<ICharTermAttribute>();this.readingAttr = AddAttribute<IReadingAttribute>();}
// Original:
public DeleteContactResult deleteContact(DeleteContactRequest request) {request = beforeClientExecution(request);return executeDeleteContact(request);}

// Translation:
public virtual DeleteContactResponse DeleteContact(DeleteContactRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteContactRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteContactResponseUnmarshaller.Instance;return Invoke<DeleteContactResponse>(request, options);}
// Original:
public static final int next(byte[] b, int ptr, char chrA) {final int sz = b.length;while (ptr < sz) {if (b[ptr++] == chrA)return ptr;}return ptr;}

// Translation:
public static int Next(byte[] b, int ptr, char chrA){int sz = b.Length;while (ptr < sz){if (b[ptr++] == chrA){return ptr;}}return ptr;}
// Original:
public InvokeEndpointResult invokeEndpoint(InvokeEndpointRequest request) {request = beforeClientExecution(request);return executeInvokeEndpoint(request);}

// Translation:
public virtual InvokeEndpointResponse InvokeEndpoint(InvokeEndpointRequest request){var options = new InvokeOptions();options.RequestMarshaller = InvokeEndpointRequestMarshaller.Instance;options.ResponseUnmarshaller = InvokeEndpointResponseUnmarshaller.Instance;return Invoke<InvokeEndpointResponse>(request, options);}