yijunyu/c-to-rust huggingface dataset:
// Original:
public DisassociateRepositoryResult disassociateRepository(DisassociateRepositoryRequest request) {request = beforeClientExecution(request);return executeDisassociateRepository(request);}

// Translation:
public virtual DisassociateRepositoryResponse DisassociateRepository(DisassociateRepositoryRequest request){var options = new InvokeOptions();options.RequestMarshaller = DisassociateRepositoryRequestMarshaller.Instance;options.ResponseUnmarshaller = DisassociateRepositoryResponseUnmarshaller.Instance;return Invoke<DisassociateRepositoryResponse>(request, options);}
// Original:
public DescribeSpotPriceHistoryResult describeSpotPriceHistory() {return describeSpotPriceHistory(new DescribeSpotPriceHistoryRequest());}

// Translation:
public virtual DescribeSpotPriceHistoryResponse DescribeSpotPriceHistory(){return DescribeSpotPriceHistory(new DescribeSpotPriceHistoryRequest());}
// Original:
public UpdateRepoSourceRepoRequest() {super("cr", "2016-06-07", "UpdateRepoSourceRepo", "cr");setUriPattern("/repos/[RepoNamespace]/[RepoName]/sourceRepo");setMethod(MethodType.POST);}

// Translation:
public UpdateRepoSourceRepoRequest(): base("cr", "2016-06-07", "UpdateRepoSourceRepo", "cr", "openAPI"){UriPattern = "/repos/[RepoNamespace]/[RepoName]/sourceRepo";Method = MethodType.POST;}
// Original:
public boolean isHidden() {if (path.isEmpty()) {return false;}return getName().startsWith(".");}

// Translation:
public bool isHidden(){if (string.IsNullOrEmpty(path)){return false;}return getName().StartsWith(".");}
// Original:
public PaneRecord(RecordInputStream in) {field_1_x          = in.readShort();field_2_y          = in.readShort();field_3_topRow     = in.readShort();field_4_leftColumn = in.readShort();field_5_activePane = in.readShort();}

// Translation:
public PaneRecord(RecordInputStream in1){field_1_x = in1.ReadShort();field_2_y = in1.ReadShort();field_3_topRow = in1.ReadShort();field_4_leftColumn = in1.ReadShort();field_5_activePane = in1.ReadShort();}
// Original:
public StartGameSessionPlacementResult startGameSessionPlacement(StartGameSessionPlacementRequest request) {request = beforeClientExecution(request);return executeStartGameSessionPlacement(request);}

// Translation:
public virtual StartGameSessionPlacementResponse StartGameSessionPlacement(StartGameSessionPlacementRequest request){var options = new InvokeOptions();options.RequestMarshaller = StartGameSessionPlacementRequestMarshaller.Instance;options.ResponseUnmarshaller = StartGameSessionPlacementResponseUnmarshaller.Instance;return Invoke<StartGameSessionPlacementResponse>(request, options);}
// Original:
public int getDFASize(int decision) {DFA decisionToDFA = atnSimulator.decisionToDFA[decision];return decisionToDFA.states.size();}

// Translation:
public int getDFASize(int decision){DFA decisionToDFA = atnSimulator.decisionToDFA[decision];return decisionToDFA.states.Count;}
// Original:
public int fillFields(byte[] data, int offset, EscherRecordFactory recordFactory) {int bytesRemaining = readHeader( data, offset );int pos            = offset + 8;remainingData = (bytesRemaining == 0) ? EMPTY : IOUtils.safelyAllocate(bytesRemaining, MAX_RECORD_LENGTH);System.arraycopy( data, pos, remainingData, 0, bytesRemaining );return 8 + bytesRemaining;}

// Translation:
public override int FillFields(byte[] data, int offset, IEscherRecordFactory recordFactory){int bytesRemaining = ReadHeader(data, offset);int pos = offset + 8;remainingData = new byte[bytesRemaining];Array.Copy(data, pos, remainingData, 0, bytesRemaining);return 8 + bytesRemaining;}
// Original:
public void startFragment(TextFragment newFragment) {foundTerms = new HashSet<>();totalScore = 0;}

