yijunyu/c-to-rust huggingface dataset:
// Original:
public Sheet build() {Sheet sheet = (sheetName == null) ? workbook.createSheet() : workbook.createSheet(sheetName);Row currentRow;Cell currentCell;for (int rowIndex = 0; rowIndex < cells.length; ++rowIndex) {Object[] rowArray = cells[rowIndex];currentRow = sheet.createRow(rowIndex);for (int cellIndex = 0; cellIndex < rowArray.length; ++cellIndex) {Object cellValue = rowArray[cellIndex];if (cellValue != null || shouldCreateEmptyCells) {currentCell = currentRow.createCell(cellIndex);setCellValue(currentCell, cellValue);}}}return sheet;}

// Translation:
public ISheet Build(){ISheet sheet = (sheetName == null) ? workbook.CreateSheet() : workbook.CreateSheet(sheetName);IRow currentRow = null;ICell currentCell = null;for (int rowIndex = 0; rowIndex < cells.Length; ++rowIndex){Object[] rowArray = cells[rowIndex];currentRow = sheet.CreateRow(rowIndex);for (int cellIndex = 0; cellIndex < rowArray.Length; ++cellIndex){Object cellValue = rowArray[cellIndex];if (cellValue != null || shouldCreateEmptyCells){currentCell = currentRow.CreateCell(cellIndex);SetCellValue(currentCell, cellValue);}}}return sheet;}
// Original:
public CharArrayWriter(int initialSize) {if (initialSize < 0) {throw new IllegalArgumentException("size < 0");}buf = new char[initialSize];lock = buf;}

// Translation:
public CharArrayWriter(int initialSize){if (initialSize < 0){throw new System.ArgumentException("size < 0");}buf = new char[initialSize];@lock = buf;}
// Original:
public AtomicReference(V initialValue) {value = initialValue;}

// Translation:
public AtomicReference(V initialValue){value = initialValue;}
// Original:
public static ISignatureComposer getComposer() {if (null == composer) {composer = new RpcSignatureComposer();}return composer;}

// Translation:
public static ISignatureComposer GetComposer(){if (null == composer){composer = new RpcSignatureComposer();}return composer;}
// Original:
public ListHITsForQualificationTypeResult listHITsForQualificationType(ListHITsForQualificationTypeRequest request) {request = beforeClientExecution(request);return executeListHITsForQualificationType(request);}

// Translation:
public virtual ListHITsForQualificationTypeResponse ListHITsForQualificationType(ListHITsForQualificationTypeRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListHITsForQualificationTypeRequestMarshaller.Instance;options.ResponseUnmarshaller = ListHITsForQualificationTypeResponseUnmarshaller.Instance;return Invoke<ListHITsForQualificationTypeResponse>(request, options);}
// Original:
public AddTagsToStreamResult addTagsToStream(AddTagsToStreamRequest request) {request = beforeClientExecution(request);return executeAddTagsToStream(request);}

// Translation:
public virtual AddTagsToStreamResponse AddTagsToStream(AddTagsToStreamRequest request){var options = new InvokeOptions();options.RequestMarshaller = AddTagsToStreamRequestMarshaller.Instance;options.ResponseUnmarshaller = AddTagsToStreamResponseUnmarshaller.Instance;return Invoke<AddTagsToStreamResponse>(request, options);}
// Original:
public String toString(){StringBuilder buffer = new StringBuilder();final String nl = System.getProperty("line.separator");buffer.append('[' + getRecordName() + ']' + nl);if (escherRecords.size() == 0)buffer.append("No Escher Records Decoded" + nl);for (EscherRecord r : escherRecords) {buffer.append(r);}buffer.append("[/" + getRecordName() + ']' + nl);return buffer.toString();}

// Translation:
public override String ToString(){StringBuilder buffer = new StringBuilder();String nl = Environment.NewLine;buffer.Append('[' + RecordName + ']' + nl);if (escherRecords.Count == 0)buffer.Append("No Escher Records Decoded" + nl);foreach (EscherRecord r in escherRecords){buffer.Append(r.ToString());}buffer.Append("[/" + RecordName + ']' + nl);return buffer.ToString();}
// Original:
public WSBoolRecord(RecordInputStream in) {byte[] data = in.readRemainder();field_1_wsbool =data[ 1 ];   field_2_wsbool =data[ 0 ];   }

