yijunyu/c-to-rust huggingface dataset:
// Original:
public DescribeGlobalClustersResult describeGlobalClusters(DescribeGlobalClustersRequest request) {request = beforeClientExecution(request);return executeDescribeGlobalClusters(request);}

// Translation:
public virtual DescribeGlobalClustersResponse DescribeGlobalClusters(DescribeGlobalClustersRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeGlobalClustersRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeGlobalClustersResponseUnmarshaller.Instance;return Invoke<DescribeGlobalClustersResponse>(request, options);}
// Original:
public PutVoiceConnectorTerminationResult putVoiceConnectorTermination(PutVoiceConnectorTerminationRequest request) {request = beforeClientExecution(request);return executePutVoiceConnectorTermination(request);}

// Translation:
public virtual PutVoiceConnectorTerminationResponse PutVoiceConnectorTermination(PutVoiceConnectorTerminationRequest request){var options = new InvokeOptions();options.RequestMarshaller = PutVoiceConnectorTerminationRequestMarshaller.Instance;options.ResponseUnmarshaller = PutVoiceConnectorTerminationResponseUnmarshaller.Instance;return Invoke<PutVoiceConnectorTerminationResponse>(request, options);}
// Original:
public static int strcmp(char[] a, int startA, char[] b, int startB) {for (; a[startA] == b[startB]; startA++, startB++) {if (a[startA] == 0) {return 0;}}return a[startA] - b[startB];}

// Translation:
public static int StrCmp(char[] a, int startA, char[] b, int startB){for (; a[startA] == b[startB]; startA++, startB++){if (a[startA] == 0){return 0;}}return a[startA] - b[startB];}
// Original:
public StartSentimentDetectionJobResult startSentimentDetectionJob(StartSentimentDetectionJobRequest request) {request = beforeClientExecution(request);return executeStartSentimentDetectionJob(request);}

// Translation:
public virtual StartSentimentDetectionJobResponse StartSentimentDetectionJob(StartSentimentDetectionJobRequest request){var options = new InvokeOptions();options.RequestMarshaller = StartSentimentDetectionJobRequestMarshaller.Instance;options.ResponseUnmarshaller = StartSentimentDetectionJobResponseUnmarshaller.Instance;return Invoke<StartSentimentDetectionJobResponse>(request, options);}
// Original:
public HSSFCell createCell(int column){return this.createCell(column,CellType.BLANK);}

// Translation:
public ICell CreateCell(int column){return this.CreateCell(column, CellType.Blank);}
// Original:
public RecalcIdRecord(RecordInputStream in) {in.readUShort(); _reserved0 = in.readUShort();_engineId = in.readInt();}

// Translation:
public RecalcIdRecord(RecordInputStream in1){in1.ReadUShort(); _reserved0 = in1.ReadUShort();_engineId = in1.ReadInt();}
// Original:
public static int getEncodedSizeWithoutArrayData(Ptg[] ptgs) {int result = 0;for (Ptg ptg : ptgs) {if (ptg instanceof ArrayPtg) {result += ArrayPtg.PLAIN_TOKEN_SIZE;} else {result += ptg.getSize();}}return result;}

// Translation:
public static int GetEncodedSizeWithoutArrayData(Ptg[] ptgs){int result = 0;for (int i = 0; i < ptgs.Length; i++){Ptg ptg = ptgs[i];if (ptg is ArrayPtg){result += ArrayPtg.PLAIN_TOKEN_SIZE;}else{result += ptg.Size;}}return result;}
// Original:
public static double ceiling(double n, double s) {if (n>0 && s<0) {return Double.NaN;} else {return (n == 0 || s == 0) ? 0 : Math.ceil(n/s) * s;}}

// Translation:
public static double Ceiling(double n, double s){double c;if ((n < 0 && s > 0) || (n > 0 && s < 0)){c = double.NaN;}else{c = (n == 0 || s == 0) ? 0 : Math.Ceiling(n / s) * s;}return c;}
// Original:
public ListResolverRulesResult listResolverRules(ListResolverRulesRequest request) {request = beforeClientExecution(request);return executeListResolverRules(request);}