// Translation:
public virtual void StartFragment(TextFragment newFragment){foundTerms = new JCG.HashSet<string>();totalScore = 0;}
// Original:
public boolean equals(ATNConfig other) {if (this == other) {return true;}else if (!(other instanceof LexerATNConfig)) {return false;}LexerATNConfig lexerOther = (LexerATNConfig)other;if (passedThroughNonGreedyDecision != lexerOther.passedThroughNonGreedyDecision) {return false;}if (!ObjectEqualityComparator.INSTANCE.equals(lexerActionExecutor, lexerOther.lexerActionExecutor)) {return false;}return super.equals(other);}

// Translation:
public override bool Equals(ATNConfig other){if (this == other){return true;}else if (!(other is LexerATNConfig)){return false;}LexerATNConfig lexerOther = (LexerATNConfig)other;if (passedThroughNonGreedyDecision != lexerOther.passedThroughNonGreedyDecision){return false;}if (!(lexerActionExecutor==null ? lexerOther.lexerActionExecutor==null : lexerActionExecutor.Equals(lexerOther.lexerActionExecutor))){return false;}return base.Equals(other);}
// Original:
public DescribeCacheParameterGroupsRequest(String cacheParameterGroupName) {setCacheParameterGroupName(cacheParameterGroupName);}

// Translation:
public DescribeCacheParameterGroupsRequest(string cacheParameterGroupName){_cacheParameterGroupName = cacheParameterGroupName;}
// Original:
public String toString() {StringBuilder buffer = new StringBuilder();buffer.append("    [Pattern Formatting]\n");buffer.append("          .fillpattern= ").append(Integer.toHexString(getFillPattern())).append("\n");buffer.append("          .fgcoloridx= ").append(Integer.toHexString(getFillForegroundColor())).append("\n");buffer.append("          .bgcoloridx= ").append(Integer.toHexString(getFillBackgroundColor())).append("\n");buffer.append("    [/Pattern Formatting]\n");return buffer.toString();}

// Translation:
public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append("    [Pattern Formatting]\n");buffer.Append("          .Fillpattern= ").Append(StringUtil.ToHexString((int) FillPattern)).Append("\n");buffer.Append("          .fgcoloridx= ").Append(StringUtil.ToHexString(FillForegroundColor)).Append("\n");buffer.Append("          .bgcoloridx= ").Append(StringUtil.ToHexString(FillBackgroundColor)).Append("\n");buffer.Append("    [/Pattern Formatting]\n");return buffer.ToString();}
// Original:
public boolean equals(Object o) {return o instanceof FileKey && path.equals(((FileKey) o).path);}

// Translation:
public override bool Equals(object o){return o is RepositoryCache.FileKey && path.Equals(((RepositoryCache.FileKey)o).path);}
// Original:
public UntagAttendeeResult untagAttendee(UntagAttendeeRequest request) {request = beforeClientExecution(request);return executeUntagAttendee(request);}

// Translation:
public virtual UntagAttendeeResponse UntagAttendee(UntagAttendeeRequest request){var options = new InvokeOptions();options.RequestMarshaller = UntagAttendeeRequestMarshaller.Instance;options.ResponseUnmarshaller = UntagAttendeeResponseUnmarshaller.Instance;return Invoke<UntagAttendeeResponse>(request, options);}
// Original:
public String toString(){StringBuilder buffer = new StringBuilder();buffer.append("[END]\n");buffer.append("[/END]\n");return buffer.toString();}

// Translation:
public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append("[END]\n");buffer.Append("[/END]\n");return buffer.ToString();}
// Original:
public MultiTerms(Terms[] subs, ReaderSlice[] subSlices) throws IOException { this.subs = subs;this.subSlices = subSlices;assert subs.length > 0 : "inefficient: don't use MultiTerms over one sub";boolean _hasFreqs = true;boolean _hasOffsets = true;boolean _hasPositions = true;boolean _hasPayloads = false;for(int i=0;i<subs.length;i++) {_hasFreqs &= subs[i].hasFreqs();_hasOffsets &= subs[i].hasOffsets();_hasPositions &= subs[i].hasPositions();_hasPayloads |= subs[i].hasPayloads();}hasFreqs = _hasFreqs;hasOffsets = _hasOffsets;hasPositions = _hasPositions;hasPayloads = hasPositions && _hasPayloads; }