// Translation:
public WSBoolRecord(RecordInputStream in1){byte[] data = in1.ReadRemainder();field_1_wsbool =data[0];field_2_wsbool =data[1];}
// Original:
public BrazilianStemFilter create(TokenStream in) {return new BrazilianStemFilter(in);}

// Translation:
public override TokenStream Create(TokenStream @in){return new BrazilianStemFilter(@in);}
// Original:
public ResetCommand setRef(String ref) {this.ref = ref;return this;}

// Translation:
public virtual NGit.Api.ResetCommand SetRef(string @ref){this.@ref = @ref;return this;}
// Original:
public EnableOrganizationAdminAccountResult enableOrganizationAdminAccount(EnableOrganizationAdminAccountRequest request) {request = beforeClientExecution(request);return executeEnableOrganizationAdminAccount(request);}

// Translation:
public virtual EnableOrganizationAdminAccountResponse EnableOrganizationAdminAccount(EnableOrganizationAdminAccountRequest request){var options = new InvokeOptions();options.RequestMarshaller = EnableOrganizationAdminAccountRequestMarshaller.Instance;options.ResponseUnmarshaller = EnableOrganizationAdminAccountResponseUnmarshaller.Instance;return Invoke<EnableOrganizationAdminAccountResponse>(request, options);}
// Original:
public ValueEval getInnerValueEval(int sheetIndex) {return _evaluator.getEvalForCell(sheetIndex, getRow(), getColumn());}

// Translation:
public override ValueEval GetInnerValueEval(int sheetIndex){return _evaluator.GetEvalForCell(sheetIndex, Row, Column);}
// Original:
public DeleteRecommenderConfigurationResult deleteRecommenderConfiguration(DeleteRecommenderConfigurationRequest request) {request = beforeClientExecution(request);return executeDeleteRecommenderConfiguration(request);}

// Translation:
public virtual DeleteRecommenderConfigurationResponse DeleteRecommenderConfiguration(DeleteRecommenderConfigurationRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteRecommenderConfigurationRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteRecommenderConfigurationResponseUnmarshaller.Instance;return Invoke<DeleteRecommenderConfigurationResponse>(request, options);}
// Original:
public UpdateIntegrationResponseResult updateIntegrationResponse(UpdateIntegrationResponseRequest request) {request = beforeClientExecution(request);return executeUpdateIntegrationResponse(request);}

// Translation:
public virtual UpdateIntegrationResponseResponse UpdateIntegrationResponse(UpdateIntegrationResponseRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateIntegrationResponseRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateIntegrationResponseResponseUnmarshaller.Instance;return Invoke<UpdateIntegrationResponseResponse>(request, options);}
// Original:
public String toString() {StringBuilder buffer = new StringBuilder();buffer.append("[INTERFACEHDR]\n");buffer.append("    .codepage = ").append(HexDump.shortToHex(_codepage)).append("\n");buffer.append("[/INTERFACEHDR]\n");return buffer.toString();}

// Translation:
public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append("[INTERFACEHDR]\n");buffer.Append("    .codepage        = ").Append(StringUtil.ToHexString(_codepage)).Append("\n");buffer.Append("[/INTERFACEHDR]\n");return buffer.ToString();}
// Original:
public String outputToString(BytesRef output) {return output.toString();}

// Translation:
public override string OutputToString(BytesRef output){return output.ToString();}
// Original:
public String toString() {StringBuilder sb = new StringBuilder();sb.append("dim=");sb.append(dim);sb.append(" path=");sb.append(Arrays.toString(path));sb.append(" value=");sb.append(value);sb.append(" childCount=");sb.append(childCount);sb.append('\n');for(LabelAndValue labelValue : labelValues) {sb.append("  ").append(labelValue).append("\n");}return sb.toString();}

