yijunyu/c-to-rust huggingface dataset:
// Original:
public DescribeTableRestoreStatusResult describeTableRestoreStatus(DescribeTableRestoreStatusRequest request) {request = beforeClientExecution(request);return executeDescribeTableRestoreStatus(request);}

// Translation:
public virtual DescribeTableRestoreStatusResponse DescribeTableRestoreStatus(DescribeTableRestoreStatusRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeTableRestoreStatusRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeTableRestoreStatusResponseUnmarshaller.Instance;return Invoke<DescribeTableRestoreStatusResponse>(request, options);}
// Original:
public Edit(int as, int ae, int bs, int be) {beginA = as;endA = ae;beginB = bs;endB = be;}

// Translation:
public Edit(int @as, int ae, int bs, int be){beginA = @as;endA = ae;beginB = bs;endB = be;}
// Original:
public UpdateDomainEndpointOptionsResult updateDomainEndpointOptions(UpdateDomainEndpointOptionsRequest request) {request = beforeClientExecution(request);return executeUpdateDomainEndpointOptions(request);}

// Translation:
public virtual UpdateDomainEndpointOptionsResponse UpdateDomainEndpointOptions(UpdateDomainEndpointOptionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateDomainEndpointOptionsRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateDomainEndpointOptionsResponseUnmarshaller.Instance;return Invoke<UpdateDomainEndpointOptionsResponse>(request, options);}
// Original:
@Override public boolean contains(Object o) {return Impl.this.containsKey(o);}

// Translation:
public override bool contains(object o){return this._enclosing.containsKey(o);}
// Original:
public ParseTreePattern compileParseTreePattern(String pattern, int patternRuleIndex,Lexer lexer){ParseTreePatternMatcher m = new ParseTreePatternMatcher(lexer, this);return m.compile(pattern, patternRuleIndex);}

// Translation:
public virtual ParseTreePattern CompileParseTreePattern(string pattern, int patternRuleIndex, Lexer lexer){ParseTreePatternMatcher m = new ParseTreePatternMatcher(lexer, this);return m.Compile(pattern, patternRuleIndex);}
// Original:
public MalformedInputException(int length) {this.inputLength = length;}

// Translation:
public MalformedInputException(int length){this.inputLength = length;}
// Original:
public void reset() {upto = 0;in.reset();}

// Translation:
public virtual void Reset(){upto = 0;@in.Reset();}
// Original:
public String toString() {return name;}

// Translation:
public override string ToString(){return name;}
// Original:
public DeletePhotoStoreRequest() {super("CloudPhoto", "2017-07-11", "DeletePhotoStore", "cloudphoto");setProtocol(ProtocolType.HTTPS);}

// Translation:
public DeletePhotoStoreRequest(): base("CloudPhoto", "2017-07-11", "DeletePhotoStore", "cloudphoto", "openAPI"){Protocol = ProtocolType.HTTPS;}
// Original:
public GlobalCluster createGlobalCluster(CreateGlobalClusterRequest request) {request = beforeClientExecution(request);return executeCreateGlobalCluster(request);}

// Translation:
public virtual CreateGlobalClusterResponse CreateGlobalCluster(CreateGlobalClusterRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateGlobalClusterRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateGlobalClusterResponseUnmarshaller.Instance;return Invoke<CreateGlobalClusterResponse>(request, options);}
// Original:
public SimpleImmutableEntry(K theKey, V theValue) {key = theKey;value = theValue;}

// Translation:
public SimpleImmutableEntry(K theKey, V theValue){key = theKey;value = theValue;}
// Original:
public String toString(){StringBuilder buffer = new StringBuilder();buffer.append("[SeriesToChartGroup]\n");buffer.append("    .chartGroupIndex      = ").append("0x").append(HexDump.toHex(  getChartGroupIndex ())).append(" (").append( getChartGroupIndex() ).append(" )");buffer.append(System.getProperty("line.separator"));buffer.append("[/SeriesToChartGroup]\n");return buffer.toString();}