// Translation:
public MultiTerms(Terms[] subs, ReaderSlice[] subSlices){this.subs = subs;this.subSlices = subSlices;IComparer<BytesRef> _termComp = null;Debug.Assert(subs.Length > 0, "inefficient: don't use MultiTerms over one sub");bool _hasFreqs = true;bool _hasOffsets = true;bool _hasPositions = true;bool _hasPayloads = false;for (int i = 0; i < subs.Length; i++){if (_termComp == null){_termComp = subs[i].Comparer;}else{IComparer<BytesRef> subTermComp = subs[i].Comparer;if (subTermComp != null && !subTermComp.Equals(_termComp)){throw new InvalidOperationException("sub-readers have different BytesRef.Comparers; cannot merge");}}_hasFreqs &= subs[i].HasFreqs;_hasOffsets &= subs[i].HasOffsets;_hasPositions &= subs[i].HasPositions;_hasPayloads |= subs[i].HasPayloads;}termComp = _termComp;hasFreqs = _hasFreqs;hasOffsets = _hasOffsets;hasPositions = _hasPositions;hasPayloads = hasPositions && _hasPayloads; }
// Original:
public DescribeGameSessionPlacementResult describeGameSessionPlacement(DescribeGameSessionPlacementRequest request) {request = beforeClientExecution(request);return executeDescribeGameSessionPlacement(request);}

// Translation:
public virtual DescribeGameSessionPlacementResponse DescribeGameSessionPlacement(DescribeGameSessionPlacementRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeGameSessionPlacementRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeGameSessionPlacementResponseUnmarshaller.Instance;return Invoke<DescribeGameSessionPlacementResponse>(request, options);}
// Original:
public SynonymMap(FST<BytesRef> fst, BytesRefHash words, int maxHorizontalContext) {this.fst = fst;this.words = words;this.maxHorizontalContext = maxHorizontalContext;}

// Translation:
public SynonymMap(FST<BytesRef> fst, BytesRefHash words, int maxHorizontalContext){this.fst = fst;this.words = words;this.maxHorizontalContext = maxHorizontalContext;}
// Original:
public DeleteTrialComponentResult deleteTrialComponent(DeleteTrialComponentRequest request) {request = beforeClientExecution(request);return executeDeleteTrialComponent(request);}

// Translation:
public virtual DeleteTrialComponentResponse DeleteTrialComponent(DeleteTrialComponentRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteTrialComponentRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteTrialComponentResponseUnmarshaller.Instance;return Invoke<DeleteTrialComponentResponse>(request, options);}
// Original:
public RevisionSyntaxException(String revstr) {this.revstr = revstr;}

// Translation:
public RevisionSyntaxException(string revstr){this.revstr = revstr;}
// Original:
public void startWorker() {startWorkers(1);}

// Translation:
public virtual void StartWorker(){StartWorkers(1);}
// Original:
public SubscribeToEventResult subscribeToEvent(SubscribeToEventRequest request) {request = beforeClientExecution(request);return executeSubscribeToEvent(request);}

// Translation:
public virtual SubscribeToEventResponse SubscribeToEvent(SubscribeToEventRequest request){var options = new InvokeOptions();options.RequestMarshaller = SubscribeToEventRequestMarshaller.Instance;options.ResponseUnmarshaller = SubscribeToEventResponseUnmarshaller.Instance;return Invoke<SubscribeToEventResponse>(request, options);}
// Original:
public PutScheduledUpdateGroupActionResult putScheduledUpdateGroupAction(PutScheduledUpdateGroupActionRequest request) {request = beforeClientExecution(request);return executePutScheduledUpdateGroupAction(request);}

// Translation:
public virtual PutScheduledUpdateGroupActionResponse PutScheduledUpdateGroupAction(PutScheduledUpdateGroupActionRequest request){var options = new InvokeOptions();options.RequestMarshaller = PutScheduledUpdateGroupActionRequestMarshaller.Instance;options.ResponseUnmarshaller = PutScheduledUpdateGroupActionResponseUnmarshaller.Instance;return Invoke<PutScheduledUpdateGroupActionResponse>(request, options);}
// Original:
public int doLogic() throws Exception {if (maxNumSegments == -1) {throw new IllegalStateException("required argument (maxNumSegments) was not specified");}IndexWriter iw = getRunData().getIndexWriter();iw.forceMerge(maxNumSegments);return 1;}