// Translation:
public override string ToString(){StringBuilder sb = new StringBuilder();sb.Append("dim=");sb.Append(Dim);sb.Append(" path=");sb.Append(Arrays.ToString(Path));sb.Append(" value=");if (TypeOfValue == typeof(int)){sb.AppendFormat(CultureInfo.InvariantCulture, "{0:0}", Value); }else{sb.AppendFormat(CultureInfo.InvariantCulture, "{0:0.0#####}", Value); }sb.Append(" childCount=");sb.Append(ChildCount);sb.Append('\n');foreach (LabelAndValue labelValue in LabelValues){sb.Append("  " + labelValue + "\n");}return sb.ToString();}
// Original:
public AcceptVpcEndpointConnectionsResult acceptVpcEndpointConnections(AcceptVpcEndpointConnectionsRequest request) {request = beforeClientExecution(request);return executeAcceptVpcEndpointConnections(request);}

// Translation:
public virtual AcceptVpcEndpointConnectionsResponse AcceptVpcEndpointConnections(AcceptVpcEndpointConnectionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = AcceptVpcEndpointConnectionsRequestMarshaller.Instance;options.ResponseUnmarshaller = AcceptVpcEndpointConnectionsResponseUnmarshaller.Instance;return Invoke<AcceptVpcEndpointConnectionsResponse>(request, options);}
// Original:
public DescribeIdentityProviderConfigurationResult describeIdentityProviderConfiguration(DescribeIdentityProviderConfigurationRequest request) {request = beforeClientExecution(request);return executeDescribeIdentityProviderConfiguration(request);}

// Translation:
public virtual DescribeIdentityProviderConfigurationResponse DescribeIdentityProviderConfiguration(DescribeIdentityProviderConfigurationRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeIdentityProviderConfigurationRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeIdentityProviderConfigurationResponseUnmarshaller.Instance;return Invoke<DescribeIdentityProviderConfigurationResponse>(request, options);}
// Original:
public void clear() {head = null;free.clear();}

// Translation:
public override void Clear(){head = null;free.Clear();}
// Original:
public String toString() {return getClass().getSimpleName() + "[" + getFile().getPath() + "]";}

// Translation:
public override string ToString(){return GetType().Name + "[" + GetFile().GetPath() + "]";}
// Original:
public GetRelationalDatabaseBlueprintsResult getRelationalDatabaseBlueprints(GetRelationalDatabaseBlueprintsRequest request) {request = beforeClientExecution(request);return executeGetRelationalDatabaseBlueprints(request);}

// Translation:
public virtual GetRelationalDatabaseBlueprintsResponse GetRelationalDatabaseBlueprints(GetRelationalDatabaseBlueprintsRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetRelationalDatabaseBlueprintsRequestMarshaller.Instance;options.ResponseUnmarshaller = GetRelationalDatabaseBlueprintsResponseUnmarshaller.Instance;return Invoke<GetRelationalDatabaseBlueprintsResponse>(request, options);}
// Original:
public void concatenate(byte[] array) {if (array == null) {throw new IllegalArgumentException("array cannot be null");}arrays.add(array);}

// Translation:
public void Concatenate(byte[] array){if (array == null){throw new ArgumentException("array cannot be null");}arrays.Add(array);}
// Original:
public final ByteBuffer get(byte[] dst, int dstOffset, int byteCount) {checkGetBounds(1, dst.length, dstOffset, byteCount);System.arraycopy(backingArray, offset + position, dst, dstOffset, byteCount);position += byteCount;return this;}

// Translation:
public sealed override java.nio.ByteBuffer get(byte[] dst, int dstOffset, int byteCount){checkGetBounds(1, dst.Length, dstOffset, byteCount);System.Array.Copy(backingArray, offset + _position, dst, dstOffset, byteCount);_position += byteCount;return this;}
// Original:
public DescribeAutoScalingNotificationTypesResult describeAutoScalingNotificationTypes() {return describeAutoScalingNotificationTypes(new DescribeAutoScalingNotificationTypesRequest());}