// Translation:
public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append("[SeriesToChartGroup]\n");buffer.Append("    .chartGroupIndex      = ").Append("0x").Append(HexDump.ToHex(ChartGroupIndex)).Append(" (").Append(ChartGroupIndex).Append(" )");buffer.Append(Environment.NewLine);buffer.Append("[/SeriesToChartGroup]\n");return buffer.ToString();}
// Original:
public String toString() {return "FAST_" + path.toString(); }

// Translation:
public override string ToString(){return "FAST_" + path.ToString();}
// Original:
public OpenNLPLemmatizerFilterFactory(Map<String,String> args) {super(args);dictionaryFile = get(args, DICTIONARY);lemmatizerModelFile = get(args, LEMMATIZER_MODEL);if (dictionaryFile == null && lemmatizerModelFile == null) {throw new IllegalArgumentException("Configuration Error: missing parameter: at least one of '"+ DICTIONARY + "' and '" + LEMMATIZER_MODEL + "' must be provided.");}if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

// Translation:
public OpenNLPLemmatizerFilterFactory(IDictionary<string, string> args): base(args){dictionaryFile = Get(args, DICTIONARY);lemmatizerModelFile = Get(args, LEMMATIZER_MODEL);if (dictionaryFile == null && lemmatizerModelFile == null){throw new ArgumentException("Configuration Error: missing parameter: at least one of '"+ DICTIONARY + "' and '" + LEMMATIZER_MODEL + "' must be provided.");}if (args.Any()){throw new ArgumentException("Unknown parameters: " + args);}}
// Original:
public Long contentLength() {return this.contentLength;}

// Translation:
public System.Uri BaseUri { get; set; }
// Original:
public void addError(FormatError err) {errors.add(err);}

// Translation:
public virtual void AddError(FormatError err){errors.AddItem(err);}
// Original:
public UpdateUserResult updateUser(UpdateUserRequest request) {request = beforeClientExecution(request);return executeUpdateUser(request);}

// Translation:
public virtual UpdateUserResponse UpdateUser(UpdateUserRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateUserRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateUserResponseUnmarshaller.Instance;return Invoke<UpdateUserResponse>(request, options);}
// Original:
public DeletePartnerEventSourceResult deletePartnerEventSource(DeletePartnerEventSourceRequest request) {request = beforeClientExecution(request);return executeDeletePartnerEventSource(request);}

// Translation:
public virtual DeletePartnerEventSourceResponse DeletePartnerEventSource(DeletePartnerEventSourceRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeletePartnerEventSourceRequestMarshaller.Instance;options.ResponseUnmarshaller = DeletePartnerEventSourceResponseUnmarshaller.Instance;return Invoke<DeletePartnerEventSourceResponse>(request, options);}
// Original:
public WorkflowExecutionInfos listClosedWorkflowExecutions(ListClosedWorkflowExecutionsRequest request) {request = beforeClientExecution(request);return executeListClosedWorkflowExecutions(request);}

// Translation:
public virtual ListClosedWorkflowExecutionsResponse ListClosedWorkflowExecutions(ListClosedWorkflowExecutionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListClosedWorkflowExecutionsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListClosedWorkflowExecutionsResponseUnmarshaller.Instance;return Invoke<ListClosedWorkflowExecutionsResponse>(request, options);}
// Original:
public HSSFFontFormatting createFontFormatting() {return getFontFormatting(true);}

// Translation:
public IFontFormatting CreateFontFormatting(){return GetFontFormatting(true);}
// Original:
public SimpleFragmenter(int fragmentSize) {this.fragmentSize = fragmentSize;}

// Translation:
public SimpleFragmenter(int fragmentSize){this.fragmentSize = fragmentSize;}
// Original:
public DeleteEmailIdentityResult deleteEmailIdentity(DeleteEmailIdentityRequest request) {request = beforeClientExecution(request);return executeDeleteEmailIdentity(request);}

// Translation:
public virtual DeleteEmailIdentityResponse DeleteEmailIdentity(DeleteEmailIdentityRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteEmailIdentityRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteEmailIdentityResponseUnmarshaller.Instance;return Invoke<DeleteEmailIdentityResponse>(request, options);}
// Original:
public ListScriptsResult listScripts(ListScriptsRequest request) {request = beforeClientExecution(request);return executeListScripts(request);}

// Translation:
public virtual ListScriptsResponse ListScripts(ListScriptsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListScriptsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListScriptsResponseUnmarshaller.Instance;return Invoke<ListScriptsResponse>(request, options);}
// Original:
public SnowballFilter(TokenStream input, SnowballStemmer stemmer) {super(input);this.stemmer = stemmer;}

// Translation:
public SnowballFilter(TokenStream input, SnowballProgram stemmer): base(input){this.stemmer = stemmer;this.termAtt = AddAttribute<ICharTermAttribute>();this.keywordAttr = AddAttribute<IKeywordAttribute>();}
// Original:
public DeleteFlowLogsResult deleteFlowLogs(DeleteFlowLogsRequest request) {request = beforeClientExecution(request);return executeDeleteFlowLogs(request);}

// Translation:
public virtual DeleteFlowLogsResponse DeleteFlowLogs(DeleteFlowLogsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteFlowLogsRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteFlowLogsResponseUnmarshaller.Instance;return Invoke<DeleteFlowLogsResponse>(request, options);}
// Original:
public CreateIdentityPoolResult createIdentityPool(CreateIdentityPoolRequest request) {request = beforeClientExecution(request);return executeCreateIdentityPool(request);}

// Translation:
public virtual CreateIdentityPoolResponse CreateIdentityPool(CreateIdentityPoolRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateIdentityPoolRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateIdentityPoolResponseUnmarshaller.Instance;return Invoke<CreateIdentityPoolResponse>(request, options);}
// Original:
public String distanceSubQueryNotAllowed() {Iterator<?> sqi = getSubQueriesIterator();while (sqi.hasNext()) {Object leq = sqi.next();if (leq instanceof DistanceSubQuery) {DistanceSubQuery dsq = (DistanceSubQuery) leq;String m = dsq.distanceSubQueryNotAllowed();if (m != null) {return m;}} else {return "Operator " + getOperatorName() + " does not allow subquery " + leq.toString();}}return null; }

// Translation:
public virtual string DistanceSubQueryNotAllowed(){var sqi = GetSubQueriesEnumerator();while (sqi.MoveNext()){var leq = sqi.Current;if (leq is IDistanceSubQuery){var dsq = sqi.Current as IDistanceSubQuery;string m = dsq.DistanceSubQueryNotAllowed();if (m != null){return m;}}else{return "Operator " + OperatorName + " does not allow subquery " + leq.ToString();}}return null; }
// Original:
public static String getNodeText(Tree t, List<String> ruleNames) {if ( ruleNames!=null ) {if ( t instanceof RuleContext ) {int ruleIndex = ((RuleContext)t).getRuleContext().getRuleIndex();String ruleName = ruleNames.get(ruleIndex);int altNumber = ((RuleContext) t).getAltNumber();if ( altNumber!=ATN.INVALID_ALT_NUMBER ) {return ruleName+":"+altNumber;}return ruleName;}else if ( t instanceof ErrorNode) {return t.toString();}else if ( t instanceof TerminalNode) {Token symbol = ((TerminalNode)t).getSymbol();if (symbol != null) {String s = symbol.getText();return s;}}}Object payload = t.getPayload();if ( payload instanceof Token ) {return ((Token)payload).getText();}return t.getPayload().toString();}

// Translation:
public static string GetNodeText(ITree t, IList<string> ruleNames){if (ruleNames != null){if (t is RuleContext){int ruleIndex = ((RuleContext)t).RuleIndex;string ruleName = ruleNames[ruleIndex];int altNumber = ((RuleContext)t).getAltNumber();if ( altNumber!=Atn.ATN.INVALID_ALT_NUMBER ) {return ruleName+":"+altNumber;}return ruleName;}else{if (t is IErrorNode){return t.ToString();}else{if (t is ITerminalNode){IToken symbol = ((ITerminalNode)t).Symbol;if (symbol != null){string s = symbol.Text;return s;}}}}}object payload = t.Payload;if (payload is IToken){return ((IToken)payload).Text;}return t.Payload.ToString();}
// Original:
public int last() {if (sentenceStarts.length > 0) {currentSentence = sentenceStarts.length - 1;text.setIndex(text.getEndIndex());} else { currentSentence = 0;text.setIndex(text.getBeginIndex());}return current();}

// Translation:
public override int Last(){if (sentenceStarts.Length > 0){currentSentence = sentenceStarts.Length - 1;text.SetIndex(text.EndIndex);}else{ currentSentence = 0;text.SetIndex(text.BeginIndex);}return Current;}
// Original:
public HSSFRichTextString createRichTextString(String text) {return new HSSFRichTextString(text);}

// Translation:
public NPOI.SS.UserModel.IRichTextString CreateRichTextString(String text){return new HSSFRichTextString(text);}
// Original:
public PushbackReader(Reader in) {super(in);buf = new char[1];pos = 1;}

// Translation:
public PushbackReader(java.io.Reader @in) : base(@in){buf = new char[1];pos = 1;}
// Original:
public List<ParseTree> getAll(String label) {List<ParseTree> nodes = labels.get(label);if ( nodes==null ) {return Collections.emptyList();}return nodes;}

// Translation:
public virtual IList<IParseTree> GetAll(string label){IList<IParseTree> nodes = labels.Get(label);if (nodes == null){return Sharpen.Collections.EmptyList<IParseTree>();}return nodes;}
// Original:
public InternalWorkbook getStubWorkbook() {return createStubWorkbook(getExternSheetRecords(), getBoundSheetRecords(),getSSTRecord());}

// Translation:
public InternalWorkbook GetStubWorkbook(){return CreateStubWorkbook(GetExternSheetRecords(), GetBoundSheetRecords(),GetSSTRecord());}
// Original:
public ReactivatePhotosRequest() {super("CloudPhoto", "2017-07-11", "ReactivatePhotos", "cloudphoto");setProtocol(ProtocolType.HTTPS);}

// Translation:
public ReactivatePhotosRequest(): base("CloudPhoto", "2017-07-11", "ReactivatePhotos", "cloudphoto", "openAPI"){Protocol = ProtocolType.HTTPS;}
// Original:
public DecisionTask pollForDecisionTask(PollForDecisionTaskRequest request) {request = beforeClientExecution(request);return executePollForDecisionTask(request);}

// Translation:
public virtual PollForDecisionTaskResponse PollForDecisionTask(PollForDecisionTaskRequest request){var options = new InvokeOptions();options.RequestMarshaller = PollForDecisionTaskRequestMarshaller.Instance;options.ResponseUnmarshaller = PollForDecisionTaskResponseUnmarshaller.Instance;return Invoke<PollForDecisionTaskResponse>(request, options);}
// Original:
public void write(LittleEndianOutput out) {out.writeByte(getSid() + getPtgClass());writeCoordinates(out);}

// Translation:
public override void Write(ILittleEndianOutput out1){out1.WriteByte(Sid + PtgClass);WriteCoordinates(out1);}
// Original:
public Ref getTarget() {return target;}

// Translation:
public virtual Ref GetTarget(){return target;}
// Original:
public CreateTagsResult createTags(CreateTagsRequest request) {request = beforeClientExecution(request);return executeCreateTags(request);}

// Translation:
public virtual CreateTagsResponse CreateTags(CreateTagsRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateTagsRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateTagsResponseUnmarshaller.Instance;return Invoke<CreateTagsResponse>(request, options);}
// Original:
public UpdateUserPhoneConfigResult updateUserPhoneConfig(UpdateUserPhoneConfigRequest request) {request = beforeClientExecution(request);return executeUpdateUserPhoneConfig(request);}

// Translation:
public virtual UpdateUserPhoneConfigResponse UpdateUserPhoneConfig(UpdateUserPhoneConfigRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateUserPhoneConfigRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateUserPhoneConfigResponseUnmarshaller.Instance;return Invoke<UpdateUserPhoneConfigResponse>(request, options);}
// Original:
public PersonIdent getSourceAuthor(int idx) {return sourceAuthors[idx];}

// Translation:
public virtual PersonIdent GetSourceAuthor(int idx){return sourceAuthors[idx];}
// Original:
public void setLength(long sz) {setLength((int) sz);}

// Translation:
public virtual void SetLength(int sz){NB.EncodeInt32(info, infoOffset + P_SIZE, sz);}
// Original:
public GetServerCertificateRequest(String serverCertificateName) {setServerCertificateName(serverCertificateName);}

// Translation:
public GetServerCertificateRequest(string serverCertificateName){_serverCertificateName = serverCertificateName;}
// Original:
public CreateStreamingDistributionWithTagsResult createStreamingDistributionWithTags(CreateStreamingDistributionWithTagsRequest request) {request = beforeClientExecution(request);return executeCreateStreamingDistributionWithTags(request);}

// Translation:
public virtual CreateStreamingDistributionWithTagsResponse CreateStreamingDistributionWithTags(CreateStreamingDistributionWithTagsRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateStreamingDistributionWithTagsRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateStreamingDistributionWithTagsResponseUnmarshaller.Instance;return Invoke<CreateStreamingDistributionWithTagsResponse>(request, options);}
// Original:
public DescribeNotificationSubscriptionsResult describeNotificationSubscriptions(DescribeNotificationSubscriptionsRequest request) {request = beforeClientExecution(request);return executeDescribeNotificationSubscriptions(request);}

// Translation:
public virtual DescribeNotificationSubscriptionsResponse DescribeNotificationSubscriptions(DescribeNotificationSubscriptionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeNotificationSubscriptionsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeNotificationSubscriptionsResponseUnmarshaller.Instance;return Invoke<DescribeNotificationSubscriptionsResponse>(request, options);}
// Original:
public String toString() {StringBuilder buffer = new StringBuilder();buffer.append("[CHARTFRTINFO]\n");buffer.append("    .rt           =").append(HexDump.shortToHex(rt)).append('\n');buffer.append("    .grbitFrt     =").append(HexDump.shortToHex(grbitFrt)).append('\n');buffer.append("    .verOriginator=").append(HexDump.byteToHex(verOriginator)).append('\n');buffer.append("    .verWriter    =").append(HexDump.byteToHex(verOriginator)).append('\n');buffer.append("    .nCFRTIDs     =").append(HexDump.shortToHex(rgCFRTID.length)).append('\n');buffer.append("[/CHARTFRTINFO]\n");return buffer.toString();}

// Translation:
public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append("[CHARTFRTINFO]\n");buffer.Append("    .rt           =").Append(HexDump.ShortToHex(rt)).Append('\n');buffer.Append("    .grbitFrt     =").Append(HexDump.ShortToHex(grbitFrt)).Append('\n');buffer.Append("    .verOriginator=").Append(HexDump.ByteToHex(verOriginator)).Append('\n');buffer.Append("    .verWriter    =").Append(HexDump.ByteToHex(verOriginator)).Append('\n');buffer.Append("    .nCFRTIDs     =").Append(HexDump.ShortToHex(rgCFRTID.Length)).Append('\n');buffer.Append("[/CHARTFRTINFO]\n");return buffer.ToString();}
// Original:
public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0) {double result;if (arg0 instanceof RefEval) {result = CountUtils.countMatchingCellsInRef((RefEval) arg0, predicate);} else if (arg0 instanceof ThreeDEval) {result = CountUtils.countMatchingCellsInArea((ThreeDEval) arg0, predicate);} else {throw new IllegalArgumentException("Bad range arg type (" + arg0.getClass().getName() + ")");}return new NumberEval(result);}