// Translation:
public override int DoLogic(){if (maxNumSegments == -1){throw new InvalidOperationException("required argument (maxNumSegments) was not specified");}IndexWriter iw = RunData.IndexWriter;iw.ForceMerge(maxNumSegments);return 1;}
// Original:
public String getSheetName(int sheetIndex) {return _uBook.getSheetName(sheetIndex);}

// Translation:
public String GetSheetName(int sheetIndex){return _uBook.GetSheetName(sheetIndex);}
// Original:
public DescribeConnectionLoaResult describeConnectionLoa(DescribeConnectionLoaRequest request) {request = beforeClientExecution(request);return executeDescribeConnectionLoa(request);}

// Translation:
public virtual DescribeConnectionLoaResponse DescribeConnectionLoa(DescribeConnectionLoaRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeConnectionLoaRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeConnectionLoaResponseUnmarshaller.Instance;return Invoke<DescribeConnectionLoaResponse>(request, options);}
// Original:
public String toString() {StringBuilder buffer = new StringBuilder();buffer.append("[NOTE]\n");buffer.append("    .row    = ").append(field_1_row).append("\n");buffer.append("    .col    = ").append(field_2_col).append("\n");buffer.append("    .flags  = ").append(field_3_flags).append("\n");buffer.append("    .shapeid= ").append(field_4_shapeid).append("\n");buffer.append("    .author = ").append(field_6_author).append("\n");buffer.append("[/NOTE]\n");return buffer.toString();}

// Translation:
public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append("[NOTE]\n");buffer.Append("    .recordid = 0x" + StringUtil.ToHexString(Sid) + ", size = " + RecordSize + "\n");buffer.Append("    .row =     " + field_1_row + "\n");buffer.Append("    .col =     " + field_2_col + "\n");buffer.Append("    .flags =   " + field_3_flags + "\n");buffer.Append("    .shapeid = " + field_4_shapeid + "\n");buffer.Append("    .author =  " + field_6_author + "\n");buffer.Append("[/NOTE]\n");return buffer.ToString();}
// Original:
public PipedInputStream(PipedOutputStream out, int pipeSize) throws IOException {this(pipeSize);connect(out);}

// Translation:
public PipedInputStream(java.io.PipedOutputStream @out, int pipeSize) : this(pipeSize){throw new System.NotImplementedException();}
// Original:
public String toString() {return description();}

// Translation:
public override string ToString(){return GetDescription();}
// Original:
public synchronized Credential getCredential() {if (null == credential && null != icredential) {credential = icredential.fresh();}return credential;}

// Translation:
public Credential GetCredential(){if (null == _credential && null != iCredentialProvider){_credential = iCredentialProvider.Fresh();}return _credential;}
// Original:
public OptionGroup copyOptionGroup(CopyOptionGroupRequest request) {request = beforeClientExecution(request);return executeCopyOptionGroup(request);}

// Translation:
public virtual CopyOptionGroupResponse CopyOptionGroup(CopyOptionGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = CopyOptionGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = CopyOptionGroupResponseUnmarshaller.Instance;return Invoke<CopyOptionGroupResponse>(request, options);}
// Original:
public InfoSubRecord(RecordInputStream in){field_1_stream_pos        = in.readInt();field_2_bucket_sst_offset = in.readShort();field_3_zero              = in.readShort();}

// Translation:
public InfoSubRecord(RecordInputStream in1){field_1_stream_pos = in1.ReadInt();field_2_bucket_sst_offset = in1.ReadShort();field_3_zero = in1.ReadShort();}
// Original:
public TreeFilter clone() {final TreeFilter[] s = new TreeFilter[subfilters.length];for (int i = 0; i < s.length; i++)s[i] = subfilters[i].clone();return new List(s);}

// Translation:
public override TreeFilter Clone(){TreeFilter[] s = new TreeFilter[subfilters.Length];for (int i = 0; i < s.Length; i++){s[i] = subfilters[i].Clone();}return new OrTreeFilter.List(s);}
// Original:
public SendAlexaOfferToMasterResult sendAlexaOfferToMaster(SendAlexaOfferToMasterRequest request) {request = beforeClientExecution(request);return executeSendAlexaOfferToMaster(request);}