// Translation:
public virtual DescribeAutoScalingNotificationTypesResponse DescribeAutoScalingNotificationTypes(){return DescribeAutoScalingNotificationTypes(new DescribeAutoScalingNotificationTypesRequest());}
// Original:
public int compareTo(LookupResult o) {return CHARSEQUENCE_COMPARATOR.compare(key, o.key);}

// Translation:
public int CompareTo(LookupResult o){return CHARSEQUENCE_COMPARER.Compare(Key, o.Key);}
// Original:
public UpdateVariableResult updateVariable(UpdateVariableRequest request) {request = beforeClientExecution(request);return executeUpdateVariable(request);}

// Translation:
public virtual UpdateVariableResponse UpdateVariable(UpdateVariableRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateVariableRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateVariableResponseUnmarshaller.Instance;return Invoke<UpdateVariableResponse>(request, options);}
// Original:
public TranslateTextRequest() {super("hiknoengine", "2019-06-25", "TranslateText", "hiknoengine");setMethod(MethodType.POST);}

// Translation:
public TranslateTextRequest(): base("hiknoengine", "2019-06-25", "TranslateText", "hiknoengine", "openAPI"){Method = MethodType.POST;}
// Original:
public E set(int location, E object) {E result = a[location];a[location] = object;return result;}

// Translation:
public override E set(int location, E @object){E result = a[location];a[location] = @object;return result;}
// Original:
public static Document loadXML(Reader is) {DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();DocumentBuilder db = null;try {db = dbf.newDocumentBuilder();}catch (Exception se) {throw new RuntimeException("Parser configuration error", se);}org.w3c.dom.Document doc = null;try {doc = db.parse(new InputSource(is));}catch (Exception se) {throw new RuntimeException("Error parsing file:" + se, se);}return doc;}

// Translation:
public static XmlDocument LoadXML(XmlReader input){XmlDocument result = new XmlDocument();try{result.Load(input);}catch (Exception se){throw new Exception("Error parsing file:" + se, se);}return result;}
// Original:
public void setTokenStream(TokenStream tokenStream) {if (type.indexOptions() == IndexOptions.NONE || !type.tokenized()) {throw new IllegalArgumentException("TokenStream fields must be indexed and tokenized");}this.tokenStream = tokenStream;}

// Translation:
public virtual void SetTokenStream(TokenStream tokenStream){if (!m_type.IsIndexed || !m_type.IsTokenized){throw new System.ArgumentException("TokenStream fields must be indexed and tokenized");}if (m_type.NumericType != Documents.NumericType.NONE){throw new System.ArgumentException("cannot set private TokenStream on numeric fields");}this.m_tokenStream = tokenStream;}
// Original:
public ValueEval getArea3DEval(Area3DPtg aptg) {SheetRangeEvaluator sre = createExternSheetRefEvaluator(aptg.getExternSheetIndex());return new LazyAreaEval(aptg.getFirstRow(), aptg.getFirstColumn(),aptg.getLastRow(), aptg.getLastColumn(), sre);}

// Translation:
public ValueEval GetArea3DEval(Area3DPtg aptg){SheetRangeEvaluator sre = CreateExternSheetRefEvaluator(aptg.ExternSheetIndex);return new LazyAreaEval(aptg.FirstRow, aptg.FirstColumn,aptg.LastRow, aptg.LastColumn, sre);}
// Original:
public MulBlankRecord(int row, int firstCol, short[] xfs) {_row = row;_firstCol = firstCol;_xfs = xfs;_lastCol = firstCol + xfs.length - 1;}

// Translation:
public MulBlankRecord(int row, int firstCol, short[] xfs){_row = row;_first_col = firstCol;_xfs = xfs;_last_col = firstCol + xfs.Length - 1;}
// Original:
public EngineDefaults describeEngineDefaultParameters(DescribeEngineDefaultParametersRequest request) {request = beforeClientExecution(request);return executeDescribeEngineDefaultParameters(request);}