// Translation:
public virtual ListResolverRulesResponse ListResolverRules(ListResolverRulesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListResolverRulesRequestMarshaller.Instance;options.ResponseUnmarshaller = ListResolverRulesResponseUnmarshaller.Instance;return Invoke<ListResolverRulesResponse>(request, options);}
// Original:
public ListBusinessReportSchedulesResult listBusinessReportSchedules(ListBusinessReportSchedulesRequest request) {request = beforeClientExecution(request);return executeListBusinessReportSchedules(request);}

// Translation:
public virtual ListBusinessReportSchedulesResponse ListBusinessReportSchedules(ListBusinessReportSchedulesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListBusinessReportSchedulesRequestMarshaller.Instance;options.ResponseUnmarshaller = ListBusinessReportSchedulesResponseUnmarshaller.Instance;return Invoke<ListBusinessReportSchedulesResponse>(request, options);}
// Original:
public EscherDgRecord createDgRecord() {EscherDgRecord dg = new EscherDgRecord();dg.setRecordId( EscherDgRecord.RECORD_ID );short dgId = findNewDrawingGroupId();dg.setOptions( (short) ( dgId << 4 ) );dg.setNumShapes( 0 );dg.setLastMSOSPID( -1 );drawingGroups.add(dg);dgg.addCluster( dgId, 0 );dgg.setDrawingsSaved( dgg.getDrawingsSaved() + 1 );return dg;}

// Translation:
public virtual EscherDgRecord CreateDgRecord(){EscherDgRecord dg = new EscherDgRecord();dg.RecordId = EscherDgRecord.RECORD_ID;short dgId = FindNewDrawingGroupId();dg.Options=(short)(dgId << 4);dg.NumShapes=0;dg.LastMSOSPID=(-1);drawingGroups.Add(dg);dgg.AddCluster(dgId, 0);dgg.DrawingsSaved=dgg.DrawingsSaved + 1;return dg;}
// Original:
public Transport open(URIish uri)throws NotSupportedException, TransportException {throw new NotSupportedException(JGitText.get().transportNeedsRepository);}

// Translation:
public virtual NGit.Transport.Transport Open(URIish uri){throw new NotSupportedException(JGitText.Get().transportNeedsRepository);}
// Original:
public int compare(Ref o1, Ref o2) {return compareTo(o1, o2);}

// Translation:
public virtual int Compare(Ref o1, Ref o2){return CompareTo(o1, o2);}
// Original:
public OrdRange(int start, int end) {this.start = start;this.end = end;}

// Translation:
public OrdRange(int start, int end){this.Start = start;this.End = end;}
// Original:
public boolean add(E object) {return backingMap.put(object, this) == null;}

// Translation:
public override bool add(E @object){return backingMap.put(@object, this) == null;}
// Original:
public void write(String s) {reserve(s.length());s.getChars(0,s.length(),buf, len);len +=s.length();}

// Translation:
public virtual void Write(int b){Write((char)b);}
// Original:
public long skip(long cnt) throws IOException {try {beginRead();return super.skip(cnt);} catch (InterruptedIOException e) {throw readTimedOut(e);} finally {endRead();}}

// Translation:
public override long Skip(long cnt){try{BeginRead();return base.Skip(cnt);}catch (ThreadInterruptedException){throw ReadTimedOut();}finally{EndRead();}}
// Original:
public StepDetail(StepConfig stepConfig, StepExecutionStatusDetail executionStatusDetail) {setStepConfig(stepConfig);setExecutionStatusDetail(executionStatusDetail);}

// Translation:
public StepDetail(StepConfig stepConfig, StepExecutionStatusDetail executionStatusDetail){_stepConfig = stepConfig;_executionStatusDetail = executionStatusDetail;}
// Original:
final public Token getToken(int index) {Token t = token;for (int i = 0; i < index; i++) {if (t.next != null) t = t.next;else t = t.next = token_source.getNextToken();}return t;}