// Translation:
public virtual SendAlexaOfferToMasterResponse SendAlexaOfferToMaster(SendAlexaOfferToMasterRequest request){var options = new InvokeOptions();options.RequestMarshaller = SendAlexaOfferToMasterRequestMarshaller.Instance;options.ResponseUnmarshaller = SendAlexaOfferToMasterResponseUnmarshaller.Instance;return Invoke<SendAlexaOfferToMasterResponse>(request, options);}
// Original:
public DescribeEndpointConfigResult describeEndpointConfig(DescribeEndpointConfigRequest request) {request = beforeClientExecution(request);return executeDescribeEndpointConfig(request);}

// Translation:
public virtual DescribeEndpointConfigResponse DescribeEndpointConfig(DescribeEndpointConfigRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeEndpointConfigRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeEndpointConfigResponseUnmarshaller.Instance;return Invoke<DescribeEndpointConfigResponse>(request, options);}
// Original:
public PushCommand setProgressMonitor(ProgressMonitor monitor) {checkCallable();if (monitor == null) {monitor = NullProgressMonitor.INSTANCE;}this.monitor = monitor;return this;}

// Translation:
public virtual NGit.Api.PushCommand SetProgressMonitor(ProgressMonitor monitor){CheckCallable();this.monitor = monitor;return this;}
// Original:
public FloatBuffer get(float[] dst, int dstOffset, int floatCount) {byteBuffer.limit(limit * SizeOf.FLOAT);byteBuffer.position(position * SizeOf.FLOAT);if (byteBuffer instanceof DirectByteBuffer) {((DirectByteBuffer) byteBuffer).get(dst, dstOffset, floatCount);} else {((HeapByteBuffer) byteBuffer).get(dst, dstOffset, floatCount);}this.position += floatCount;return this;}

// Translation:
public override java.nio.FloatBuffer get(float[] dst, int dstOffset, int floatCount){byteBuffer.limit(_limit * libcore.io.SizeOf.FLOAT);byteBuffer.position(_position * libcore.io.SizeOf.FLOAT);if (byteBuffer is java.nio.DirectByteBuffer){((java.nio.DirectByteBuffer)byteBuffer).get(dst, dstOffset, floatCount);}else{((java.nio.HeapByteBuffer)byteBuffer).get(dst, dstOffset, floatCount);}this._position += floatCount;return this;}
// Original:
public boolean shouldBeRecursive() {for (TreeFilter f : subfilters)if (f.shouldBeRecursive())return true;return false;}

// Translation:
public override bool ShouldBeRecursive(){foreach (TreeFilter f in subfilters){if (f.ShouldBeRecursive()){return true;}}return false;}
// Original:
public static void putUnicodeLE(String input, LittleEndianOutput out) {byte[] bytes = input.getBytes(UTF16LE);out.write(bytes);}

// Translation:
public static void PutUnicodeLE(String input, ILittleEndianOutput out1){byte[] bytes = UTF16LE.GetBytes(input);out1.Write(bytes);}
// Original:
public ReservedNode acceptReservedNodeExchange(AcceptReservedNodeExchangeRequest request) {request = beforeClientExecution(request);return executeAcceptReservedNodeExchange(request);}

// Translation:
public virtual AcceptReservedNodeExchangeResponse AcceptReservedNodeExchange(AcceptReservedNodeExchangeRequest request){var options = new InvokeOptions();options.RequestMarshaller = AcceptReservedNodeExchangeRequestMarshaller.Instance;options.ResponseUnmarshaller = AcceptReservedNodeExchangeResponseUnmarshaller.Instance;return Invoke<AcceptReservedNodeExchangeResponse>(request, options);}
// Original:
public ClusterSecurityGroup authorizeClusterSecurityGroupIngress(AuthorizeClusterSecurityGroupIngressRequest request) {request = beforeClientExecution(request);return executeAuthorizeClusterSecurityGroupIngress(request);}