// Translation:
public virtual DescribeEngineDefaultParametersResponse DescribeEngineDefaultParameters(DescribeEngineDefaultParametersRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeEngineDefaultParametersRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeEngineDefaultParametersResponseUnmarshaller.Instance;return Invoke<DescribeEngineDefaultParametersResponse>(request, options);}
// Original:
public AttachVolumeResult attachVolume(AttachVolumeRequest request) {request = beforeClientExecution(request);return executeAttachVolume(request);}

// Translation:
public virtual AttachVolumeResponse AttachVolume(AttachVolumeRequest request){var options = new InvokeOptions();options.RequestMarshaller = AttachVolumeRequestMarshaller.Instance;options.ResponseUnmarshaller = AttachVolumeResponseUnmarshaller.Instance;return Invoke<AttachVolumeResponse>(request, options);}
// Original:
public long ramBytesUsed() {return ((termOffsets!=null)? termOffsets.ramBytesUsed() : 0) +((termsDictOffsets!=null)? termsDictOffsets.ramBytesUsed() : 0);}

// Translation:
public override long RamBytesUsed(){long sizeInBytes = 0;foreach (FieldIndexData entry in fields.Values){sizeInBytes += entry.RamBytesUsed();}return sizeInBytes;}
// Original:
public DeleteWorkerBlockResult deleteWorkerBlock(DeleteWorkerBlockRequest request) {request = beforeClientExecution(request);return executeDeleteWorkerBlock(request);}

// Translation:
public virtual DeleteWorkerBlockResponse DeleteWorkerBlock(DeleteWorkerBlockRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteWorkerBlockRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteWorkerBlockResponseUnmarshaller.Instance;return Invoke<DeleteWorkerBlockResponse>(request, options);}
// Original:
public static void unregister(TransportProtocol proto) {for (WeakReference<TransportProtocol> ref : protocols) {TransportProtocol refProto = ref.get();if (refProto == null || refProto == proto)protocols.remove(ref);}}

// Translation:
public static void Unregister(TransportProtocol proto){foreach (JavaWeakReference<TransportProtocol> @ref in protocols){TransportProtocol refProto = @ref.Get();if (refProto == null || refProto == proto){protocols.Remove(@ref);}}}
// Original:
public CreateNetworkInterfacePermissionResult createNetworkInterfacePermission(CreateNetworkInterfacePermissionRequest request) {request = beforeClientExecution(request);return executeCreateNetworkInterfacePermission(request);}

// Translation:
public virtual CreateNetworkInterfacePermissionResponse CreateNetworkInterfacePermission(CreateNetworkInterfacePermissionRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateNetworkInterfacePermissionRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateNetworkInterfacePermissionResponseUnmarshaller.Instance;return Invoke<CreateNetworkInterfacePermissionResponse>(request, options);}
// Original:
public void parseLine(DocData docData, String line) {String[] parts = line.split("\\t", 7);docData.setID(Integer.parseInt(parts[0]));docData.setName(parts[1]);String latitude = parts[4];String longitude = parts[5];docData.setBody("POINT("+longitude+" "+latitude+")");}

// Translation:
public override void ParseLine(DocData docData, string line){string[] parts = new Regex("\\t").Split(line, 7);docData.ID = Convert.ToInt32(parts[0], CultureInfo.InvariantCulture);docData.Name = parts[1];string latitude = parts[4];string longitude = parts[5];docData.Body = "POINT(" + longitude + " " + latitude + ")";}
// Original:
public DeleteArchiveRequest(String accountId, String vaultName, String archiveId) {setAccountId(accountId);setVaultName(vaultName);setArchiveId(archiveId);}

// Translation:
public DeleteArchiveRequest(string accountId, string vaultName, string archiveId){_accountId = accountId;_vaultName = vaultName;_archiveId = archiveId;}
// Original:
public static void close(@NonNull Repository db) {if (db.getDirectory() != null) {FileKey key = FileKey.exact(db.getDirectory(), db.getFS());cache.unregisterAndCloseRepository(key);}}