// Translation:
public Token GetToken(int index){Token t = Token;for (int i = 0; i < index; i++){if (t.Next != null) t = t.Next;else t = t.Next = TokenSource.GetNextToken();}return t;}
// Original:
public Object[] toArray() {synchronized (mutex) {return delegate().toArray();}}

// Translation:
public virtual object[] toArray(){lock (mutex){return c.toArray();}}
// Original:
public DBParameterGroup createDBParameterGroup(CreateDBParameterGroupRequest request) {request = beforeClientExecution(request);return executeCreateDBParameterGroup(request);}

// Translation:
public virtual CreateDBParameterGroupResponse CreateDBParameterGroup(CreateDBParameterGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateDBParameterGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateDBParameterGroupResponseUnmarshaller.Instance;return Invoke<CreateDBParameterGroupResponse>(request, options);}
// Original:
public StringBuilder append(boolean b) {append0(b ? "true" : "false");return this;}

// Translation:
public java.lang.StringBuilder append(bool b){append0(b ? "true" : "false");return this;}
// Original:
public void execute(Lexer lexer, CharStream input, int startIndex) {boolean requiresSeek = false;int stopIndex = input.index();try {for (LexerAction lexerAction : lexerActions) {if (lexerAction instanceof LexerIndexedCustomAction) {int offset = ((LexerIndexedCustomAction)lexerAction).getOffset();input.seek(startIndex + offset);lexerAction = ((LexerIndexedCustomAction)lexerAction).getAction();requiresSeek = (startIndex + offset) != stopIndex;}else if (lexerAction.isPositionDependent()) {input.seek(stopIndex);requiresSeek = false;}lexerAction.execute(lexer);}}finally {if (requiresSeek) {input.seek(stopIndex);}}}

// Translation:
public virtual void Execute(Lexer lexer, ICharStream input, int startIndex){bool requiresSeek = false;int stopIndex = input.Index;try{foreach (ILexerAction lexerAction in lexerActions){ILexerAction action = lexerAction;if (action is LexerIndexedCustomAction){int offset = ((LexerIndexedCustomAction)action).Offset;input.Seek(startIndex + offset);action = ((LexerIndexedCustomAction)action).Action;requiresSeek = (startIndex + offset) != stopIndex;}else{if (action.IsPositionDependent){input.Seek(stopIndex);requiresSeek = false;}}action.Execute(lexer);}}finally{if (requiresSeek){input.Seek(stopIndex);}}}
// Original:
public ListMailboxPermissionsResult listMailboxPermissions(ListMailboxPermissionsRequest request) {request = beforeClientExecution(request);return executeListMailboxPermissions(request);}

// Translation:
public virtual ListMailboxPermissionsResponse ListMailboxPermissions(ListMailboxPermissionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListMailboxPermissionsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListMailboxPermissionsResponseUnmarshaller.Instance;return Invoke<ListMailboxPermissionsResponse>(request, options);}
// Original:
public ConditionalFormattingTable(RecordStream rs) {while (rs.peekNextRecord() instanceof CFHeaderBase) {_cfHeaders.add(CFRecordsAggregate.createCFAggregate(rs));}}

// Translation:
public ConditionalFormattingTable(RecordStream rs){IList temp = new ArrayList();while (rs.PeekNextClass() == typeof(CFHeaderRecord)){temp.Add(CFRecordsAggregate.CreateCFAggregate(rs));}_cfHeaders = temp;}
// Original:
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {for (int i = 0; i < iterations; ++i) {final int byte0 = blocks[blocksOffset++] & 0xFF;final int byte1 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = (byte0 << 4) | (byte1 >>> 4);final int byte2 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte1 & 15) << 8) | byte2;}}

// Translation:
public override void Decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations){for (int i = 0; i < iterations; ++i){int byte0 = blocks[blocksOffset++] & 0xFF;int byte1 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = (byte0 << 4) | ((int)((uint)byte1 >> 4));int byte2 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte1 & 15) << 8) | byte2;}}
// Original:
public Map<String, Ref> getTags() {try {return getRefDatabase().getRefs(Constants.R_TAGS);} catch (IOException e) {throw new UncheckedIOException(e);}}