// Translation:
public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0){double result;if (arg0 is RefEval){result = CountUtils.CountMatchingCellsInRef((RefEval)arg0, predicate);}else if (arg0 is ThreeDEval){result = CountUtils.CountMatchingCellsInArea((ThreeDEval)arg0, predicate);}else{throw new ArgumentException("Bad range arg type (" + arg0.GetType().Name + ")");}return new NumberEval(result);}
// Original:
public UpdateRestApiResult updateRestApi(UpdateRestApiRequest request) {request = beforeClientExecution(request);return executeUpdateRestApi(request);}

// Translation:
public virtual UpdateRestApiResponse UpdateRestApi(UpdateRestApiRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateRestApiRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateRestApiResponseUnmarshaller.Instance;return Invoke<UpdateRestApiResponse>(request, options);}
// Original:
public int size() {return ConcurrentHashMap.this.size();}

// Translation:
public override int size(){return this._enclosing._size;}
// Original:
public EscherSimpleProperty( short propertyNumber, boolean isComplex, boolean isBlipId, int propertyValue ) {super( propertyNumber, isComplex, isBlipId );this.propertyValue = propertyValue;}

// Translation:
public EscherSimpleProperty(short propertyNumber, bool isComplex, bool isBlipId, int propertyValue):base(propertyNumber, isComplex, isBlipId){this.propertyValue = propertyValue;}
// Original:
public static boolean isEndOfRowBlock(int sid) {switch(sid) {case ViewDefinitionRecord.sid:case DrawingRecord.sid:case DrawingSelectionRecord.sid:case ObjRecord.sid:case TextObjectRecord.sid:case ColumnInfoRecord.sid: case GutsRecord.sid:   case WindowOneRecord.sid:case WindowTwoRecord.sid:return true;case DVALRecord.sid:return true;case EOFRecord.sid:throw new RuntimeException("Found EOFRecord before WindowTwoRecord was encountered");}return PageSettingsBlock.isComponentRecord(sid);}