// Translation:
public static void Close(Repository db){if (db.Directory != null){RepositoryCache.FileKey key = RepositoryCache.FileKey.Exact(db.Directory, db.FileSystem);cache.UnregisterRepository(key);}}
// Original:
public OrQueryNode(List<QueryNode> clauses) {super(clauses);if ((clauses == null) || (clauses.size() == 0)) {throw new IllegalArgumentException("OR query must have at least one clause");}}

// Translation:
public OrQueryNode(IList<IQueryNode> clauses): base(clauses){if ((clauses == null) || (clauses.Count == 0)){throw new ArgumentException("OR query must have at least one clause");}}
// Original:
public ReplicationGroup createReplicationGroup(CreateReplicationGroupRequest request) {request = beforeClientExecution(request);return executeCreateReplicationGroup(request);}

// Translation:
public virtual CreateReplicationGroupResponse CreateReplicationGroup(CreateReplicationGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateReplicationGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateReplicationGroupResponseUnmarshaller.Instance;return Invoke<CreateReplicationGroupResponse>(request, options);}
// Original:
public ListCollectionsResult listCollections(ListCollectionsRequest request) {request = beforeClientExecution(request);return executeListCollections(request);}

// Translation:
public virtual ListCollectionsResponse ListCollections(ListCollectionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListCollectionsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListCollectionsResponseUnmarshaller.Instance;return Invoke<ListCollectionsResponse>(request, options);}
// Original:
public void setParentIds(AnyObjectId parent1, AnyObjectId parent2) {parentIds = new ObjectId[] { parent1.copy(), parent2.copy() };}

// Translation:
public virtual void SetParentIds(AnyObjectId parent1, AnyObjectId parent2){parentIds = new ObjectId[] { parent1.Copy(), parent2.Copy() };}
// Original:
public TokenOffsetPayloadTokenFilter create(TokenStream input) {return new TokenOffsetPayloadTokenFilter(input);}

// Translation:
public override TokenStream Create(TokenStream input){return new TokenOffsetPayloadTokenFilter(input);}
// Original:
public CreateDataSourceResult createDataSource(CreateDataSourceRequest request) {request = beforeClientExecution(request);return executeCreateDataSource(request);}

// Translation:
public virtual CreateDataSourceResponse CreateDataSource(CreateDataSourceRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateDataSourceRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateDataSourceResponseUnmarshaller.Instance;return Invoke<CreateDataSourceResponse>(request, options);}
// Original:
public DeleteBranchCommand setBranchNames(String... branchnames) {checkCallable();this.branchNames.clear();this.branchNames.addAll(Arrays.asList(branchnames));return this;}

// Translation:
public virtual NGit.Api.DeleteBranchCommand SetBranchNames(params string[] branchnames){CheckCallable();this.branchNames.Clear();foreach (string branch in branchnames){this.branchNames.AddItem(branch);}return this;}
// Original:
public void setCoordinates(int x1, int y1, int x2, int y2) {_spgrRecord.setRectX1(x1);_spgrRecord.setRectX2(x2);_spgrRecord.setRectY1(y1);_spgrRecord.setRectY2(y2);}

// Translation:
public void SetCoordinates(int x1, int y1, int x2, int y2){_spgrRecord.RectX1 = (x1);_spgrRecord.RectX2 = (x2);_spgrRecord.RectY1 = (y1);_spgrRecord.RectY2 = (y2);}
// Original:
public DescribeNotificationConfigurationsResult describeNotificationConfigurations() {return describeNotificationConfigurations(new DescribeNotificationConfigurationsRequest());}

// Translation:
public virtual DescribeNotificationConfigurationsResponse DescribeNotificationConfigurations(){return DescribeNotificationConfigurations(new DescribeNotificationConfigurationsRequest());}
// Original:
public GetStatusResult getStatus(GetStatusRequest request) {request = beforeClientExecution(request);return executeGetStatus(request);}

// Translation:
public virtual GetStatusResponse GetStatus(GetStatusRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetStatusRequestMarshaller.Instance;options.ResponseUnmarshaller = GetStatusResponseUnmarshaller.Instance;return Invoke<GetStatusResponse>(request, options);}