// Translation:
public virtual IDictionary<string, Ref> GetTags(){try{return RefDatabase.GetRefs(Constants.R_TAGS);}catch (IOException){return new Dictionary<string, Ref>();}}
// Original:
public ComposedQuery(List<SrndQuery> qs, boolean operatorInfix, String opName) {recompose(qs);this.operatorInfix = operatorInfix;this.opName = opName;}

// Translation:
public ComposedQuery(IList<SrndQuery> qs, bool operatorInfix, string opName){Recompose(qs);this.operatorInfix = operatorInfix;this.m_opName = opName;}
// Original:
public TestRoleResult testRole(TestRoleRequest request) {request = beforeClientExecution(request);return executeTestRole(request);}

// Translation:
public virtual TestRoleResponse TestRole(TestRoleRequest request){var options = new InvokeOptions();options.RequestMarshaller = TestRoleRequestMarshaller.Instance;options.ResponseUnmarshaller = TestRoleResponseUnmarshaller.Instance;return Invoke<TestRoleResponse>(request, options);}
// Original:
public String toString() {final StringBuilder r = new StringBuilder();r.append("(");for (int i = 0; i < subfilters.length; i++) {if (i > 0)r.append(" AND ");r.append(subfilters[i].toString());}r.append(")");return r.toString();}

// Translation:
public override string ToString(){StringBuilder r = new StringBuilder();r.Append("(");for (int i = 0; i < subfilters.Length; i++){if (i > 0){r.Append(" OR ");}r.Append(subfilters[i].ToString());}r.Append(")");return r.ToString();}
// Original:
public ModifyVpcAttributeResult modifyVpcAttribute(ModifyVpcAttributeRequest request) {request = beforeClientExecution(request);return executeModifyVpcAttribute(request);}

// Translation:
public virtual ModifyVpcAttributeResponse ModifyVpcAttribute(ModifyVpcAttributeRequest request){var options = new InvokeOptions();options.RequestMarshaller = ModifyVpcAttributeRequestMarshaller.Instance;options.ResponseUnmarshaller = ModifyVpcAttributeResponseUnmarshaller.Instance;return Invoke<ModifyVpcAttributeResponse>(request, options);}
// Original:
public void seekExact(long ord) throws IOException {throw new UnsupportedOperationException();}