// Translation:
public static bool IsEndOfRowBlock(int sid){switch (sid){case ViewDefinitionRecord.sid:                case DrawingRecord.sid:case DrawingSelectionRecord.sid:case ObjRecord.sid:case TextObjectRecord.sid:case ColumnInfoRecord.sid: case GutsRecord.sid:   case WindowOneRecord.sid:case WindowTwoRecord.sid:return true;case DVALRecord.sid:return true;case EOFRecord.sid:throw new InvalidOperationException("Found EOFRecord before WindowTwoRecord was encountered");}return PageSettingsBlock.IsComponentRecord(sid);}
// Original:
public RegistrantProfileRealNameVerificationRequest() {super("Domain-intl", "2017-12-18", "RegistrantProfileRealNameVerification", "domain");setMethod(MethodType.POST);}

// Translation:
public RegistrantProfileRealNameVerificationRequest(): base("Domain-intl", "2017-12-18", "RegistrantProfileRealNameVerification", "domain", "openAPI"){Method = MethodType.POST;}
// Original:
public CreateProfileResult createProfile(CreateProfileRequest request) {request = beforeClientExecution(request);return executeCreateProfile(request);}

// Translation:
public virtual CreateProfileResponse CreateProfile(CreateProfileRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateProfileRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateProfileResponseUnmarshaller.Instance;return Invoke<CreateProfileResponse>(request, options);}
// Original:
public ObjectId idFor(int type, byte[] data, int off, int len) {SHA1 md = SHA1.newInstance();md.update(Constants.encodedTypeString(type));md.update((byte) ' ');md.update(Constants.encodeASCII(len));md.update((byte) 0);md.update(data, off, len);return md.toObjectId();}

// Translation:
public virtual ObjectId IdFor(int type, byte[] data, int off, int len){MessageDigest md = Digest();md.Update(Constants.EncodedTypeString(type));md.Update(unchecked((byte)' '));md.Update(Constants.EncodeASCII(len));md.Update(unchecked((byte)0));md.Update(data, off, len);return ObjectId.FromRaw(md.Digest());}
// Original:
public EndSubRecord clone() {return copy();}

// Translation:
public override Object Clone(){EndSubRecord rec = new EndSubRecord();return rec;}
// Original:
public SearchRepoRequest() {super("cr", "2016-06-07", "SearchRepo", "cr");setUriPattern("/search");setMethod(MethodType.GET);}

// Translation:
public SearchRepoRequest(): base("cr", "2016-06-07", "SearchRepo", "cr", "openAPI"){UriPattern = "/search";Method = MethodType.GET;}