// Translation:
public virtual AuthorizeClusterSecurityGroupIngressResponse AuthorizeClusterSecurityGroupIngress(AuthorizeClusterSecurityGroupIngressRequest request){var options = new InvokeOptions();options.RequestMarshaller = AuthorizeClusterSecurityGroupIngressRequestMarshaller.Instance;options.ResponseUnmarshaller = AuthorizeClusterSecurityGroupIngressResponseUnmarshaller.Instance;return Invoke<AuthorizeClusterSecurityGroupIngressResponse>(request, options);}
// Original:
public ListVaultsResult listVaults(ListVaultsRequest request) {request = beforeClientExecution(request);return executeListVaults(request);}

// Translation:
public virtual ListVaultsResponse ListVaults(ListVaultsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListVaultsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListVaultsResponseUnmarshaller.Instance;return Invoke<ListVaultsResponse>(request, options);}
// Original:
public void add(UDFFinder toolPack){_usedToolPacks.add(toolPack);}

// Translation:
public void Add(UDFFinder toolPack){_usedToolPacks.Add(toolPack);}
// Original:
public CreateRealtimeEndpointResult createRealtimeEndpoint(CreateRealtimeEndpointRequest request) {request = beforeClientExecution(request);return executeCreateRealtimeEndpoint(request);}

// Translation:
public virtual CreateRealtimeEndpointResponse CreateRealtimeEndpoint(CreateRealtimeEndpointRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateRealtimeEndpointRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateRealtimeEndpointResponseUnmarshaller.Instance;return Invoke<CreateRealtimeEndpointResponse>(request, options);}
// Original:
public final void recurseClearCachedFormulaResults(IEvaluationListener listener) {if (listener == null) {recurseClearCachedFormulaResults();} else {listener.onClearCachedValue(this);recurseClearCachedFormulaResults(listener, 1);}}

// Translation:
public void RecurseClearCachedFormulaResults(IEvaluationListener listener){if (listener == null){RecurseClearCachedFormulaResults();}else{listener.OnClearCachedValue(this);RecurseClearCachedFormulaResults(listener, 1);}}
// Original:
public PageBreakRecord(RecordInputStream in) {final int nBreaks = in.readShort();_breaks.ensureCapacity(nBreaks + 2);for(int k = 0; k < nBreaks; k++) {_breaks.add(new Break(in));}initMap();}

// Translation:
public PageBreakRecord(RecordInputStream in1){int nBreaks = in1.ReadShort();_breaks = new List<Break>(nBreaks + 2);_breakMap = new Hashtable();for (int k = 0; k < nBreaks; k++){Break br = new Break(in1);_breaks.Add(br);_breakMap[br.main] = br;}}
// Original:
public String toString() {return attSource.toString();}

// Translation:
public override string ToString(){return Image;}
// Original:
public void add(double value) {ensureCapacity(_count + 1);_array[_count] = value;_count++;}

// Translation:
public void Add(double[] values){int AddLen = values.Length;EnsureCapacity(_Count + AddLen);Array.Copy(values, 0, _array, _Count, AddLen);_Count += AddLen;}
// Original:
public FileInputStream(String path) throws FileNotFoundException {this(new File(path));}

// Translation:
public FileInputStream(string path) : this(new java.io.File(path)){throw new System.NotImplementedException();}
// Original:
public SetDataRetrievalPolicyResult setDataRetrievalPolicy(SetDataRetrievalPolicyRequest request) {request = beforeClientExecution(request);return executeSetDataRetrievalPolicy(request);}

// Translation:
public virtual SetDataRetrievalPolicyResponse SetDataRetrievalPolicy(SetDataRetrievalPolicyRequest request){var options = new InvokeOptions();options.RequestMarshaller = SetDataRetrievalPolicyRequestMarshaller.Instance;options.ResponseUnmarshaller = SetDataRetrievalPolicyResponseUnmarshaller.Instance;return Invoke<SetDataRetrievalPolicyResponse>(request, options);}
// Original:
public ScoreDoc(int doc, float score, int shardIndex) {this.doc = doc;this.score = score;this.shardIndex = shardIndex;}

// Translation:
public ScoreDoc(int doc, float score, int shardIndex){this.Doc = doc;this.Score = score;this.ShardIndex = shardIndex;}