// Translation:
public override void SeekExact(long ord){throw new System.NotSupportedException();}
// Original:
public ArabicNormalizationFilterFactory(Map<String,String> args) {super(args);if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

// Translation:
public ArabicNormalizationFilterFactory(IDictionary<string, string> args): base(args){if (args.Count > 0){throw new System.ArgumentException("Unknown parameters: " + args);}}
// Original:
public boolean equals(Object obj) {if (!(obj instanceof BookSheetKey)) {return false;}BookSheetKey other = (BookSheetKey) obj;return _bookIndex == other._bookIndex && _sheetIndex == other._sheetIndex;}

// Translation:
public override bool Equals(Object obj){BookSheetKey other = (BookSheetKey)obj;return _bookIndex == other._bookIndex && _sheetIndex == other._sheetIndex;}
// Original:
public TermQuery(Term t, TermStates states) {assert states != null;term = Objects.requireNonNull(t);perReaderTermState = Objects.requireNonNull(states);}

// Translation:
public TermQuery(Term t, TermContext states){Debug.Assert(states != null);term = t;docFreq = states.DocFreq;perReaderTermState = states;}
// Original:
public GetClusterCredentialsResult getClusterCredentials(GetClusterCredentialsRequest request) {request = beforeClientExecution(request);return executeGetClusterCredentials(request);}

// Translation:
public virtual GetClusterCredentialsResponse GetClusterCredentials(GetClusterCredentialsRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetClusterCredentialsRequestMarshaller.Instance;options.ResponseUnmarshaller = GetClusterCredentialsResponseUnmarshaller.Instance;return Invoke<GetClusterCredentialsResponse>(request, options);}
// Original:
public boolean equals(Object other) {return (getClass() == other.getClass()) && this.equalsSameType(other);}

// Translation:
public override bool Equals(object other){return (this.GetType() == other.GetType()) && this.EqualsSameType(other);}
// Original:
public Item clone() {return new Item(parent, child);}

// Translation:
public object Clone(){return new Item(parent, child);}
// Original:
public UpdateClusterResult updateCluster(UpdateClusterRequest request) {request = beforeClientExecution(request);return executeUpdateCluster(request);}

// Translation:
public virtual UpdateClusterResponse UpdateCluster(UpdateClusterRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateClusterRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateClusterResponseUnmarshaller.Instance;return Invoke<UpdateClusterResponse>(request, options);}
// Original:
public E get(int index) {synchronized (mutex) {return delegate().get(index);}}

// Translation:
public virtual E get(int location){lock (mutex){return list.get(location);}}
// Original:
public LogCommand setMaxCount(int maxCount) {checkCallable();this.maxCount = maxCount;return this;}

// Translation:
public virtual NGit.Api.LogCommand SetMaxCount(int maxCount){CheckCallable();this.maxCount = maxCount;return this;}
// Original:
public GetInsightRuleReportResult getInsightRuleReport(GetInsightRuleReportRequest request) {request = beforeClientExecution(request);return executeGetInsightRuleReport(request);}

// Translation:
public virtual GetInsightRuleReportResponse GetInsightRuleReport(GetInsightRuleReportRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetInsightRuleReportRequestMarshaller.Instance;options.ResponseUnmarshaller = GetInsightRuleReportResponseUnmarshaller.Instance;return Invoke<GetInsightRuleReportResponse>(request, options);}
// Original:
public CommonToken(Token oldToken) {type = oldToken.getType();line = oldToken.getLine();index = oldToken.getTokenIndex();charPositionInLine = oldToken.getCharPositionInLine();channel = oldToken.getChannel();start = oldToken.getStartIndex();stop = oldToken.getStopIndex();if (oldToken instanceof CommonToken) {text = ((CommonToken)oldToken).text;source = ((CommonToken)oldToken).source;}else {text = oldToken.getText();source = new Pair<TokenSource, CharStream>(oldToken.getTokenSource(), oldToken.getInputStream());}}

// Translation:
public CommonToken(IToken oldToken){_type = oldToken.Type;_line = oldToken.Line;index = oldToken.TokenIndex;charPositionInLine = oldToken.Column;_channel = oldToken.Channel;start = oldToken.StartIndex;stop = oldToken.StopIndex;if (oldToken is Antlr4.Runtime.CommonToken){_text = ((Antlr4.Runtime.CommonToken)oldToken)._text;source = ((Antlr4.Runtime.CommonToken)oldToken).source;}else{_text = oldToken.Text;source = Tuple.Create(oldToken.TokenSource, oldToken.InputStream);}}
// Original:
public ListSolutionsResult listSolutions(ListSolutionsRequest request) {request = beforeClientExecution(request);return executeListSolutions(request);}

// Translation:
public virtual ListSolutionsResponse ListSolutions(ListSolutionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListSolutionsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListSolutionsResponseUnmarshaller.Instance;return Invoke<ListSolutionsResponse>(request, options);}
// Original:
public boolean hasPrevious() {return index > from;}

// Translation:
public virtual bool hasPrevious(){return index > from;}
// Original:
public final void end() {if (finalState != null) {restoreState(finalState);}}

// Translation:
public override void End(){if (finalState != null){RestoreState(finalState);}}
// Original:
public DoubleBuffer put(int index, double c) {checkIndex(index);backingArray[offset + index] = c;return this;}

// Translation:
public override java.nio.DoubleBuffer put(int index, double c){checkIndex(index);backingArray[offset + index] = c;return this;}
// Original:
public ThreeWayMerger newMerger(Repository db) {return new ResolveMerger(db, false);}

// Translation:
public override Merger NewMerger(Repository db){return new ResolveMerger(db, false);}
// Original:
public static long pop_union(long[] arr1, long[] arr2, int wordOffset, int numWords) {long popCount = 0;for (int i = wordOffset, end = wordOffset + numWords; i < end; ++i) {popCount += Long.bitCount(arr1[i] | arr2[i]);}return popCount;}

// Translation:
public static long Pop_Union(long[] arr1, long[] arr2, int wordOffset, int numWords){long popCount = 0;for (int i = wordOffset, end = wordOffset + numWords; i < end; ++i){popCount += (arr1[i] | arr2[i]).PopCount();}return popCount;}
// Original:
public LongBuffer put(long c) {if (position == limit) {throw new BufferOverflowException();}backingArray[offset + position++] = c;return this;}

// Translation:
public override java.nio.LongBuffer put(long c){if (_position == _limit){throw new java.nio.BufferOverflowException();}backingArray[offset + _position++] = c;return this;}
// Original:
public ConstValueSource(float constant) {this.constant = constant;this.dv = constant;}

// Translation:
public ConstValueSource(float constant){this.constant = constant;this.dv = constant;}
// Original:
public boolean matches(char c) {return punctCharacters.indexOf(c) != -1;}

// Translation:
public bool Matches(char c){return punctCharacters.IndexOf(c) != -1;}
// Original:
public FlushInfo(int numDocs, long estimatedSegmentSize) {this.numDocs = numDocs;this.estimatedSegmentSize = estimatedSegmentSize;}

// Translation:
public FlushInfo(int numDocs, long estimatedSegmentSize){this.NumDocs = numDocs;this.EstimatedSegmentSize = estimatedSegmentSize;}
// Original:
public void print(char[] chars) {print(new String(chars, 0, chars.length));}

// Translation:
public virtual void print(char[] chars){print(new string(chars, 0, chars.Length));}
// Original:
public E element() {return getFirstImpl();}

// Translation:
public virtual E element(){return getFirstImpl();}
// Original:
public ListNodegroupsResult listNodegroups(ListNodegroupsRequest request) {request = beforeClientExecution(request);return executeListNodegroups(request);}

// Translation:
public virtual ListNodegroupsResponse ListNodegroups(ListNodegroupsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListNodegroupsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListNodegroupsResponseUnmarshaller.Instance;return Invoke<ListNodegroupsResponse>(request, options);}
// Original:
public PutSkillAuthorizationResult putSkillAuthorization(PutSkillAuthorizationRequest request) {request = beforeClientExecution(request);return executePutSkillAuthorization(request);}

// Translation:
public virtual PutSkillAuthorizationResponse PutSkillAuthorization(PutSkillAuthorizationRequest request){var options = new InvokeOptions();options.RequestMarshaller = PutSkillAuthorizationRequestMarshaller.Instance;options.ResponseUnmarshaller = PutSkillAuthorizationResponseUnmarshaller.Instance;return Invoke<PutSkillAuthorizationResponse>(request, options);}
// Original:
public DescribeSourceRegionsResult describeSourceRegions(DescribeSourceRegionsRequest request) {request = beforeClientExecution(request);return executeDescribeSourceRegions(request);}

// Translation:
public virtual DescribeSourceRegionsResponse DescribeSourceRegions(DescribeSourceRegionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeSourceRegionsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeSourceRegionsResponseUnmarshaller.Instance;return Invoke<DescribeSourceRegionsResponse>(request, options);}
// Original:
public SplitShardResult splitShard(SplitShardRequest request) {request = beforeClientExecution(request);return executeSplitShard(request);}

// Translation:
public virtual SplitShardResponse SplitShard(SplitShardRequest request){var options = new InvokeOptions();options.RequestMarshaller = SplitShardRequestMarshaller.Instance;options.ResponseUnmarshaller = SplitShardResponseUnmarshaller.Instance;return Invoke<SplitShardResponse>(request, options);}
// Original:
public CreateTableRequest(String tableName, java.util.List<KeySchemaElement> keySchema) {setTableName(tableName);setKeySchema(keySchema);}

// Translation:
public CreateTableRequest(string tableName, List<KeySchemaElement> keySchema){_tableName = tableName;_keySchema = keySchema;}