validation.json

[
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DVRecord(RecordInputStream in) {_option_flags = in.readInt();_promptTitle = readUnicodeString(in);_errorTitle = readUnicodeString(in);_promptText = readUnicodeString(in);_errorText = readUnicodeString(in);int field_size_first_formula = in.readUShort();_not_used_1 = in.readShort();_formula1 = Formula.read(field_size_first_formula, in);int field_size_sec_formula = in.readUShort();_not_used_2 = in.readShort();_formula2 = Formula.read(field_size_sec_formula, in);_regions = new CellRangeAddressList(in);}\n",
        "output": "public DVRecord(RecordInputStream in1){_option_flags = in1.ReadInt();_promptTitle = ReadUnicodeString(in1);_errorTitle = ReadUnicodeString(in1);_promptText = ReadUnicodeString(in1);_errorText = ReadUnicodeString(in1);int field_size_first_formula = in1.ReadUShort();_not_used_1 = in1.ReadShort();_formula1 = NPOI.SS.Formula.Formula.Read(field_size_first_formula, in1);int field_size_sec_formula = in1.ReadUShort();_not_used_2 = in1.ReadShort();_formula2 = NPOI.SS.Formula.Formula.Read(field_size_sec_formula, in1);_regions = new CellRangeAddressList(in1);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String toString() {return pattern();}\n",
        "output": "public override string ToString(){return Pattern();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public InsertInstanceRequest() {super(\"Ots\", \"2016-06-20\", \"InsertInstance\", \"ots\");setMethod(MethodType.POST);}\n",
        "output": "public InsertInstanceRequest(): base(\"Ots\", \"2016-06-20\", \"InsertInstance\", \"ots\", \"openAPI\"){Method = MethodType.POST;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public boolean contains(Object o) {return indexOf(o) != -1;}\n",
        "output": "public virtual bool contains(object o){return indexOf(o) != -1;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public final ByteBuffer encode(String s) {return encode(CharBuffer.wrap(s));}\n",
        "output": "public java.nio.ByteBuffer encode(string s){return encode(java.nio.CharBuffer.wrap(java.lang.CharSequenceProxy.Wrap(s)));}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public boolean requiresCommitBody() {return false;}\n",
        "output": "public override bool RequiresCommitBody(){return false;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String getKey() {return RawParseUtils.decode(enc, buffer, keyStart, keyEnd);}\n",
        "output": "public string GetKey(){return RawParseUtils.Decode(enc, buffer, keyStart, keyEnd);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1,ValueEval arg2, ValueEval arg3, ValueEval arg4) {double result;try {double d0 = NumericFunction.singleOperandEvaluate(arg0, srcRowIndex, srcColumnIndex);double d1 = NumericFunction.singleOperandEvaluate(arg1, srcRowIndex, srcColumnIndex);double d2 = NumericFunction.singleOperandEvaluate(arg2, srcRowIndex, srcColumnIndex);double d3 = NumericFunction.singleOperandEvaluate(arg3, srcRowIndex, srcColumnIndex);double d4 = NumericFunction.singleOperandEvaluate(arg4, srcRowIndex, srcColumnIndex);result = evaluate(d0, d1, d2, d3, d4 != 0.0);NumericFunction.checkValue(result);} catch (EvaluationException e) {return e.getErrorEval();}return new NumberEval(result);}\n",
        "output": "public ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1,ValueEval arg2, ValueEval arg3, ValueEval arg4){double result;try{double d0 = NumericFunction.SingleOperandEvaluate(arg0, srcRowIndex, srcColumnIndex);double d1 = NumericFunction.SingleOperandEvaluate(arg1, srcRowIndex, srcColumnIndex);double d2 = NumericFunction.SingleOperandEvaluate(arg2, srcRowIndex, srcColumnIndex);double d3 = NumericFunction.SingleOperandEvaluate(arg3, srcRowIndex, srcColumnIndex);double d4 = NumericFunction.SingleOperandEvaluate(arg4, srcRowIndex, srcColumnIndex);result = Evaluate(d0, d1, d2, d3, d4 != 0.0);NumericFunction.CheckValue(result);}catch (EvaluationException e){return e.GetErrorEval();}return new NumberEval(result);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DeleteClientVpnEndpointResult deleteClientVpnEndpoint(DeleteClientVpnEndpointRequest request) {request = beforeClientExecution(request);return executeDeleteClientVpnEndpoint(request);}\n",
        "output": "public virtual DeleteClientVpnEndpointResponse DeleteClientVpnEndpoint(DeleteClientVpnEndpointRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteClientVpnEndpointRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteClientVpnEndpointResponseUnmarshaller.Instance;return Invoke<DeleteClientVpnEndpointResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public Object get(CharSequence key) {List<TernaryTreeNode> list = autocomplete.prefixCompletion(root, key, 0);if (list == null || list.isEmpty()) {return null;}for (TernaryTreeNode n : list) {if (charSeqEquals(n.token, key)) {return n.val;}}return null;}\n",
        "output": "public virtual object Get(string key){IList<TernaryTreeNode> list = autocomplete.PrefixCompletion(root, key, 0);if (list == null || list.Count == 0){return null;}foreach (TernaryTreeNode n in list){if (CharSeqEquals(n.token, key)){return n.val;}}return null;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public StartFleetActionsResult startFleetActions(StartFleetActionsRequest request) {request = beforeClientExecution(request);return executeStartFleetActions(request);}\n",
        "output": "public virtual StartFleetActionsResponse StartFleetActions(StartFleetActionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = StartFleetActionsRequestMarshaller.Instance;options.ResponseUnmarshaller = StartFleetActionsResponseUnmarshaller.Instance;return Invoke<StartFleetActionsResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CellRangeAddress getCellRangeAddress(int index) {return _list.get(index);}\n",
        "output": "public CellRangeAddress GetCellRangeAddress(int index){return (CellRangeAddress)_list[index];}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "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;}\n",
        "output": "public static XmlDocument LoadXML(TextReader input){XmlDocument result = new XmlDocument();try{result.Load(input);}catch (Exception se){throw new Exception(\"Error parsing file:\" + se, se);}return result;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public double get(String name, double dflt) {double vals[] = (double[]) valByRound.get(name);if (vals != null) {return vals[roundNumber % vals.length];}String sval = props.getProperty(name, \"\" + dflt);if (sval.indexOf(\":\") < 0) {return Double.parseDouble(sval);}int k = sval.indexOf(\":\");String colName = sval.substring(0, k);sval = sval.substring(k + 1);colForValByRound.put(name, colName);vals = propToDoubleArray(sval);valByRound.put(name, vals);return vals[roundNumber % vals.length];}\n",
        "output": "public virtual int Get(string name, int dflt){int[] vals;object temp;if (valByRound.TryGetValue(name, out temp) && temp != null){vals = (int[])temp;return vals[roundNumber % vals.Length];}string sval;if (!props.TryGetValue(name, out sval)){sval = dflt.ToString(CultureInfo.InvariantCulture);}if (sval.IndexOf(':') < 0){return int.Parse(sval, CultureInfo.InvariantCulture);}int k = sval.IndexOf(':');string colName = sval.Substring(0, k - 0);sval = sval.Substring(k + 1);colForValByRound[name] = colName;vals = PropToInt32Array(sval);valByRound[name] = vals;return vals[roundNumber % vals.Length];}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public int getBackgroundImageId(){EscherSimpleProperty property = getOptRecord().lookup(EscherPropertyTypes.FILL__PATTERNTEXTURE);return property == null ? 0 : property.getPropertyValue();}\n",
        "output": "public int GetBackgroundImageId(){EscherSimpleProperty property = (EscherSimpleProperty)GetOptRecord().Lookup(EscherProperties.FILL__PATTERNTEXTURE);return property == null ? 0 : property.PropertyValue;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public TreeFilter getTreeFilter() {return treeFilter;}\n",
        "output": "public virtual TreeFilter GetTreeFilter(){return treeFilter;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public GetMemberResult getMember(GetMemberRequest request) {request = beforeClientExecution(request);return executeGetMember(request);}\n",
        "output": "public virtual GetMemberResponse GetMember(GetMemberRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetMemberRequestMarshaller.Instance;options.ResponseUnmarshaller = GetMemberResponseUnmarshaller.Instance;return Invoke<GetMemberResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public boolean canEncode() {return true;}\n",
        "output": "public virtual bool canEncode(){return true;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ReplaceRouteResult replaceRoute(ReplaceRouteRequest request) {request = beforeClientExecution(request);return executeReplaceRoute(request);}\n",
        "output": "public virtual ReplaceRouteResponse ReplaceRoute(ReplaceRouteRequest request){var options = new InvokeOptions();options.RequestMarshaller = ReplaceRouteRequestMarshaller.Instance;options.ResponseUnmarshaller = ReplaceRouteResponseUnmarshaller.Instance;return Invoke<ReplaceRouteResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ObjectId getResultTreeId() {return (resultTree == null) ? null : resultTree.toObjectId();}\n",
        "output": "public override ObjectId GetResultTreeId(){return (resultTree == null) ? null : resultTree.ToObjectId();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public boolean equals(final Object o){boolean rval = this == o;if (!rval && (o != null) && (o.getClass() == this.getClass())){IntList other = ( IntList ) o;if (other._limit == _limit){rval = true;for (int j = 0; rval && (j < _limit); j++){rval = _array[ j ] == other._array[ j ];}}}return rval;}\n",
        "output": "public override bool Equals(Object o){bool rval = this == o;if (!rval && (o != null) && (o.GetType() == this.GetType())){IntList other = (IntList)o;if (other._limit == _limit){rval = true;for (int j = 0; rval && (j < _limit); j++){rval = _array[j] == other._array[j];}}}return rval;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ListReusableDelegationSetsResult listReusableDelegationSets(ListReusableDelegationSetsRequest request) {request = beforeClientExecution(request);return executeListReusableDelegationSets(request);}\n",
        "output": "public virtual ListReusableDelegationSetsResponse ListReusableDelegationSets(ListReusableDelegationSetsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListReusableDelegationSetsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListReusableDelegationSetsResponseUnmarshaller.Instance;return Invoke<ListReusableDelegationSetsResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String toString() {return \"(\" + a.toString() + \" OR \" + b.toString() + \")\";}\n",
        "output": "public override string ToString(){return \"(\" + a.ToString() + \" OR \" + b.ToString() + \")\";}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public InitiateLayerUploadResult initiateLayerUpload(InitiateLayerUploadRequest request) {request = beforeClientExecution(request);return executeInitiateLayerUpload(request);}\n",
        "output": "public virtual InitiateLayerUploadResponse InitiateLayerUpload(InitiateLayerUploadRequest request){var options = new InvokeOptions();options.RequestMarshaller = InitiateLayerUploadRequestMarshaller.Instance;options.ResponseUnmarshaller = InitiateLayerUploadResponseUnmarshaller.Instance;return Invoke<InitiateLayerUploadResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public UpdateRepoRequest() {super(\"cr\", \"2016-06-07\", \"UpdateRepo\", \"cr\");setUriPattern(\"/repos/[RepoNamespace]/[RepoName]\");setMethod(MethodType.POST);}\n",
        "output": "public UpdateRepoRequest(): base(\"cr\", \"2016-06-07\", \"UpdateRepo\", \"cr\", \"openAPI\"){UriPattern = \"/repos/[RepoNamespace]/[RepoName]\";Method = MethodType.POST;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public PhoneticFilterFactory(Map<String,String> args) {super(args);inject = getBoolean(args, INJECT, true);name = require(args, ENCODER);String v = get(args, MAX_CODE_LENGTH);if (v != null) {maxCodeLength = Integer.valueOf(v);} else {maxCodeLength = null;}if (!args.isEmpty()) {throw new IllegalArgumentException(\"Unknown parameters: \" + args);}}\n",
        "output": "public PhoneticFilterFactory(IDictionary<string, string> args): base(args){inject = GetBoolean(args, INJECT, true);name = Require(args, ENCODER);string v = Get(args, MAX_CODE_LENGTH);if (v != null){maxCodeLength = int.Parse(v, CultureInfo.InvariantCulture);}else{maxCodeLength = null;}if (!(args.Count == 0)){throw new ArgumentException(\"Unknown parameters: \" + args);}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public FetchCommand fetch() {return new FetchCommand(repo);}\n",
        "output": "public virtual FetchCommand Fetch(){return new FetchCommand(repo);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public QueryPhraseMap searchPhrase( String fieldName, final List<TermInfo> phraseCandidate ){QueryPhraseMap root = getRootMap( fieldName );if( root == null ) return null;return root.searchPhrase( phraseCandidate );}\n",
        "output": "public virtual QueryPhraseMap SearchPhrase(string fieldName, IList<TermInfo> phraseCandidate){QueryPhraseMap root = GetRootMap(fieldName);if (root == null) return null;return root.SearchPhrase(phraseCandidate);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "@Override public Iterator<Multiset.Entry<K>> iterator() {return new MultisetEntryIterator();}\n",
        "output": "public override java.util.Iterator<java.util.MapClass.Entry<K, V>> iterator(){return new java.util.Hashtable<K, V>.EntryIterator(this._enclosing);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DBSnapshot deleteDBSnapshot(DeleteDBSnapshotRequest request) {request = beforeClientExecution(request);return executeDeleteDBSnapshot(request);}\n",
        "output": "public virtual DeleteDBSnapshotResponse DeleteDBSnapshot(DeleteDBSnapshotRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteDBSnapshotRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteDBSnapshotResponseUnmarshaller.Instance;return Invoke<DeleteDBSnapshotResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void setOutput() {output = true;}\n",
        "output": "public virtual void SetOutput(){output = true;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ByteBuffer compact() {throw new ReadOnlyBufferException();}\n",
        "output": "public override java.nio.ByteBuffer compact(){throw new System.NotImplementedException();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public XmlPullParser newPullParser() throws XmlPullParserException {if (parserClasses == null) throw new XmlPullParserException(\"Factory initialization was incomplete - has not tried \"+classNamesLocation);if (parserClasses.size() == 0) throw new XmlPullParserException(\"No valid parser classes found in \"+classNamesLocation);final StringBuilder issues = new StringBuilder();for (int i = 0; i < parserClasses.size(); i++) {final Class ppClass = (Class) parserClasses.get(i);try {final XmlPullParser pp = (XmlPullParser) ppClass.newInstance();for (Iterator iter = features.keySet().iterator(); iter.hasNext(); ) {final String key = (String) iter.next();final Boolean value = (Boolean) features.get(key);if(value != null && value.booleanValue()) {pp.setFeature(key, true);}}return pp;} catch(Exception ex) {issues.append (ppClass.getName () + \": \"+ ex.toString ()+\"; \");}}throw new XmlPullParserException (\"could not create parser: \"+issues);}\n",
        "output": "public virtual org.xmlpull.v1.XmlPullParser newPullParser(){if (parserClasses == null){throw new org.xmlpull.v1.XmlPullParserException(\"Factory initialization was incomplete - has not tried \"+ classNamesLocation);}if (parserClasses.size() == 0){throw new org.xmlpull.v1.XmlPullParserException(\"No valid parser classes found in \"+ classNamesLocation);}java.lang.StringBuilder issues = new java.lang.StringBuilder();{for (int i = 0; i < parserClasses.size(); i++){System.Type ppClass = (System.Type)parserClasses.get(i);try{org.xmlpull.v1.XmlPullParser pp = (org.xmlpull.v1.XmlPullParser)System.Activator.CreateInstance(ppClass);{for (java.util.Iterator<object> iter = features.keySet().iterator(); iter.hasNext(); ){string key = (string)iter.next();bool value = (bool)features.get(key);if (value != null && value){pp.setFeature(key, true);}}}return pp;}catch (System.Exception ex){issues.append(ppClass.FullName + \": \" + ex.ToString() + \"; \");}}}throw new org.xmlpull.v1.XmlPullParserException(\"could not create parser: \" + issues);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DeleteAnalysisSchemeResult deleteAnalysisScheme(DeleteAnalysisSchemeRequest request) {request = beforeClientExecution(request);return executeDeleteAnalysisScheme(request);}\n",
        "output": "public virtual DeleteAnalysisSchemeResponse DeleteAnalysisScheme(DeleteAnalysisSchemeRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteAnalysisSchemeRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteAnalysisSchemeResponseUnmarshaller.Instance;return Invoke<DeleteAnalysisSchemeResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ExcelExtractor(HSSFWorkbook wb) {super(wb);_wb = wb;_formatter = new HSSFDataFormatter();}\n",
        "output": "public ExcelExtractor(HSSFWorkbook wb): base(wb){this.wb = wb;_formatter = new HSSFDataFormatter();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public IntBuffer put(int index, int c) {checkIndex(index);byteBuffer.putInt(index * SizeOf.INT, c);return this;}\n",
        "output": "public override java.nio.IntBuffer put(int index, int c){checkIndex(index);byteBuffer.putInt(index * libcore.io.SizeOf.INT, c);return this;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public final byte getParameterClass(int index) {if (index >= paramClass.length) {return paramClass[paramClass.length - 1];}return paramClass[index];}\n",
        "output": "public byte GetParameterClass(int index){if (index >= paramClass.Length){return paramClass[paramClass.Length - 1];}return paramClass[index];}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ListEndpointsResult listEndpoints(ListEndpointsRequest request) {request = beforeClientExecution(request);return executeListEndpoints(request);}\n",
        "output": "public virtual ListEndpointsResponse ListEndpoints(ListEndpointsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListEndpointsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListEndpointsResponseUnmarshaller.Instance;return Invoke<ListEndpointsResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public static CharsRef join(String[] words, CharsRefBuilder reuse) {int upto = 0;char[] buffer = reuse.chars();for (String word : words) {final int wordLen = word.length();final int needed = (0 == upto ? wordLen : 1 + upto + wordLen); if (needed > buffer.length) {reuse.grow(needed);buffer = reuse.chars();}if (upto > 0) {buffer[upto++] = SynonymMap.WORD_SEPARATOR;}word.getChars(0, wordLen, buffer, upto);upto += wordLen;}reuse.setLength(upto);return reuse.get();}\n",
        "output": "public static CharsRef Join(string[] words, CharsRef reuse){int upto = 0;char[] buffer = reuse.Chars;foreach (string word in words){int wordLen = word.Length;int needed = (0 == upto ? wordLen : 1 + upto + wordLen); if (needed > buffer.Length){reuse.Grow(needed);buffer = reuse.Chars;}if (upto > 0){buffer[upto++] = SynonymMap.WORD_SEPARATOR;}word.CopyTo(0, buffer, upto, wordLen - 0);upto += wordLen;}reuse.Length = upto;return reuse;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public StringBuffer insert(int index, float f) {return insert(index, Float.toString(f));}\n",
        "output": "public java.lang.StringBuffer insert(int index, float f){return insert(index, System.Convert.ToString(f));}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ShortBuffer put(short[] src, int srcOffset, int shortCount) {if (shortCount > remaining()) {throw new BufferOverflowException();}System.arraycopy(src, srcOffset, backingArray, offset + position, shortCount);position += shortCount;return this;}\n",
        "output": "public override java.nio.ShortBuffer put(short[] src, int srcOffset, int shortCount){if (shortCount > remaining()){throw new java.nio.BufferOverflowException();}System.Array.Copy(src, srcOffset, backingArray, offset + _position, shortCount);_position += shortCount;return this;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DisassociateResolverEndpointIpAddressResult disassociateResolverEndpointIpAddress(DisassociateResolverEndpointIpAddressRequest request) {request = beforeClientExecution(request);return executeDisassociateResolverEndpointIpAddress(request);}\n",
        "output": "public virtual DisassociateResolverEndpointIpAddressResponse DisassociateResolverEndpointIpAddress(DisassociateResolverEndpointIpAddressRequest request){var options = new InvokeOptions();options.RequestMarshaller = DisassociateResolverEndpointIpAddressRequestMarshaller.Instance;options.ResponseUnmarshaller = DisassociateResolverEndpointIpAddressResponseUnmarshaller.Instance;return Invoke<DisassociateResolverEndpointIpAddressResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public AcceptDirectConnectGatewayAssociationProposalResult acceptDirectConnectGatewayAssociationProposal(AcceptDirectConnectGatewayAssociationProposalRequest request) {request = beforeClientExecution(request);return executeAcceptDirectConnectGatewayAssociationProposal(request);}\n",
        "output": "public virtual AcceptDirectConnectGatewayAssociationProposalResponse AcceptDirectConnectGatewayAssociationProposal(AcceptDirectConnectGatewayAssociationProposalRequest request){var options = new InvokeOptions();options.RequestMarshaller = AcceptDirectConnectGatewayAssociationProposalRequestMarshaller.Instance;options.ResponseUnmarshaller = AcceptDirectConnectGatewayAssociationProposalResponseUnmarshaller.Instance;return Invoke<AcceptDirectConnectGatewayAssociationProposalResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public StopStackSetOperationResult stopStackSetOperation(StopStackSetOperationRequest request) {request = beforeClientExecution(request);return executeStopStackSetOperation(request);}\n",
        "output": "public virtual StopStackSetOperationResponse StopStackSetOperation(StopStackSetOperationRequest request){var options = new InvokeOptions();options.RequestMarshaller = StopStackSetOperationRequestMarshaller.Instance;options.ResponseUnmarshaller = StopStackSetOperationResponseUnmarshaller.Instance;return Invoke<StopStackSetOperationResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CacheSubnetGroup createCacheSubnetGroup(CreateCacheSubnetGroupRequest request) {request = beforeClientExecution(request);return executeCreateCacheSubnetGroup(request);}\n",
        "output": "public virtual CreateCacheSubnetGroupResponse CreateCacheSubnetGroup(CreateCacheSubnetGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateCacheSubnetGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateCacheSubnetGroupResponseUnmarshaller.Instance;return Invoke<CreateCacheSubnetGroupResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CachedOrds(OrdinalsSegmentReader source, int maxDoc) throws IOException {offsets = new int[maxDoc + 1];int[] ords = new int[maxDoc]; long totOrds = 0;final IntsRef values = new IntsRef(32);for (int docID = 0; docID < maxDoc; docID++) {offsets[docID] = (int) totOrds;source.get(docID, values);long nextLength = totOrds + values.length;if (nextLength > ords.length) {if (nextLength > ArrayUtil.MAX_ARRAY_LENGTH) {throw new IllegalStateException(\"too many ordinals (>= \" + nextLength + \") to cache\");}ords = ArrayUtil.grow(ords, (int) nextLength);}System.arraycopy(values.ints, 0, ords, (int) totOrds, values.length);totOrds = nextLength;}offsets[maxDoc] = (int) totOrds;if ((double) totOrds / ords.length < 0.9) {this.ordinals = new int[(int) totOrds];System.arraycopy(ords, 0, this.ordinals, 0, (int) totOrds);} else {this.ordinals = ords;}}\n",
        "output": "public CachedOrds(OrdinalsSegmentReader source, int maxDoc){Offsets = new int[maxDoc + 1];int[] ords = new int[maxDoc]; long totOrds = 0;Int32sRef values = new Int32sRef(32);for (int docID = 0; docID < maxDoc; docID++){Offsets[docID] = (int)totOrds;source.Get(docID, values);long nextLength = totOrds + values.Length;if (nextLength > ords.Length){if (nextLength > ArrayUtil.MAX_ARRAY_LENGTH){throw new ThreadStateException(\"too many ordinals (>= \" + nextLength + \") to cache\");}ords = ArrayUtil.Grow(ords, (int)nextLength);}Array.Copy(values.Int32s, 0, ords, (int)totOrds, values.Length);totOrds = nextLength;}Offsets[maxDoc] = (int)totOrds;if ((double)totOrds / ords.Length < 0.9){this.Ordinals = new int[(int)totOrds];Array.Copy(ords, 0, this.Ordinals, 0, (int)totOrds);}else{this.Ordinals = ords;}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String getRawUserInfo() {return userInfo;}\n",
        "output": "public string getRawUserInfo(){return userInfo;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "@Override public Object[] toArray() {return ObjectArrays.toArrayImpl(this);}\n",
        "output": "public override object[] toArray(){lock (this._enclosing){return base.toArray();}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeCompilationJobResult describeCompilationJob(DescribeCompilationJobRequest request) {request = beforeClientExecution(request);return executeDescribeCompilationJob(request);}\n",
        "output": "public virtual DescribeCompilationJobResponse DescribeCompilationJob(DescribeCompilationJobRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeCompilationJobRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeCompilationJobResponseUnmarshaller.Instance;return Invoke<DescribeCompilationJobResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String getQuery() {return decode(query);}\n",
        "output": "public string getQuery(){return decode(query);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CreateEnvironmentResult createEnvironment(CreateEnvironmentRequest request) {request = beforeClientExecution(request);return executeCreateEnvironment(request);}\n",
        "output": "public virtual CreateEnvironmentResponse CreateEnvironment(CreateEnvironmentRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateEnvironmentRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateEnvironmentResponseUnmarshaller.Instance;return Invoke<CreateEnvironmentResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ParseTreeMatch match(ParseTree tree) {return matcher.match(tree, this);}\n",
        "output": "public virtual ParseTreeMatch Match(IParseTree tree){return matcher.Match(tree, this);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public boolean contains(CharSequence cs) {return map.containsKey(cs);}\n",
        "output": "public virtual bool Contains(char[] text){return map.ContainsKey(text, 0, text.Length);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public QueryRequest(String tableName) {setTableName(tableName);}\n",
        "output": "public QueryRequest(string tableName){_tableName = tableName;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public boolean isRowGroupHiddenByParent(int row) {int endLevel;boolean endHidden;int endOfOutlineGroupIdx = findEndOfRowOutlineGroup(row);if (getRow(endOfOutlineGroupIdx + 1) == null) {endLevel = 0;endHidden = false;} else {endLevel = getRow(endOfOutlineGroupIdx + 1).getOutlineLevel();endHidden = getRow(endOfOutlineGroupIdx + 1).getZeroHeight();}int startLevel;boolean startHidden;int startOfOutlineGroupIdx = findStartOfRowOutlineGroup( row );if (startOfOutlineGroupIdx - 1 < 0 || getRow(startOfOutlineGroupIdx - 1) == null) {startLevel = 0;startHidden = false;} else {startLevel = getRow(startOfOutlineGroupIdx - 1).getOutlineLevel();startHidden = getRow(startOfOutlineGroupIdx - 1).getZeroHeight();}if (endLevel > startLevel) {return endHidden;}return startHidden;}\n",
        "output": "public bool IsRowGroupHiddenByParent(int row){int endLevel;bool endHidden;int endOfOutlineGroupIdx = FindEndOfRowOutlineGroup(row);if (GetRow(endOfOutlineGroupIdx + 1) == null){endLevel = 0;endHidden = false;}else{endLevel = GetRow(endOfOutlineGroupIdx + 1).OutlineLevel;endHidden = GetRow(endOfOutlineGroupIdx + 1).ZeroHeight;}int startLevel;bool startHidden;int startOfOutlineGroupIdx = FindStartOfRowOutlineGroup(row);if (startOfOutlineGroupIdx - 1 < 0 || GetRow(startOfOutlineGroupIdx - 1) == null){startLevel = 0;startHidden = false;}else{startLevel = GetRow(startOfOutlineGroupIdx - 1).OutlineLevel;startHidden = GetRow(startOfOutlineGroupIdx - 1).ZeroHeight;}if (endLevel > startLevel){return endHidden;}else{return startHidden;}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public boolean retryFailedLockFileCommit() {return true;}\n",
        "output": "public override bool RetryFailedLockFileCommit(){return true;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ValidateMatchmakingRuleSetResult validateMatchmakingRuleSet(ValidateMatchmakingRuleSetRequest request) {request = beforeClientExecution(request);return executeValidateMatchmakingRuleSet(request);}\n",
        "output": "public virtual ValidateMatchmakingRuleSetResponse ValidateMatchmakingRuleSet(ValidateMatchmakingRuleSetRequest request){var options = new InvokeOptions();options.RequestMarshaller = ValidateMatchmakingRuleSetRequestMarshaller.Instance;options.ResponseUnmarshaller = ValidateMatchmakingRuleSetResponseUnmarshaller.Instance;return Invoke<ValidateMatchmakingRuleSetResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public boolean get(String name, boolean dflt) {boolean vals[] = (boolean[]) valByRound.get(name);if (vals != null) {return vals[roundNumber % vals.length];}String sval = props.getProperty(name, \"\" + dflt);if (sval.indexOf(\":\") < 0) {return Boolean.valueOf(sval).booleanValue();}int k = sval.indexOf(\":\");String colName = sval.substring(0, k);sval = sval.substring(k + 1);colForValByRound.put(name, colName);vals = propToBooleanArray(sval);valByRound.put(name, vals);return vals[roundNumber % vals.length];}\n",
        "output": "public virtual bool Get(string name, bool dflt){bool[] vals;object temp;if (valByRound.TryGetValue(name, out temp) && temp != null){vals = (bool[])temp;return vals[roundNumber % vals.Length];}string sval;if (!props.TryGetValue(name, out sval)){sval = dflt.ToString(); }if (sval.IndexOf(':') < 0){return bool.Parse(sval);}int k = sval.IndexOf(':');string colName = sval.Substring(0, k - 0);sval = sval.Substring(k + 1);colForValByRound[name] = colName;vals = PropToBooleanArray(sval);valByRound[name] = vals;return vals[roundNumber % vals.Length];}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public UpdateLinkAttributesResult updateLinkAttributes(UpdateLinkAttributesRequest request) {request = beforeClientExecution(request);return executeUpdateLinkAttributes(request);}\n",
        "output": "public virtual UpdateLinkAttributesResponse UpdateLinkAttributes(UpdateLinkAttributesRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateLinkAttributesRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateLinkAttributesResponseUnmarshaller.Instance;return Invoke<UpdateLinkAttributesResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public NumericPayloadTokenFilter(TokenStream input, float payload, String typeMatch) {super(input);if (typeMatch == null) {throw new IllegalArgumentException(\"typeMatch must not be null\");}thePayload = new BytesRef(PayloadHelper.encodeFloat(payload));this.typeMatch = typeMatch;}\n",
        "output": "public NumericPayloadTokenFilter(TokenStream input, float payload, string typeMatch): base(input){if (typeMatch == null){throw new ArgumentException(\"typeMatch cannot be null\");}thePayload = new BytesRef(PayloadHelper.EncodeSingle(payload));this.typeMatch = typeMatch;this.payloadAtt = AddAttribute<IPayloadAttribute>();this.typeAtt = AddAttribute<ITypeAttribute>();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String toString(){StringBuilder buffer = new StringBuilder();buffer.append(\"[CALCCOUNT]\\n\");buffer.append(\"    .iterations     = \").append(Integer.toHexString(getIterations())).append(\"\\n\");buffer.append(\"[/CALCCOUNT]\\n\");return buffer.toString();}\n",
        "output": "public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append(\"[CALCCOUNT]\\n\");buffer.Append(\"    .iterations     = \").Append(StringUtil.ToHexString(Iterations)).Append(\"\\n\");buffer.Append(\"[/CALCCOUNT]\\n\");return buffer.ToString();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public E push(E object) {addElement(object);return object;}\n",
        "output": "public virtual E push(E @object){addElement(@object);return @object;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) {super(initialCapacity, loadFactor);init();this.accessOrder = accessOrder;}\n",
        "output": "public LinkedHashMap(int initialCapacity, float loadFactor, bool accessOrder) : base(initialCapacity, loadFactor){init();this.accessOrder = accessOrder;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public TreeSet() {backingMap = new TreeMap<E, Object>();}\n",
        "output": "public TreeSet(){backingMap = new java.util.TreeMap<E, object>();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public long skip(long charCount) throws IOException {if (charCount < 0) {throw new IllegalArgumentException(\"charCount < 0: \" + charCount);}synchronized (lock) {long skipped = 0;int toRead = charCount < 512 ? (int) charCount : 512;char[] charsSkipped = new char[toRead];while (skipped < charCount) {int read = read(charsSkipped, 0, toRead);if (read == -1) {return skipped;}skipped += read;if (read < toRead) {return skipped;}if (charCount - skipped < toRead) {toRead = (int) (charCount - skipped);}}return skipped;}}\n",
        "output": "public virtual long skip(long charCount){if (charCount < 0){throw new System.ArgumentException(\"charCount < 0: \" + charCount);}lock (@lock){long skipped = 0;int toRead = charCount < 512 ? (int)charCount : 512;char[] charsSkipped = new char[toRead];while (skipped < charCount){int read_1 = read(charsSkipped, 0, toRead);if (read_1 == -1){return skipped;}skipped += read_1;if (read_1 < toRead){return skipped;}if (charCount - skipped < toRead){toRead = (int)(charCount - skipped);}}return skipped;}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ValueEval getRef3DEval(Ref3DPxg rptg) {SheetRangeEvaluator sre = createExternSheetRefEvaluator(rptg.getSheetName(), rptg.getLastSheetName(), rptg.getExternalWorkbookNumber());return new LazyRefEval(rptg.getRow(), rptg.getColumn(), sre);}\n",
        "output": "public ValueEval GetRef3DEval(Ref3DPxg rptg){SheetRangeEvaluator sre = CreateExternSheetRefEvaluator(rptg.SheetName, rptg.LastSheetName, rptg.ExternalWorkbookNumber);return new LazyRefEval(rptg.Row, rptg.Column, sre);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public NewAnalyzerTask(PerfRunData runData) {super(runData);analyzerNames = new ArrayList<>();}\n",
        "output": "public NewAnalyzerTask(PerfRunData runData): base(runData){analyzerNames = new List<string>();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public boolean equals( Object o ) {return o instanceof EnglishStemmer;}\n",
        "output": "public override bool Equals(object o){return o is EnglishStemmer;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void decode(long[] blocks, int blocksOffset, long[] values,int valuesOffset, int iterations) {for (int i = 0; i < iterations; ++i) {final long block = blocks[blocksOffset++];valuesOffset = decode(block, values, valuesOffset);}}\n",
        "output": "public override void Decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations){for (int i = 0; i < iterations; ++i){long block = blocks[blocksOffset++];valuesOffset = Decode(block, values, valuesOffset);}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public final void incRef() {ensureOpen();refCount.incrementAndGet();}\n",
        "output": "public void IncRef(){EnsureOpen();refCount.IncrementAndGet();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ReplicationGroup testFailover(TestFailoverRequest request) {request = beforeClientExecution(request);return executeTestFailover(request);}\n",
        "output": "public virtual TestFailoverResponse TestFailover(TestFailoverRequest request){var options = new InvokeOptions();options.RequestMarshaller = TestFailoverRequestMarshaller.Instance;options.ResponseUnmarshaller = TestFailoverResponseUnmarshaller.Instance;return Invoke<TestFailoverResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public RefWriter(Collection<Ref> refs) {this.refs = RefComparator.sort(refs);}\n",
        "output": "public RefWriter(ICollection<Ref> refs){this.refs = RefComparator.Sort(refs);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ByteVector(int capacity) {if (capacity > 0) {blockSize = capacity;} else {blockSize = DEFAULT_BLOCK_SIZE;}array = new byte[blockSize];n = 0;}\n",
        "output": "public ByteVector(int capacity){if (capacity > 0){blockSize = capacity;}else{blockSize = DEFAULT_BLOCK_SIZE;}array = new byte[blockSize];n = 0;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void endWorker() {if (workers.decrementAndGet() == 0)process.release();}\n",
        "output": "public virtual void EndWorker(){if (workers.DecrementAndGet() == 0){process.Release();}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeVolumeStatusResult describeVolumeStatus(DescribeVolumeStatusRequest request) {request = beforeClientExecution(request);return executeDescribeVolumeStatus(request);}\n",
        "output": "public virtual DescribeVolumeStatusResponse DescribeVolumeStatus(DescribeVolumeStatusRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeVolumeStatusRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeVolumeStatusResponseUnmarshaller.Instance;return Invoke<DescribeVolumeStatusResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public IntMapper(final int initialCapacity) {elements = new ArrayList<>(initialCapacity);valueKeyMap = new HashMap<>(initialCapacity);}\n",
        "output": "public IntMapper(int InitialCapacity){elements = new List<T>(InitialCapacity);valueKeyMap = new Dictionary<T, int>(InitialCapacity);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void serialize(LittleEndianOutput out) {out.writeShort(field_1_borderType);out.writeShort(field_2_options);}\n",
        "output": "public override void Serialize(ILittleEndianOutput out1){out1.WriteShort(field_1_borderType);out1.WriteShort(field_2_options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public synchronized void copyInto(Object[] elements) {System.arraycopy(elementData, 0, elements, 0, elementCount);}\n",
        "output": "public virtual void copyInto(object[] elements_1){lock (this){System.Array.Copy(elementData, 0, elements_1, 0, elementCount);}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1) {double s0;String s1;try {s0 = evaluateDoubleArg(arg0, srcRowIndex, srcColumnIndex);s1 = evaluateStringArg(arg1, srcRowIndex, srcColumnIndex);} catch (EvaluationException e) {return e.getErrorEval();}try {String formattedStr = formatter.formatRawCellContents(s0, -1, s1);return new StringEval(formattedStr);} catch (Exception e) {return ErrorEval.VALUE_INVALID;}}\n",
        "output": "public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0,ValueEval arg1){String arg;int index;try{arg = TextFunction.EvaluateStringArg(arg0, srcRowIndex, srcColumnIndex);index = TextFunction.EvaluateIntArg(arg1, srcRowIndex, srcColumnIndex);}catch (EvaluationException e){return e.GetErrorEval();}if (index < 0){return ErrorEval.VALUE_INVALID;}String result;if (_isLeft){result = arg.Substring(0, Math.Min(arg.Length, index));}else{result = arg.Substring(Math.Max(0, arg.Length - index));}return new StringEval(result);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CustomViewSettingsRecordAggregate(RecordStream rs) {_begin = rs.getNext();if (_begin.getSid() != UserSViewBegin.sid) {throw new IllegalStateException(\"Bad begin record\");}List<RecordBase> temp = new ArrayList<>();while (rs.peekNextSid() != UserSViewEnd.sid) {if (PageSettingsBlock.isComponentRecord(rs.peekNextSid())) {if (_psBlock != null) {if (rs.peekNextSid() == HeaderFooterRecord.sid) {_psBlock.addLateHeaderFooter((HeaderFooterRecord)rs.getNext());continue;}throw new IllegalStateException(\"Found more than one PageSettingsBlock in chart sub-stream, had sid: \" + rs.peekNextSid());}_psBlock = new PageSettingsBlock(rs);temp.add(_psBlock);continue;}temp.add(rs.getNext());}_recs = temp;_end = rs.getNext(); if (_end.getSid() != UserSViewEnd.sid) {throw new IllegalStateException(\"Bad custom view settings end record\");}}\n",
        "output": "public CustomViewSettingsRecordAggregate(RecordStream rs){_begin = rs.GetNext();if (_begin.Sid != UserSViewBegin.sid){throw new InvalidOperationException(\"Bad begin record\");}List<RecordBase> temp = new List<RecordBase>();while (rs.PeekNextSid() != UserSViewEnd.sid){if (PageSettingsBlock.IsComponentRecord(rs.PeekNextSid())){if (_psBlock != null){throw new InvalidOperationException(\"Found more than one PageSettingsBlock in custom view Settings sub-stream\");}_psBlock = new PageSettingsBlock(rs);temp.Add(_psBlock);continue;}temp.Add(rs.GetNext());}_recs = temp;_end = rs.GetNext(); if (_end.Sid != UserSViewEnd.sid){throw new InvalidOperationException(\"Bad custom view Settings end record\");}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DeleteSignalingChannelResult deleteSignalingChannel(DeleteSignalingChannelRequest request) {request = beforeClientExecution(request);return executeDeleteSignalingChannel(request);}\n",
        "output": "public virtual DeleteSignalingChannelResponse DeleteSignalingChannel(DeleteSignalingChannelRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteSignalingChannelRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteSignalingChannelResponseUnmarshaller.Instance;return Invoke<DeleteSignalingChannelResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "@Override public boolean remove(Object o) {if (contains(o)) {Entry<?> entry = (Entry<?>) o;AtomicInteger frequency = backingMap.remove(entry.getElement());int numberRemoved = frequency.getAndSet(0);size -= numberRemoved;return true;}return false;}\n",
        "output": "public override bool remove(object o){if (!(o is java.util.MapClass.Entry<K, V>)){return false;}java.util.MapClass.Entry<object, object> e = (java.util.MapClass.Entry<object, object>)o;return this._enclosing.removeMapping(e.getKey(), e.getValue());}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public SnapshotDeletionPolicy(IndexDeletionPolicy primary) {this.primary = primary;}\n",
        "output": "public SnapshotDeletionPolicy(IndexDeletionPolicy primary){this.primary = primary;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void throwException() throws BufferUnderflowException,BufferOverflowException, UnmappableCharacterException,MalformedInputException, CharacterCodingException {switch (this.type) {case TYPE_UNDERFLOW:throw new BufferUnderflowException();case TYPE_OVERFLOW:throw new BufferOverflowException();case TYPE_UNMAPPABLE_CHAR:throw new UnmappableCharacterException(this.length);case TYPE_MALFORMED_INPUT:throw new MalformedInputException(this.length);default:throw new CharacterCodingException();}}\n",
        "output": "public virtual void throwException(){switch (this.type){case TYPE_UNDERFLOW:{throw new java.nio.BufferUnderflowException();}case TYPE_OVERFLOW:{throw new java.nio.BufferOverflowException();}case TYPE_UNMAPPABLE_CHAR:{throw new java.nio.charset.UnmappableCharacterException(this._length);}case TYPE_MALFORMED_INPUT:{throw new java.nio.charset.MalformedInputException(this._length);}default:{throw new java.nio.charset.CharacterCodingException();}}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public StringPtg(LittleEndianInput in)  {int nChars = in.readUByte(); _is16bitUnicode = (in.readByte() & 0x01) != 0;if (_is16bitUnicode) {field_3_string = StringUtil.readUnicodeLE(in, nChars);} else {field_3_string = StringUtil.readCompressedUnicode(in, nChars);}}\n",
        "output": "public StringPtg(ILittleEndianInput in1){int field_1_length = in1.ReadUByte();field_2_options = (byte)in1.ReadByte();_is16bitUnicode = (field_2_options & 0x01) != 0;if (_is16bitUnicode){field_3_string = StringUtil.ReadUnicodeLE(in1, field_1_length);}else{field_3_string = StringUtil.ReadCompressedUnicode(in1, field_1_length);}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public GetPublicAccessUrlsRequest() {super(\"CloudPhoto\", \"2017-07-11\", \"GetPublicAccessUrls\", \"cloudphoto\");setProtocol(ProtocolType.HTTPS);}\n",
        "output": "public GetPublicAccessUrlsRequest(): base(\"CloudPhoto\", \"2017-07-11\", \"GetPublicAccessUrls\", \"cloudphoto\", \"openAPI\"){Protocol = ProtocolType.HTTPS;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CleanCommand clean() {return new CleanCommand(repo);}\n",
        "output": "public virtual CleanCommand Clean(){return new CleanCommand(repo);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public Collection<PackFile> getPacks() {PackList list = packList.get();if (list == NO_PACKS)list = scanPacks(list);PackFile[] packs = list.packs;return Collections.unmodifiableCollection(Arrays.asList(packs));}\n",
        "output": "public virtual ICollection<PackFile> GetPacks(){ObjectDirectory.PackList list = packList.Get();if (list == NO_PACKS){list = ScanPacks(list);}PackFile[] packs = list.packs;return Sharpen.Collections.UnmodifiableCollection(Arrays.AsList(packs));}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeStackDriftDetectionStatusResult describeStackDriftDetectionStatus(DescribeStackDriftDetectionStatusRequest request) {request = beforeClientExecution(request);return executeDescribeStackDriftDetectionStatus(request);}\n",
        "output": "public virtual DescribeStackDriftDetectionStatusResponse DescribeStackDriftDetectionStatus(DescribeStackDriftDetectionStatusRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeStackDriftDetectionStatusRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeStackDriftDetectionStatusResponseUnmarshaller.Instance;return Invoke<DescribeStackDriftDetectionStatusResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ListCloudFrontOriginAccessIdentitiesResult listCloudFrontOriginAccessIdentities(ListCloudFrontOriginAccessIdentitiesRequest request) {request = beforeClientExecution(request);return executeListCloudFrontOriginAccessIdentities(request);}\n",
        "output": "public virtual ListCloudFrontOriginAccessIdentitiesResponse ListCloudFrontOriginAccessIdentities(ListCloudFrontOriginAccessIdentitiesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListCloudFrontOriginAccessIdentitiesRequestMarshaller.Instance;options.ResponseUnmarshaller = ListCloudFrontOriginAccessIdentitiesResponseUnmarshaller.Instance;return Invoke<ListCloudFrontOriginAccessIdentitiesResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public static SshSessionFactory getInstance() {return INSTANCE;}\n",
        "output": "public static SshSessionFactory GetInstance(){return INSTANCE;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ListConferenceProvidersResult listConferenceProviders(ListConferenceProvidersRequest request) {request = beforeClientExecution(request);return executeListConferenceProviders(request);}\n",
        "output": "public virtual ListConferenceProvidersResponse ListConferenceProviders(ListConferenceProvidersRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListConferenceProvidersRequestMarshaller.Instance;options.ResponseUnmarshaller = ListConferenceProvidersResponseUnmarshaller.Instance;return Invoke<ListConferenceProvidersResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public UpdateReceiptRuleResult updateReceiptRule(UpdateReceiptRuleRequest request) {request = beforeClientExecution(request);return executeUpdateReceiptRule(request);}\n",
        "output": "public virtual UpdateReceiptRuleResponse UpdateReceiptRule(UpdateReceiptRuleRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateReceiptRuleRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateReceiptRuleResponseUnmarshaller.Instance;return Invoke<UpdateReceiptRuleResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String toString() {final 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();}\n",
        "output": "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();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void serialize(LittleEndianOutput out) {out.writeShort(sid);out.writeShort(length);out.writeShort(flags);}\n",
        "output": "public override void Serialize(ILittleEndianOutput out1){out1.WriteShort(sid);out1.WriteShort(length);out1.WriteShort(flags);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public UpdateHealthCheckResult updateHealthCheck(UpdateHealthCheckRequest request) {request = beforeClientExecution(request);return executeUpdateHealthCheck(request);}\n",
        "output": "public virtual UpdateHealthCheckResponse UpdateHealthCheck(UpdateHealthCheckRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateHealthCheckRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateHealthCheckResponseUnmarshaller.Instance;return Invoke<UpdateHealthCheckResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public synchronized long ramBytesUsed() {long bytes = 0;for(CachedOrds ords : ordsCache.values()) {bytes += ords.ramBytesUsed();}return bytes;}\n",
        "output": "public long RamBytesUsed(){long mem = RamUsageEstimator.ShallowSizeOf(this) + RamUsageEstimator.SizeOf(Offsets);if (Offsets != Ordinals){mem += RamUsageEstimator.SizeOf(Ordinals);}return mem;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public UpdateWorkforceResult updateWorkforce(UpdateWorkforceRequest request) {request = beforeClientExecution(request);return executeUpdateWorkforce(request);}\n",
        "output": "public virtual UpdateWorkforceResponse UpdateWorkforce(UpdateWorkforceRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateWorkforceRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateWorkforceResponseUnmarshaller.Instance;return Invoke<UpdateWorkforceResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void setObjectId(AnyObjectId id) {id.copyRawTo(idBuffer(), idOffset());}\n",
        "output": "public virtual void SetObjectId(AnyObjectId id){id.CopyRawTo(IdBuffer, IdOffset);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void write(byte[] buffer, int byteOffset, int byteCount) throws IOException {IoBridge.write(fd, buffer, byteOffset, byteCount);if (syncMetadata) {fd.sync();}}\n",
        "output": "public virtual void write(byte[] buffer, int byteOffset, int byteCount){throw new System.NotImplementedException();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public GetBlockResult getBlock(GetBlockRequest request) {request = beforeClientExecution(request);return executeGetBlock(request);}\n",
        "output": "public virtual GetBlockResponse GetBlock(GetBlockRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetBlockRequestMarshaller.Instance;options.ResponseUnmarshaller = GetBlockResponseUnmarshaller.Instance;return Invoke<GetBlockResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void exportDirectory(File dir) {exportBase.add(dir);}\n",
        "output": "public virtual void ExportDirectory(FilePath dir){exportBase.AddItem(dir);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CreateReservedInstancesListingResult createReservedInstancesListing(CreateReservedInstancesListingRequest request) {request = beforeClientExecution(request);return executeCreateReservedInstancesListing(request);}\n",
        "output": "public virtual CreateReservedInstancesListingResponse CreateReservedInstancesListing(CreateReservedInstancesListingRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateReservedInstancesListingRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateReservedInstancesListingResponseUnmarshaller.Instance;return Invoke<CreateReservedInstancesListingResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ByteBuffer put(byte b) {throw new ReadOnlyBufferException();}\n",
        "output": "public override java.nio.ByteBuffer put(byte b){throw new java.nio.ReadOnlyBufferException();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ValueEval evaluate(ValueEval[] args, int srcCellRow, int srcCellCol) {double result;try {List<Double> temp = new ArrayList<>();for (ValueEval arg : args) {collectValues(arg, temp);}double[] values = new double[temp.size()];for (int i = 0; i < values.length; i++) {values[i] = temp.get(i).doubleValue();}result = evaluate(values);} catch (EvaluationException e) {return e.getErrorEval();}return new NumberEval(result);}\n",
        "output": "public ValueEval Evaluate(ValueEval[] args, int srcCellRow, int srcCellCol){double result;try{IList temp = new ArrayList();for (int i = 0; i < args.Length; i++){CollectValues(args[i], temp);}double[] values = new double[temp.Count];for (int i = 0; i < values.Length; i++){values[i] = (Double)temp[i];}result = Evaluate(values);}catch (EvaluationException e){return e.GetErrorEval();}return new NumberEval(result);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public static int getCharType(char ch) {if (isSurrogate(ch))return CharType.SURROGATE;if (ch >= 0x4E00 && ch <= 0x9FA5)return CharType.HANZI;if ((ch >= 0x0041 && ch <= 0x005A) || (ch >= 0x0061 && ch <= 0x007A))return CharType.LETTER;if (ch >= 0x0030 && ch <= 0x0039)return CharType.DIGIT;if (ch == ' ' || ch == '\\t' || ch == '\\r' || ch == '\\n' || ch == '\u3000')return CharType.SPACE_LIKE;if ((ch >= 0x0021 && ch <= 0x00BB) || (ch >= 0x2010 && ch <= 0x2642)|| (ch >= 0x3001 && ch <= 0x301E))return CharType.DELIMITER;if ((ch >= 0xFF21 && ch <= 0xFF3A) || (ch >= 0xFF41 && ch <= 0xFF5A))return CharType.FULLWIDTH_LETTER;if (ch >= 0xFF10 && ch <= 0xFF19)return CharType.FULLWIDTH_DIGIT;if (ch >= 0xFE30 && ch <= 0xFF63)return CharType.DELIMITER;return CharType.OTHER;}\n",
        "output": "public static CharType GetCharType(char ch){if (ch >= 0x4E00 && ch <= 0x9FA5)return CharType.HANZI;if ((ch >= 0x0041 && ch <= 0x005A) || (ch >= 0x0061 && ch <= 0x007A))return CharType.LETTER;if (ch >= 0x0030 && ch <= 0x0039)return CharType.DIGIT;if (ch == ' ' || ch == '\\t' || ch == '\\r' || ch == '\\n' || ch == '\u3000')return CharType.SPACE_LIKE;if ((ch >= 0x0021 && ch <= 0x00BB) || (ch >= 0x2010 && ch <= 0x2642)|| (ch >= 0x3001 && ch <= 0x301E))return CharType.DELIMITER;if ((ch >= 0xFF21 && ch <= 0xFF3A) || (ch >= 0xFF41 && ch <= 0xFF5A))return CharType.FULLWIDTH_LETTER;if (ch >= 0xFF10 && ch <= 0xFF19)return CharType.FULLWIDTH_DIGIT;if (ch >= 0xFE30 && ch <= 0xFF63)return CharType.DELIMITER;return CharType.OTHER;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public StopJumpserverRequest() {super(\"HPC\", \"2016-06-03\", \"StopJumpserver\", \"hpc\");setMethod(MethodType.POST);}\n",
        "output": "public StopJumpserverRequest(): base(\"HPC\", \"2016-06-03\", \"StopJumpserver\"){Method = MethodType.POST;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CreateDirectoryConfigResult createDirectoryConfig(CreateDirectoryConfigRequest request) {request = beforeClientExecution(request);return executeCreateDirectoryConfig(request);}\n",
        "output": "public virtual CreateDirectoryConfigResponse CreateDirectoryConfig(CreateDirectoryConfigRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateDirectoryConfigRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateDirectoryConfigResponseUnmarshaller.Instance;return Invoke<CreateDirectoryConfigResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeExportTasksResult describeExportTasks() {return describeExportTasks(new DescribeExportTasksRequest());}\n",
        "output": "public virtual DescribeExportTasksResponse DescribeExportTasks(){return DescribeExportTasks(new DescribeExportTasksRequest());}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ExportClientVpnClientCertificateRevocationListResult exportClientVpnClientCertificateRevocationList(ExportClientVpnClientCertificateRevocationListRequest request) {request = beforeClientExecution(request);return executeExportClientVpnClientCertificateRevocationList(request);}\n",
        "output": "public virtual ExportClientVpnClientCertificateRevocationListResponse ExportClientVpnClientCertificateRevocationList(ExportClientVpnClientCertificateRevocationListRequest request){var options = new InvokeOptions();options.RequestMarshaller = ExportClientVpnClientCertificateRevocationListRequestMarshaller.Instance;options.ResponseUnmarshaller = ExportClientVpnClientCertificateRevocationListResponseUnmarshaller.Instance;return Invoke<ExportClientVpnClientCertificateRevocationListResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CompleteMultipartUploadResult completeMultipartUpload(CompleteMultipartUploadRequest request) {request = beforeClientExecution(request);return executeCompleteMultipartUpload(request);}\n",
        "output": "public virtual CompleteMultipartUploadResponse CompleteMultipartUpload(CompleteMultipartUploadRequest request){var options = new InvokeOptions();options.RequestMarshaller = CompleteMultipartUploadRequestMarshaller.Instance;options.ResponseUnmarshaller = CompleteMultipartUploadResponseUnmarshaller.Instance;return Invoke<CompleteMultipartUploadResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public long ramBytesUsed() {long sizeInBytes = 0;sizeInBytes += RamUsageEstimator.sizeOf(minValues);sizeInBytes += RamUsageEstimator.sizeOf(averages);for(PackedInts.Reader reader: subReaders) {sizeInBytes += reader.ramBytesUsed();}return sizeInBytes;}\n",
        "output": "public long RamBytesUsed(){long sizeInBytes = 0;sizeInBytes += RamUsageEstimator.SizeOf(minValues);sizeInBytes += RamUsageEstimator.SizeOf(averages);foreach (PackedInt32s.Reader reader in subReaders){sizeInBytes += reader.RamBytesUsed();}return sizeInBytes;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public static void fill(Object[] array, Object value) {for (int i = 0; i < array.length; i++) {array[i] = value;}}\n",
        "output": "public static void fill(object[] array, object value){{for (int i = 0; i < array.Length; i++){array[i] = value;}}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ByteBuffer putDouble(int index, double value) {throw new ReadOnlyBufferException();}\n",
        "output": "public override java.nio.ByteBuffer putDouble(int index, double value){throw new System.NotImplementedException();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeAdjustmentTypesResult describeAdjustmentTypes() {return describeAdjustmentTypes(new DescribeAdjustmentTypesRequest());}\n",
        "output": "public virtual DescribeAdjustmentTypesResponse DescribeAdjustmentTypes(){return DescribeAdjustmentTypes(new DescribeAdjustmentTypesRequest());}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public PersonIdent getSourceCommitter() {RevCommit c = getSourceCommit();return c != null ? c.getCommitterIdent() : null;}\n",
        "output": "public virtual PersonIdent GetSourceCommitter(){RevCommit c = GetSourceCommit();return c != null ? c.GetCommitterIdent() : null;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public Object[] toArray() {int index = 0;Object[] contents = new Object[size];Link<E> link = voidLink.next;while (link != voidLink) {contents[index++] = link.data;link = link.next;}return contents;}\n",
        "output": "public override object[] toArray(){int index = 0;object[] contents = new object[_size];java.util.LinkedList.Link<E> link = voidLink.next;while (link != voidLink){contents[index++] = link.data;link = link.next;}return contents;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String toString() {return name + \" version \" + version;}\n",
        "output": "public override string ToString(){return \"Provider{\" + Sharpen.Util.IntToHexString(Sharpen.Util.IdentityHashCode(this)) + \" \" + info.name + \"}\";}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public PushCommand setRefSpecs(RefSpec... specs) {checkCallable();this.refSpecs.clear();Collections.addAll(refSpecs, specs);return this;}\n",
        "output": "public virtual NGit.Api.PushCommand SetRefSpecs(params RefSpec[] specs){CheckCallable();this.refSpecs.Clear();Sharpen.Collections.AddAll(refSpecs, specs);return this;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String toString(String field) {StringBuilder buffer = new StringBuilder();buffer.append(\"spanFirst(\");buffer.append(match.toString(field));buffer.append(\", \");buffer.append(end);buffer.append(\")\");return buffer.toString();}\n",
        "output": "public override string ToString(string field){StringBuilder buffer = new StringBuilder();buffer.Append(\"spanFirst(\");buffer.Append(m_match.ToString(field));buffer.Append(\", \");buffer.Append(m_end);buffer.Append(\")\");buffer.Append(ToStringUtils.Boost(Boost));return buffer.ToString();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public X509Certificate[] getAcceptedIssuers() {return null;}\n",
        "output": "public virtual X509Certificate[] GetAcceptedIssuers(){return null;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public int read() {if (pos < size) {return s.charAt(pos++);} else {s = null;return -1;}}\n",
        "output": "public override int Read(){if (pos < size){return s[pos++];}else{s = null;return -1;}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public PersonIdent getRefLogIdent() {return destination.getRefLogIdent();}\n",
        "output": "public virtual PersonIdent GetRefLogIdent(){return destination.GetRefLogIdent();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "@Override public int size() {return size;}\n",
        "output": "public override int size(){return _size;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public GetRequestValidatorsResult getRequestValidators(GetRequestValidatorsRequest request) {request = beforeClientExecution(request);return executeGetRequestValidators(request);}\n",
        "output": "public virtual GetRequestValidatorsResponse GetRequestValidators(GetRequestValidatorsRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetRequestValidatorsRequestMarshaller.Instance;options.ResponseUnmarshaller = GetRequestValidatorsResponseUnmarshaller.Instance;return Invoke<GetRequestValidatorsResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String toString() {return \"I(F)\";}\n",
        "output": "public override string ToString(){return \"I(F)\";}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;SegToken other = (SegToken) obj;if (!Arrays.equals(charArray, other.charArray))return false;if (endOffset != other.endOffset)return false;if (index != other.index)return false;if (startOffset != other.startOffset)return false;if (weight != other.weight)return false;if (wordType != other.wordType)return false;return true;}\n",
        "output": "public override bool Equals(object obj){if (this == obj)return true;if (obj == null)return false;if (GetType() != obj.GetType())return false;SegToken other = (SegToken)obj;if (!Arrays.Equals(CharArray, other.CharArray))return false;if (EndOffset != other.EndOffset)return false;if (Index != other.Index)return false;if (StartOffset != other.StartOffset)return false;if (Weight != other.Weight)return false;if (WordType != other.WordType)return false;return true;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public int fillFields(byte[] data, int offset, EscherRecordFactory recordFactory) { readHeader( data, offset );int pos            = offset + 8;int size           = 0;field_1_shapeId    =  LittleEndian.getInt( data, pos + size );     size += 4;field_2_flags      =  LittleEndian.getInt( data, pos + size );     size += 4;return getRecordSize();}\n",
        "output": "public override int FillFields(byte[] data, int offset, IEscherRecordFactory recordFactory){int bytesRemaining = ReadHeader(data, offset);int pos = offset + 8;int size = 0;field_1_shapeId = LittleEndian.GetInt(data, pos + size); size += 4;field_2_flags = LittleEndian.GetInt(data, pos + size); size += 4;return RecordSize;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String getSignerName() {return ALGORITHM_NAME;}\n",
        "output": "public override string GetSignerName(){return ALGORITHM_NAME;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public synchronized void clear() {if (size != 0) {Arrays.fill(table, null);modCount++;size = 0;}}\n",
        "output": "public virtual void clear(){lock (this){if (_size != 0){java.util.Arrays.fill(table, null);modCount++;_size = 0;}}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CancelCapacityReservationResult cancelCapacityReservation(CancelCapacityReservationRequest request) {request = beforeClientExecution(request);return executeCancelCapacityReservation(request);}\n",
        "output": "public virtual CancelCapacityReservationResponse CancelCapacityReservation(CancelCapacityReservationRequest request){var options = new InvokeOptions();options.RequestMarshaller = CancelCapacityReservationRequestMarshaller.Instance;options.ResponseUnmarshaller = CancelCapacityReservationResponseUnmarshaller.Instance;return Invoke<CancelCapacityReservationResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ImportDocumentationPartsResult importDocumentationParts(ImportDocumentationPartsRequest request) {request = beforeClientExecution(request);return executeImportDocumentationParts(request);}\n",
        "output": "public virtual ImportDocumentationPartsResponse ImportDocumentationParts(ImportDocumentationPartsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ImportDocumentationPartsRequestMarshaller.Instance;options.ResponseUnmarshaller = ImportDocumentationPartsResponseUnmarshaller.Instance;return Invoke<ImportDocumentationPartsResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public SuggestResult suggest(SuggestRequest request) {request = beforeClientExecution(request);return executeSuggest(request);}\n",
        "output": "public virtual SuggestResponse Suggest(SuggestRequest request){var options = new InvokeOptions();options.RequestMarshaller = SuggestRequestMarshaller.Instance;options.ResponseUnmarshaller = SuggestResponseUnmarshaller.Instance;return Invoke<SuggestResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public Explanation explain(int docId, String field, int numPayloadsSeen, float payloadScore){return Explanation.match(docScore(docId, field, numPayloadsSeen, payloadScore),getClass().getSimpleName() + \".docScore()\");}\n",
        "output": "public virtual Explanation Explain(int docId, string field, int numPayloadsSeen, float payloadScore){Explanation result = new Explanation();result.Description = this.GetType().Name + \".docScore()\";result.Value = DocScore(docId, field, numPayloadsSeen, payloadScore);return result;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public int serialize(int offset, byte[] data) {int result = 0;for (org.apache.poi.hssf.record.Record rec : _list) {result += rec.serialize(offset + result, data);}return result;}\n",
        "output": "public int Serialize(int offset, byte[] data){int result = 0;int nRecs = _list.Count;for (int i = 0; i < nRecs; i++){Record rec = (Record)_list[i];result += rec.Serialize(offset + result, data);}return result;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String toString() {return _string.toString();}\n",
        "output": "public override String ToString(){return _string.ToString();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public static long[] copyOfRange(long[] original, int start, int end) {if (start > end) {throw new IllegalArgumentException();}int originalLength = original.length;if (start < 0 || start > originalLength) {throw new ArrayIndexOutOfBoundsException();}int resultLength = end - start;int copyLength = Math.min(resultLength, originalLength - start);long[] result = new long[resultLength];System.arraycopy(original, start, result, 0, copyLength);return result;}\n",
        "output": "public static long[] copyOfRange(long[] original, int start, int end){if (start > end){throw new System.ArgumentException();}int originalLength = original.Length;if (start < 0 || start > originalLength){throw new System.IndexOutOfRangeException();}int resultLength = end - start;int copyLength = System.Math.Min(resultLength, originalLength - start);long[] result = new long[resultLength];System.Array.Copy(original, start, result, 0, copyLength);return result;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public static byte[] toByteArray(ByteBuffer buffer, int length) {if(buffer.hasArray() && buffer.arrayOffset() == 0) {return buffer.array();}checkByteSizeLimit(length);byte[] data = new byte[length];buffer.get(data);return data;}\n",
        "output": "public static byte[] ToByteArray(ByteBuffer buffer, int length){if (buffer.HasBuffer && buffer.Offset == 0){return buffer.Buffer;}byte[] data = new byte[length];buffer.Read(data);return data;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public synchronized void setProgress(int progress) {setProgress(progress, false);}\n",
        "output": "public virtual void setProgress(int progress){lock (this){setProgress(progress, false);}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void removeCell(CellValueRecordInterface cell) {if (cell == null) {throw new IllegalArgumentException(\"cell must not be null\");}int row = cell.getRow();if (row >= records.length) {throw new RuntimeException(\"cell row is out of range\");}CellValueRecordInterface[] rowCells = records[row];if (rowCells == null) {throw new RuntimeException(\"cell row is already empty\");}short column = cell.getColumn();if (column >= rowCells.length) {throw new RuntimeException(\"cell column is out of range\");}rowCells[column] = null;}\n",
        "output": "public void RemoveCell(CellValueRecordInterface cell){if (cell == null){throw new ArgumentException(\"cell must not be null\");}int row = cell.Row;if (row >= records.Length){throw new Exception(\"cell row is out of range\");}CellValueRecordInterface[] rowCells = records[row];if (rowCells == null){throw new Exception(\"cell row is already empty\");}int column = cell.Column;if (column >= rowCells.Length){throw new Exception(\"cell column is out of range\");}rowCells[column] = null;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public static String canonicalizePath(String path, boolean discardRelativePrefix) {int segmentStart = 0;int deletableSegments = 0;for (int i = 0; i <= path.length(); ) {int nextSegmentStart;if (i == path.length()) {nextSegmentStart = i;} else if (path.charAt(i) == '/') {nextSegmentStart = i + 1;} else {i++;continue;}if (i == segmentStart + 1 && path.regionMatches(segmentStart, \".\", 0, 1)) {path = path.substring(0, segmentStart) + path.substring(nextSegmentStart);i = segmentStart;} else if (i == segmentStart + 2 && path.regionMatches(segmentStart, \"..\", 0, 2)) {if (deletableSegments > 0 || discardRelativePrefix) {deletableSegments--;int prevSegmentStart = path.lastIndexOf('/', segmentStart - 2) + 1;path = path.substring(0, prevSegmentStart) + path.substring(nextSegmentStart);i = segmentStart = prevSegmentStart;} else {i++;segmentStart = i;}} else {if (i > 0) {deletableSegments++;}i++;segmentStart = i;}}return path;}\n",
        "output": "public static string canonicalizePath(string path, bool discardRelativePrefix){int segmentStart = 0;int deletableSegments = 0;{for (int i = 0; i <= path.Length; ){int nextSegmentStart;if (i == path.Length){nextSegmentStart = i;}else{if (path[i] == '/'){nextSegmentStart = i + 1;}else{i++;continue;}}if (i == segmentStart + 1 && Sharpen.StringHelper.RegionMatches(path, segmentStart, \".\", 0, 1)){path = Sharpen.StringHelper.Substring(path, 0, segmentStart) + Sharpen.StringHelper.Substring(path, nextSegmentStart);i = segmentStart;}else{if (i == segmentStart + 2 && Sharpen.StringHelper.RegionMatches(path, segmentStart, \"..\", 0, 2)){if (deletableSegments > 0 || discardRelativePrefix){deletableSegments--;int prevSegmentStart = path.LastIndexOf('/', segmentStart - 2) + 1;path = Sharpen.StringHelper.Substring(path, 0, prevSegmentStart) + Sharpen.StringHelper.Substring(path, nextSegmentStart);i = segmentStart = prevSegmentStart;}else{i++;segmentStart = i;}}else{if (i > 0){deletableSegments++;}i++;segmentStart = i;}}}}return path;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ApostropheFilterFactory(Map<String, String> args) {super(args);if (!args.isEmpty()) {throw new IllegalArgumentException(\"Unknown parameter(s): \" + args);}}\n",
        "output": "public ApostropheFilterFactory(IDictionary<string, string> args): base(args){if (args.Count > 0){throw new System.ArgumentException(\"Unknown parameter(s): \" + args);}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public Entry<String, Ref> peek() {if (packedIdx < packed.size() && looseIdx < loose.size()) {Ref p = packed.get(packedIdx);Ref l = loose.get(looseIdx);int cmp = RefComparator.compareTo(p, l);if (cmp < 0) {packedIdx++;return toEntry(p);}if (cmp == 0)packedIdx++;looseIdx++;return toEntry(resolveLoose(l));}if (looseIdx < loose.size())return toEntry(resolveLoose(loose.get(looseIdx++)));if (packedIdx < packed.size())return toEntry(packed.get(packedIdx++));return null;}\n",
        "output": "public virtual Ent Peek(){if (this.packedIdx < this._enclosing.packed.Size() && this.looseIdx < this._enclosing.loose.Size()){Ref p = this._enclosing.packed.Get(this.packedIdx);Ref l = this._enclosing.loose.Get(this.looseIdx);int cmp = RefComparator.CompareTo(p, l);if (cmp < 0){this.packedIdx++;return this.ToEntry(p);}if (cmp == 0){this.packedIdx++;}this.looseIdx++;return this.ToEntry(this.ResolveLoose(l));}if (this.looseIdx < this._enclosing.loose.Size()){return this.ToEntry(this.ResolveLoose(this._enclosing.loose.Get(this.looseIdx++)));}if (this.packedIdx < this._enclosing.packed.Size()){return this.ToEntry(this._enclosing.packed.Get(this.packedIdx++));}return null;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DeleteEnvironmentResult deleteEnvironment(DeleteEnvironmentRequest request) {request = beforeClientExecution(request);return executeDeleteEnvironment(request);}\n",
        "output": "public virtual DeleteEnvironmentResponse DeleteEnvironment(DeleteEnvironmentRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteEnvironmentRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteEnvironmentResponseUnmarshaller.Instance;return Invoke<DeleteEnvironmentResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public int stem(char s[], int len) {for (int i = 0; i < len; i++)switch(s[i]) {case '\u00e1': s[i] = 'a'; break;case '\u00eb':case '\u00e9': s[i] = 'e'; break;case '\u00ed': s[i] = 'i'; break;case '\u00f3':case '\u0151':case '\u00f5':case '\u00f6': s[i] = 'o'; break;case '\u00fa':case '\u0171':case '\u0169':case '\u00fb':case '\u00fc': s[i] = 'u'; break;}len = removeCase(s, len);len = removePossessive(s, len);len = removePlural(s, len);return normalize(s, len);}\n",
        "output": "public virtual int Stem(char[] s, int len){for (int i = 0; i < len; i++){switch (s[i]){case '\u00e1':s[i] = 'a';break;case '\u00eb':case '\u00e9':s[i] = 'e';break;case '\u00ed':s[i] = 'i';break;case '\u00f3':case '\u0151':case '\u00f5':case '\u00f6':s[i] = 'o';break;case '\u00fa':case '\u0171':case '\u0169':case '\u00fb':case '\u00fc':s[i] = 'u';break;}}len = RemoveCase(s, len);len = RemovePossessive(s, len);len = RemovePlural(s, len);return Normalize(s, len);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void addChildBefore(EscherRecord record, int insertBeforeRecordId) {int idx = 0;for (EscherRecord rec : this) {if(rec.getRecordId() == (short)insertBeforeRecordId) {break;}idx++;}_childRecords.add(idx, record);}\n",
        "output": "public void AddChildBefore(EscherRecord record, int insertBeforeRecordId){for (int i = 0; i < _childRecords.Count; i++){EscherRecord rec = _childRecords[(i)];if (rec.RecordId == insertBeforeRecordId){_childRecords.Insert(i++, record);}}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ListAlbumsRequest() {super(\"CloudPhoto\", \"2017-07-11\", \"ListAlbums\", \"cloudphoto\");setProtocol(ProtocolType.HTTPS);}\n",
        "output": "public ListAlbumsRequest(): base(\"CloudPhoto\", \"2017-07-11\", \"ListAlbums\", \"cloudphoto\", \"openAPI\"){Protocol = ProtocolType.HTTPS;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public SaveTaskForUpdatingRegistrantInfoByIdentityCredentialRequest() {super(\"Domain-intl\", \"2017-12-18\", \"SaveTaskForUpdatingRegistrantInfoByIdentityCredential\", \"domain\");setMethod(MethodType.POST);}\n",
        "output": "public SaveTaskForUpdatingRegistrantInfoByIdentityCredentialRequest(): base(\"Domain-intl\", \"2017-12-18\", \"SaveTaskForUpdatingRegistrantInfoByIdentityCredential\", \"domain\", \"openAPI\"){Method = MethodType.POST;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0) {int result;if (arg0 instanceof TwoDEval) {result = ((TwoDEval) arg0).getHeight();} else if (arg0 instanceof RefEval) {result = 1;} else { return ErrorEval.VALUE_INVALID;}return new NumberEval(result);}\n",
        "output": "public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0){int result;if (arg0 is TwoDEval){result = ((TwoDEval)arg0).Height;}else if (arg0 is RefEval){result = 1;}else{ return ErrorEval.VALUE_INVALID;}return new NumberEval(result);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeReservedInstancesResult describeReservedInstances() {return describeReservedInstances(new DescribeReservedInstancesRequest());}\n",
        "output": "public virtual DescribeReservedInstancesResponse DescribeReservedInstances(){return DescribeReservedInstances(new DescribeReservedInstancesRequest());}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void setPackedGitMMAP(boolean usemmap) {packedGitMMAP = usemmap;}\n",
        "output": "public virtual void SetPackedGitMMAP(bool usemmap){packedGitMMAP = usemmap;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public POIFSDocumentPath(){this.components = new String[ 0 ];}\n",
        "output": "public POIFSDocumentPath(){this.components = new string[0];}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String toString() {return key + \"/\" + value;}\n",
        "output": "public override string ToString(){return Key + \"/\" + Value;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "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;final int byte2 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = (byte0 << 12) | (byte1 << 4) | (byte2 >>> 4);final int byte3 = blocks[blocksOffset++] & 0xFF;final int byte4 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte2 & 15) << 16) | (byte3 << 8) | byte4;}}\n",
        "output": "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;int byte2 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = (byte0 << 12) | (byte1 << 4) | ((int)((uint)byte2 >> 4));int byte3 = blocks[blocksOffset++] & 0xFF;int byte4 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte2 & 15) << 16) | (byte3 << 8) | byte4;}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void serialize(LittleEndianOutput out) {out.writeShort(_extBookIndex);out.writeShort(_firstSheetIndex);out.writeShort(_lastSheetIndex);}\n",
        "output": "public void Serialize(ILittleEndianOutput out1){out1.WriteShort(_extBookIndex);out1.WriteShort(_firstSheetIndex);out1.WriteShort(_lastSheetIndex);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public PatternParser(PatternConsumer consumer) {this();this.consumer = consumer;}\n",
        "output": "public PatternParser(IPatternConsumer consumer): this(){this.consumer = consumer;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public final String[] getValues(String name) {List<String> result = new ArrayList<>();for (IndexableField field : fields) {if (field.name().equals(name) && field.stringValue() != null) {result.add(field.stringValue());}}if (result.size() == 0) {return NO_STRINGS;}return result.toArray(new String[result.size()]);}\n",
        "output": "public string[] GetValues(string name){var result = new List<string>();foreach (IIndexableField field in fields){if (field.Name.Equals(name, StringComparison.Ordinal) && field.GetStringValue() != null){result.Add(field.GetStringValue());}}if (result.Count == 0){return NO_STRINGS;}return result.ToArray();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ListIdentityPoolUsageResult listIdentityPoolUsage(ListIdentityPoolUsageRequest request) {request = beforeClientExecution(request);return executeListIdentityPoolUsage(request);}\n",
        "output": "public virtual ListIdentityPoolUsageResponse ListIdentityPoolUsage(ListIdentityPoolUsageRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListIdentityPoolUsageRequestMarshaller.Instance;options.ResponseUnmarshaller = ListIdentityPoolUsageResponseUnmarshaller.Instance;return Invoke<ListIdentityPoolUsageResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ValueEval evaluate(ValueEval[] args, int srcCellRow, int srcCellCol) {if(args.length < 1 || args.length > 5) {return ErrorEval.VALUE_INVALID;}try {BaseRef baseRef = evaluateBaseRef(args[0]);int rowOffset = (args[1] instanceof MissingArgEval) ? 0 : evaluateIntArg(args[1], srcCellRow, srcCellCol);int columnOffset = (args[2] instanceof MissingArgEval) ? 0 : evaluateIntArg(args[2], srcCellRow, srcCellCol);int height = baseRef.getHeight();int width = baseRef.getWidth();switch(args.length) {case 5:if(!(args[4] instanceof MissingArgEval)) {width = evaluateIntArg(args[4], srcCellRow, srcCellCol);}case 4:if(!(args[3] instanceof MissingArgEval)) {height = evaluateIntArg(args[3], srcCellRow, srcCellCol);}break;default:break;}if(height == 0 || width == 0) {return ErrorEval.REF_INVALID;}LinearOffsetRange rowOffsetRange = new LinearOffsetRange(rowOffset, height);LinearOffsetRange colOffsetRange = new LinearOffsetRange(columnOffset, width);return createOffset(baseRef, rowOffsetRange, colOffsetRange);} catch (EvaluationException e) {return e.getErrorEval();}}\n",
        "output": "public ValueEval Evaluate(ValueEval[] args, int srcCellRow, int srcCellCol){if (args.Length < 3 || args.Length > 5){return ErrorEval.VALUE_INVALID;}try{BaseRef baseRef = EvaluateBaseRef(args[0]);int rowOffset = EvaluateIntArg(args[1], srcCellRow, srcCellCol);int columnOffset = EvaluateIntArg(args[2], srcCellRow, srcCellCol);int height = baseRef.Height;int width = baseRef.Width;switch (args.Length){case 5:width = EvaluateIntArg(args[4], srcCellRow, srcCellCol);break;case 4:height = EvaluateIntArg(args[3], srcCellRow, srcCellCol);break;}if (height == 0 || width == 0){return ErrorEval.REF_INVALID;}LinearOffsetRange rowOffsetRange = new LinearOffsetRange(rowOffset, height);LinearOffsetRange colOffsetRange = new LinearOffsetRange(columnOffset, width);return CreateOffset(baseRef, rowOffsetRange, colOffsetRange);}catch (EvaluationException e){return e.GetErrorEval();}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public int[] getCountsByTime() {return countsByTime;}\n",
        "output": "public virtual int[] GetCountsByTime(){return countsByTime;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public UpdateAccountResult updateAccount(UpdateAccountRequest request) {request = beforeClientExecution(request);return executeUpdateAccount(request);}\n",
        "output": "public virtual UpdateAccountResponse UpdateAccount(UpdateAccountRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateAccountRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateAccountResponseUnmarshaller.Instance;return Invoke<UpdateAccountResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeTrainingJobResult describeTrainingJob(DescribeTrainingJobRequest request) {request = beforeClientExecution(request);return executeDescribeTrainingJob(request);}\n",
        "output": "public virtual DescribeTrainingJobResponse DescribeTrainingJob(DescribeTrainingJobRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeTrainingJobRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeTrainingJobResponseUnmarshaller.Instance;return Invoke<DescribeTrainingJobResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DeleteGroupResult deleteGroup(DeleteGroupRequest request) {request = beforeClientExecution(request);return executeDeleteGroup(request);}\n",
        "output": "public virtual DeleteGroupResponse DeleteGroup(DeleteGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteGroupResponseUnmarshaller.Instance;return Invoke<DeleteGroupResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public int advance(int target) {upto++;if (upto == docIDs.length) {return docID = NO_MORE_DOCS;}int inc = 10;int nextUpto = upto+10;int low;int high;while (true) {if (nextUpto >= docIDs.length) {low = nextUpto-inc;high = docIDs.length-1;break;}if (target <= docIDs[nextUpto]) {low = nextUpto-inc;high = nextUpto;break;}inc *= 2;nextUpto += inc;}while (true) {if (low > high) {upto = low;break;}int mid = (low + high) >>> 1;int cmp = docIDs[mid] - target;if (cmp < 0) {low = mid + 1;} else if (cmp > 0) {high = mid - 1;} else {upto = mid;break;}}if (upto == docIDs.length) {return docID = NO_MORE_DOCS;} else {return docID = docIDs[upto];}}\n",
        "output": "public override int Advance(int target){upto++;if (upto == docIDs.Length){return docID_Renamed = NO_MORE_DOCS;}int inc = 10;int nextUpto = upto + 10;int low;int high;while (true){if (nextUpto >= docIDs.Length){low = nextUpto - inc;high = docIDs.Length - 1;break;}if (target <= docIDs[nextUpto]){low = nextUpto - inc;high = nextUpto;break;}inc *= 2;nextUpto += inc;}while (true){if (low > high){upto = low;break;}int mid = (int) ((uint) (low + high) >> 1);int cmp = docIDs[mid] - target;if (cmp < 0){low = mid + 1;}else if (cmp > 0){high = mid - 1;}else{upto = mid;break;}}if (liveDocs != null){while (upto < docIDs.Length){if (liveDocs.Get(docIDs[upto])){break;}upto++;}}if (upto == docIDs.Length){return docID_Renamed = NO_MORE_DOCS;}else{return docID_Renamed = docIDs[upto];}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void registerListener(final POIFSReaderListener listener) {if (listener == null) {throw new NullPointerException();}if (registryClosed) {throw new IllegalStateException();}registry.registerListener(listener);}\n",
        "output": "public void RegisterListener(POIFSReaderListener listener){if (listener == null){throw new NullReferenceException();}if (registryClosed){throw new InvalidOperationException();}registry.RegisterListener(listener);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public static int[] grow(int[] array, int minSize) {assert minSize >= 0: \"size must be positive (got \" + minSize + \"): likely integer overflow?\";if (array.length < minSize) {return growExact(array, oversize(minSize, Integer.BYTES));} elsereturn array;}\n",
        "output": "public static int[] Grow(int[] array, int minSize){Debug.Assert(minSize >= 0, \"size must be positive (got \" + minSize + \"): likely integer overflow?\");if (array.Length < minSize){int[] newArray = new int[Oversize(minSize, RamUsageEstimator.NUM_BYTES_INT32)];Array.Copy(array, 0, newArray, 0, array.Length);return newArray;}else{return array;}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void visitTerminal(TerminalNode node) {System.out.println(\"consume \"+node.getSymbol()+\" rule \"+getRuleNames()[_ctx.getRuleIndex()]);}\n",
        "output": "public virtual void VisitTerminal(ITerminalNode node){ParserRuleContext parent = (ParserRuleContext)((IRuleNode)node.Parent).RuleContext;IToken token = node.Symbol;Output.WriteLine(\"consume \" + token + \" rule \" + this._enclosing.RuleNames[parent.RuleIndex]);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public TokenStream create(TokenStream input) {return new LatvianStemFilter(input);}\n",
        "output": "public override TokenStream Create(TokenStream input){return new LatvianStemFilter(input);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ReplicationGroup increaseReplicaCount(IncreaseReplicaCountRequest request) {request = beforeClientExecution(request);return executeIncreaseReplicaCount(request);}\n",
        "output": "public virtual IncreaseReplicaCountResponse IncreaseReplicaCount(IncreaseReplicaCountRequest request){var options = new InvokeOptions();options.RequestMarshaller = IncreaseReplicaCountRequestMarshaller.Instance;options.ResponseUnmarshaller = IncreaseReplicaCountResponseUnmarshaller.Instance;return Invoke<IncreaseReplicaCountResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {for (int i = 0; i < iterations; ++i) {final long byte0 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = byte0 >>> 5;values[valuesOffset++] = (byte0 >>> 2) & 7;final long byte1 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte0 & 3) << 1) | (byte1 >>> 7);values[valuesOffset++] = (byte1 >>> 4) & 7;values[valuesOffset++] = (byte1 >>> 1) & 7;final long byte2 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte1 & 1) << 2) | (byte2 >>> 6);values[valuesOffset++] = (byte2 >>> 3) & 7;values[valuesOffset++] = byte2 & 7;}}\n",
        "output": "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;values[valuesOffset++] = (int)((uint)byte0 >> 5);values[valuesOffset++] = ((int)((uint)byte0 >> 2)) & 7;int byte1 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte0 & 3) << 1) | ((int)((uint)byte1 >> 7));values[valuesOffset++] = ((int)((uint)byte1 >> 4)) & 7;values[valuesOffset++] = ((int)((uint)byte1 >> 1)) & 7;int byte2 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte1 & 1) << 2) | ((int)((uint)byte2 >> 6));values[valuesOffset++] = ((int)((uint)byte2 >> 3)) & 7;values[valuesOffset++] = byte2 & 7;}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public StopHyperParameterTuningJobResult stopHyperParameterTuningJob(StopHyperParameterTuningJobRequest request) {request = beforeClientExecution(request);return executeStopHyperParameterTuningJob(request);}\n",
        "output": "public virtual StopHyperParameterTuningJobResponse StopHyperParameterTuningJob(StopHyperParameterTuningJobRequest request){var options = new InvokeOptions();options.RequestMarshaller = StopHyperParameterTuningJobRequestMarshaller.Instance;options.ResponseUnmarshaller = StopHyperParameterTuningJobResponseUnmarshaller.Instance;return Invoke<StopHyperParameterTuningJobResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ResetNetworkInterfaceAttributeResult resetNetworkInterfaceAttribute(ResetNetworkInterfaceAttributeRequest request) {request = beforeClientExecution(request);return executeResetNetworkInterfaceAttribute(request);}\n",
        "output": "public virtual ResetNetworkInterfaceAttributeResponse ResetNetworkInterfaceAttribute(ResetNetworkInterfaceAttributeRequest request){var options = new InvokeOptions();options.RequestMarshaller = ResetNetworkInterfaceAttributeRequestMarshaller.Instance;options.ResponseUnmarshaller = ResetNetworkInterfaceAttributeResponseUnmarshaller.Instance;return Invoke<ResetNetworkInterfaceAttributeResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public RevBlob lookupBlob(AnyObjectId id) {RevBlob c = (RevBlob) objects.get(id);if (c == null) {c = new RevBlob(id);objects.add(c);}return c;}\n",
        "output": "public virtual RevBlob LookupBlob(AnyObjectId id){RevBlob c = (RevBlob)objects.Get(id);if (c == null){c = new RevBlob(id);objects.Add(c);}return c;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ListGroupMembershipsResult listGroupMemberships(ListGroupMembershipsRequest request) {request = beforeClientExecution(request);return executeListGroupMemberships(request);}\n",
        "output": "public virtual ListGroupMembershipsResponse ListGroupMemberships(ListGroupMembershipsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListGroupMembershipsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListGroupMembershipsResponseUnmarshaller.Instance;return Invoke<ListGroupMembershipsResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public static void mkdir(File d, boolean skipExisting)throws IOException {if (!d.mkdir()) {if (skipExisting && d.isDirectory())return;throw new IOException(MessageFormat.format(JGitText.get().mkDirFailed, d.getAbsolutePath()));}}\n",
        "output": "public static void Mkdir(FilePath d, bool skipExisting){if (!d.Mkdir()){if (skipExisting && d.IsDirectory()){return;}throw new IOException(MessageFormat.Format(JGitText.Get().mkDirFailed, d.GetAbsolutePath()));}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public UpdateDetectorVersionMetadataResult updateDetectorVersionMetadata(UpdateDetectorVersionMetadataRequest request) {request = beforeClientExecution(request);return executeUpdateDetectorVersionMetadata(request);}\n",
        "output": "public virtual UpdateDetectorVersionMetadataResponse UpdateDetectorVersionMetadata(UpdateDetectorVersionMetadataRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateDetectorVersionMetadataRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateDetectorVersionMetadataResponseUnmarshaller.Instance;return Invoke<UpdateDetectorVersionMetadataResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void write(String str, int offset, int count) throws IOException {if ((offset | count) < 0 || offset > str.length() - count) {throw new StringIndexOutOfBoundsException(str, offset, count);}char[] buf = new char[count];str.getChars(offset, offset + count, buf, 0);synchronized (lock) {write(buf, 0, buf.length);}}\n",
        "output": "public virtual void write(string str, int offset, int count){if ((offset | count) < 0 || offset > str.Length - count){throw new java.lang.StringIndexOutOfBoundsException(str, offset, count);}char[] buf = new char[count];Sharpen.StringHelper.GetCharsForString(str, offset, offset + count, buf, 0);lock (@lock){write(buf, 0, buf.Length);}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public synchronized void ensureCapacity(int min) {super.ensureCapacity(min);}\n",
        "output": "public override void ensureCapacity(int min){lock (this){base.ensureCapacity(min);}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeRecipeResult describeRecipe(DescribeRecipeRequest request) {request = beforeClientExecution(request);return executeDescribeRecipe(request);}\n",
        "output": "public virtual DescribeRecipeResponse DescribeRecipe(DescribeRecipeRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeRecipeRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeRecipeResponseUnmarshaller.Instance;return Invoke<DescribeRecipeResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DisassociateRouteTableResult disassociateRouteTable(DisassociateRouteTableRequest request) {request = beforeClientExecution(request);return executeDisassociateRouteTable(request);}\n",
        "output": "public virtual DisassociateRouteTableResponse DisassociateRouteTable(DisassociateRouteTableRequest request){var options = new InvokeOptions();options.RequestMarshaller = DisassociateRouteTableRequestMarshaller.Instance;options.ResponseUnmarshaller = DisassociateRouteTableResponseUnmarshaller.Instance;return Invoke<DisassociateRouteTableResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public SetTopicAttributesRequest(String topicArn, String attributeName, String attributeValue) {setTopicArn(topicArn);setAttributeName(attributeName);setAttributeValue(attributeValue);}\n",
        "output": "public SetTopicAttributesRequest(string topicArn, string attributeName, string attributeValue){_topicArn = topicArn;_attributeName = attributeName;_attributeValue = attributeValue;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public static char[] grow(char[] array, int minSize) {assert minSize >= 0: \"size must be positive (got \" + minSize + \"): likely integer overflow?\";if (array.length < minSize) {return growExact(array, oversize(minSize, Character.BYTES));} elsereturn array;}\n",
        "output": "public static float[] Grow(float[] array, int minSize){Debug.Assert(minSize >= 0, \"size must be positive (got \" + minSize + \"): likely integer overflow?\");if (array.Length < minSize){float[] newArray = new float[Oversize(minSize, RamUsageEstimator.NUM_BYTES_SINGLE)];Array.Copy(array, 0, newArray, 0, array.Length);return newArray;}else{return array;}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public StashCreateCommand setRef(String ref) {this.ref = ref;return this;}\n",
        "output": "public virtual NGit.Api.StashCreateCommand SetRef(string @ref){this.@ref = @ref;return this;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public FormulaRecord(RecordInputStream ris) {super(ris);long valueLongBits  = ris.readLong();field_5_options = ris.readShort();specialCachedValue = FormulaSpecialCachedValue.create(valueLongBits);if (specialCachedValue == null) {field_4_value = Double.longBitsToDouble(valueLongBits);}field_6_zero = ris.readInt();int field_7_expression_len = ris.readShort(); int nBytesAvailable = ris.available();field_8_parsed_expr = Formula.read(field_7_expression_len, ris, nBytesAvailable);}\n",
        "output": "public FormulaRecord(RecordInputStream in1):base(in1){long valueLongBits  = in1.ReadLong();field_5_options = in1.ReadShort();specialCachedValue = SpecialCachedValue.Create(valueLongBits);if (specialCachedValue == null) {field_4_value = BitConverter.Int64BitsToDouble(valueLongBits);}field_6_zero = in1.ReadInt();int field_7_expression_len = in1.ReadShort();field_8_parsed_expr = NPOI.SS.Formula.Formula.Read(field_7_expression_len, in1,in1.Available());}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public SynonymQuery build() {Collections.sort(terms, Comparator.comparing(a -> a.term));return new SynonymQuery(terms.toArray(new TermAndBoost[0]), field);}\n",
        "output": "public override WAH8DocIdSet Build(){if (this.wordNum != -1){AddWord(wordNum, (byte)word);}return base.Build();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public PasswordRev4Record(RecordInputStream in) {field_1_password = in.readShort();}\n",
        "output": "public PasswordRev4Record(RecordInputStream in1){field_1_password = in1.ReadShort();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public boolean isReadOnly() {return false;}\n",
        "output": "public override bool isReadOnly(){return false;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public int preceding(int pos) {if (pos < start || pos > end) {throw new IllegalArgumentException(\"offset out of bounds\");} else if (pos == start) {current = start;return DONE;} else {return first();}}\n",
        "output": "public override int Preceding(int pos){if (pos < start || pos > end){throw new ArgumentException(\"offset out of bounds\");}else if (pos == start){current = start;return Done;}else{return First();}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CodepageRecord(RecordInputStream in) {field_1_codepage = in.readShort();}\n",
        "output": "public CodepageRecord(RecordInputStream in1){field_1_codepage = in1.ReadShort();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ApproveAssignmentResult approveAssignment(ApproveAssignmentRequest request) {request = beforeClientExecution(request);return executeApproveAssignment(request);}\n",
        "output": "public virtual ApproveAssignmentResponse ApproveAssignment(ApproveAssignmentRequest request){var options = new InvokeOptions();options.RequestMarshaller = ApproveAssignmentRequestMarshaller.Instance;options.ResponseUnmarshaller = ApproveAssignmentResponseUnmarshaller.Instance;return Invoke<ApproveAssignmentResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeVpnConnectionsResult describeVpnConnections() {return describeVpnConnections(new DescribeVpnConnectionsRequest());}\n",
        "output": "public virtual DescribeVpnConnectionsResponse DescribeVpnConnections(){return DescribeVpnConnections(new DescribeVpnConnectionsRequest());}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public final V next() { return nextEntry().value; }\n",
        "output": "public override V next(){return this.nextEntry().value;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeInstanceHealthResult describeInstanceHealth(DescribeInstanceHealthRequest request) {request = beforeClientExecution(request);return executeDescribeInstanceHealth(request);}\n",
        "output": "public virtual DescribeInstanceHealthResponse DescribeInstanceHealth(DescribeInstanceHealthRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeInstanceHealthRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeInstanceHealthResponseUnmarshaller.Instance;return Invoke<DescribeInstanceHealthResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public static void register(TransportProtocol proto) {protocols.add(0, new WeakReference<>(proto));}\n",
        "output": "public static void Register(TransportProtocol proto){protocols.Add(0, new JavaWeakReference<TransportProtocol>(proto));}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public static char[] copyOfRange(char[] original, int start, int end) {if (start > end) {throw new IllegalArgumentException();}int originalLength = original.length;if (start < 0 || start > originalLength) {throw new ArrayIndexOutOfBoundsException();}int resultLength = end - start;int copyLength = Math.min(resultLength, originalLength - start);char[] result = new char[resultLength];System.arraycopy(original, start, result, 0, copyLength);return result;}\n",
        "output": "public static char[] copyOfRange(char[] original, int start, int end){if (start > end){throw new System.ArgumentException();}int originalLength = original.Length;if (start < 0 || start > originalLength){throw new System.IndexOutOfRangeException();}int resultLength = end - start;int copyLength = System.Math.Min(resultLength, originalLength - start);char[] result = new char[resultLength];System.Array.Copy(original, start, result, 0, copyLength);return result;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public static void fill(int[] array, int value) {for (int i = 0; i < array.length; i++) {array[i] = value;}}\n",
        "output": "public static void fill(int[] array, int value){{for (int i = 0; i < array.Length; i++){array[i] = value;}}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public Class<? extends Record> peekNextClass() {if(!hasNext()) {return null;}return _list.get(_nextIndex).getClass();}\n",
        "output": "public Type PeekNextClass(){if (_nextIndex >= _list.Count){return null;}return _list[_nextIndex].GetType();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public static char[] copyOf(char[] original, int newLength) {if (newLength < 0) {throw new NegativeArraySizeException();}return copyOfRange(original, 0, newLength);}\n",
        "output": "public static char[] copyOf(char[] original, int newLength){if (newLength < 0){throw new java.lang.NegativeArraySizeException();}return copyOfRange(original, 0, newLength);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DeleteRelationalDatabaseResult deleteRelationalDatabase(DeleteRelationalDatabaseRequest request) {request = beforeClientExecution(request);return executeDeleteRelationalDatabase(request);}\n",
        "output": "public virtual DeleteRelationalDatabaseResponse DeleteRelationalDatabase(DeleteRelationalDatabaseRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteRelationalDatabaseRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteRelationalDatabaseResponseUnmarshaller.Instance;return Invoke<DeleteRelationalDatabaseResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public boolean equals(Object obj) {if (this == obj) {return true;}if (obj == null) {return false;}if (getClass() != obj.getClass()) {return false;}WeightedPhraseInfo other = (WeightedPhraseInfo) obj;if (getStartOffset() != other.getStartOffset()) {return false;}if (getEndOffset() != other.getEndOffset()) {return false;}if (getBoost() != other.getBoost()) {return false;}return true;}\n",
        "output": "public override bool Equals(object obj){if (this == obj){return true;}if (obj == null){return false;}if (GetType() != obj.GetType()){return false;}WeightedPhraseInfo other = (WeightedPhraseInfo)obj;if (StartOffset != other.StartOffset){return false;}if (EndOffset != other.EndOffset){return false;}if (Boost != other.Boost){return false;}return true;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public boolean hasNext() {return nextBlock != POIFSConstants.END_OF_CHAIN;}\n",
        "output": "public bool HasNext(){if (nextBlock == POIFSConstants.END_OF_CHAIN){return false;}return true;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void write(char b) {if (len >= buf.length) {resize(len +1);}unsafeWrite(b);}\n",
        "output": "public virtual void Write(char b){if (m_len >= m_buf.Length){Resize(m_len + 1);}UnsafeWrite(b);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void serialize(LittleEndianOutput out) {futureHeader.serialize(out);out.writeShort(isf_sharedFeatureType);out.writeByte(reserved);out.writeInt((int)cbHdrData);out.write(rgbHdrData);}\n",
        "output": "public override void Serialize(ILittleEndianOutput out1){futureHeader.Serialize(out1);out1.WriteShort(isf_sharedFeatureType);out1.WriteByte(reserved);out1.WriteInt((int)cbHdrData);out1.Write(rgbHdrData);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ListUserHierarchyGroupsResult listUserHierarchyGroups(ListUserHierarchyGroupsRequest request) {request = beforeClientExecution(request);return executeListUserHierarchyGroups(request);}\n",
        "output": "public virtual ListUserHierarchyGroupsResponse ListUserHierarchyGroups(ListUserHierarchyGroupsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListUserHierarchyGroupsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListUserHierarchyGroupsResponseUnmarshaller.Instance;return Invoke<ListUserHierarchyGroupsResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public GetTopicAttributesRequest(String topicArn) {setTopicArn(topicArn);}\n",
        "output": "public GetTopicAttributesRequest(string topicArn){_topicArn = topicArn;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CreateTrafficPolicyVersionResult createTrafficPolicyVersion(CreateTrafficPolicyVersionRequest request) {request = beforeClientExecution(request);return executeCreateTrafficPolicyVersion(request);}\n",
        "output": "public virtual CreateTrafficPolicyVersionResponse CreateTrafficPolicyVersion(CreateTrafficPolicyVersionRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateTrafficPolicyVersionRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateTrafficPolicyVersionResponseUnmarshaller.Instance;return Invoke<CreateTrafficPolicyVersionResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "@Override public boolean equals(Object object) {if (this == object) {return true;}if (object instanceof Map.Entry) {Map.Entry<?, ?> entry = (Map.Entry<?, ?>) object;return (key == null ? entry.getKey() == null : key.equals(entry.getKey()))&& (value == null ? entry.getValue() == null : value.equals(entry.getValue()));}return false;}\n",
        "output": "public override bool Equals(object @object){if (this == @object){return true;}if (@object is java.util.MapClass.Entry<K, V>){java.util.MapClass.Entry<object, object> entry = (java.util.MapClass.Entry<object, object>)@object;return ((object)key == null ? entry.getKey() == null : key.Equals(entry.getKey())) && ((object)value == null ? entry.getValue() == null : value.Equals(entry.getValue()));}return false;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ListResourcesResult listResources(ListResourcesRequest request) {request = beforeClientExecution(request);return executeListResources(request);}\n",
        "output": "public virtual ListResourcesResponse ListResources(ListResourcesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListResourcesRequestMarshaller.Instance;options.ResponseUnmarshaller = ListResourcesResponseUnmarshaller.Instance;return Invoke<ListResourcesResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public final V getAndSet(V newValue) {while (true) {V x = get();if (compareAndSet(x, newValue))return x;}}\n",
        "output": "public V getAndSet(V newValue){while(true) {V x = get ();if (compareAndSet(x, newValue))return x;}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public FeatHdrRecord() {futureHeader = new FtrHeader();futureHeader.setRecordType(sid);}\n",
        "output": "public FeatHdrRecord(){futureHeader = new FtrHeader();futureHeader.RecordType = (sid);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DisassociatePhoneNumbersFromVoiceConnectorResult disassociatePhoneNumbersFromVoiceConnector(DisassociatePhoneNumbersFromVoiceConnectorRequest request) {request = beforeClientExecution(request);return executeDisassociatePhoneNumbersFromVoiceConnector(request);}\n",
        "output": "public virtual DisassociatePhoneNumbersFromVoiceConnectorResponse DisassociatePhoneNumbersFromVoiceConnector(DisassociatePhoneNumbersFromVoiceConnectorRequest request){var options = new InvokeOptions();options.RequestMarshaller = DisassociatePhoneNumbersFromVoiceConnectorRequestMarshaller.Instance;options.ResponseUnmarshaller = DisassociatePhoneNumbersFromVoiceConnectorResponseUnmarshaller.Instance;return Invoke<DisassociatePhoneNumbersFromVoiceConnectorResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ObjectId idFor(int type, byte[] data) {return idFor(type, data, 0, data.length);}\n",
        "output": "public virtual ObjectId IdFor(int type, byte[] data){return IdFor(type, data, 0, data.Length);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void removeParseListener(ParseTreeListener listener) {if (_parseListeners != null) {if (_parseListeners.remove(listener)) {if (_parseListeners.isEmpty()) {_parseListeners = null;}}}}\n",
        "output": "public virtual void RemoveParseListener(IParseTreeListener listener){if (_parseListeners != null){if (_parseListeners.Remove(listener)){if (_parseListeners.Count == 0){_parseListeners = null;}}}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public AxisRecord(RecordInputStream in) {field_1_axisType  = in.readShort();field_2_reserved1 = in.readInt();field_3_reserved2 = in.readInt();field_4_reserved3 = in.readInt();field_5_reserved4 = in.readInt();}\n",
        "output": "public AxisRecord(RecordInputStream in1){field_1_axisType = in1.ReadShort();field_2_reserved1 = in1.ReadInt();field_3_reserved2 = in1.ReadInt();field_4_reserved3 = in1.ReadInt();field_5_reserved4 = in1.ReadInt();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public static double evaluate(double[] v) throws EvaluationException {if (v.length < 2) {throw new EvaluationException(ErrorEval.NA);}int[] counts = new int[v.length];Arrays.fill(counts, 1);for (int i = 0, iSize = v.length; i < iSize; i++) {for (int j = i + 1, jSize = v.length; j < jSize; j++) {if (v[i] == v[j])counts[i]++;}}double maxv = 0;int maxc = 0;for (int i = 0, iSize = counts.length; i < iSize; i++) {if (counts[i] > maxc) {maxv = v[i];maxc = counts[i];}}if (maxc > 1) {return maxv;}throw new EvaluationException(ErrorEval.NA);}\n",
        "output": "public static double Evaluate(double[] v){if (v.Length < 2){throw new EvaluationException(ErrorEval.NA);}int[] counts = new int[v.Length];Arrays.Fill(counts, 1);for (int i = 0, iSize = v.Length; i < iSize; i++){for (int j = i + 1, jSize = v.Length; j < jSize; j++){if (v[i] == v[j])counts[i]++;}}double maxv = 0;int maxc = 0;for (int i = 0, iSize = counts.Length; i < iSize; i++){if (counts[i] > maxc){maxv = v[i];maxc = counts[i];}}if (maxc > 1){return maxv;}throw new EvaluationException(ErrorEval.NA);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void addFacetCount(BytesRef facetValue, int count) {if (count < currentMin) {return;}FacetEntry facetEntry = new FacetEntry(facetValue, count);if (facetEntries.size() == maxSize) {if (facetEntries.higher(facetEntry) == null) {return;}facetEntries.pollLast();}facetEntries.add(facetEntry);if (facetEntries.size() == maxSize) {currentMin = facetEntries.last().count;}}\n",
        "output": "public virtual void AddFacetCount(BytesRef facetValue, int count){if (count < currentMin){return;}FacetEntry facetEntry = new FacetEntry(facetValue, count);if (facetEntries.Count == maxSize){if (!facetEntries.TryGetSuccessor(facetEntry, out FacetEntry _)){return;}var max = facetEntries.Max;if (max != null)facetEntries.Remove(max);}facetEntries.Add(facetEntry);if (facetEntries.Count == maxSize){var max = facetEntries.Max;currentMin =  max != null ? max.Count : 0;}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String toString(){StringBuilder buffer = new StringBuilder();String nl = System.getProperty(\"line.separator\");buffer.append(\"[ftGmo]\" + nl);buffer.append(\"  reserved = \").append(HexDump.toHex(reserved)).append(nl);buffer.append(\"[/ftGmo]\" + nl);return buffer.toString();}\n",
        "output": "public override String ToString(){StringBuilder buffer = new StringBuilder();String nl = Environment.NewLine;buffer.Append(\"[ftGmo]\" + nl);buffer.Append(\"  reserved = \").Append(HexDump.ToHex(reserved)).Append(nl);buffer.Append(\"[/ftGmo]\" + nl);return buffer.ToString();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String toString() {return getMode().toString() + \" \" + getName(); }\n",
        "output": "public override string ToString(){return GetMode().ToString() + \" \" + GetName();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CharVector(int capacity) {if (capacity > 0) {blockSize = capacity;} else {blockSize = DEFAULT_BLOCK_SIZE;}array = new char[blockSize];n = 0;}\n",
        "output": "public CharVector(int capacity){if (capacity > 0){blockSize = capacity;}else{blockSize = DEFAULT_BLOCK_SIZE;}array = new char[blockSize];n = 0;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeAccountLimitsResult describeAccountLimits(DescribeAccountLimitsRequest request) {request = beforeClientExecution(request);return executeDescribeAccountLimits(request);}\n",
        "output": "public virtual DescribeAccountLimitsResponse DescribeAccountLimits(DescribeAccountLimitsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeAccountLimitsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeAccountLimitsResponseUnmarshaller.Instance;return Invoke<DescribeAccountLimitsResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void removeBuiltinRecord(byte name, int sheetIndex) {linkTable.removeBuiltinRecord(name, sheetIndex);}\n",
        "output": "public void RemoveBuiltinRecord(byte name, int sheetIndex){linkTable.RemoveBuiltinRecord(name, sheetIndex);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CreateSecurityGroupResult createSecurityGroup(CreateSecurityGroupRequest request) {request = beforeClientExecution(request);return executeCreateSecurityGroup(request);}\n",
        "output": "public virtual CreateSecurityGroupResponse CreateSecurityGroup(CreateSecurityGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateSecurityGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateSecurityGroupResponseUnmarshaller.Instance;return Invoke<CreateSecurityGroupResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public boolean equals(Object other) {return sameClassAs(other) &&equalsTo(getClass().cast(other));}\n",
        "output": "public override bool Equals(object o){if (!(o is DisjunctionMaxQuery)){return false;}DisjunctionMaxQuery other = (DisjunctionMaxQuery)o;return this.Boost == other.Boost&& this.tieBreakerMultiplier == other.tieBreakerMultiplier&& this.disjuncts.Equals(other.disjuncts);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public GetObjectInformationResult getObjectInformation(GetObjectInformationRequest request) {request = beforeClientExecution(request);return executeGetObjectInformation(request);}\n",
        "output": "public virtual GetObjectInformationResponse GetObjectInformation(GetObjectInformationRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetObjectInformationRequestMarshaller.Instance;options.ResponseUnmarshaller = GetObjectInformationResponseUnmarshaller.Instance;return Invoke<GetObjectInformationResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public StringBuffer append(long l) {IntegralToString.appendLong(this, l);return this;}\n",
        "output": "public java.lang.StringBuffer append(bool b){return append(b ? \"true\" : \"false\");}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public GetIntegrationResponsesResult getIntegrationResponses(GetIntegrationResponsesRequest request) {request = beforeClientExecution(request);return executeGetIntegrationResponses(request);}\n",
        "output": "public virtual GetIntegrationResponsesResponse GetIntegrationResponses(GetIntegrationResponsesRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetIntegrationResponsesRequestMarshaller.Instance;options.ResponseUnmarshaller = GetIntegrationResponsesResponseUnmarshaller.Instance;return Invoke<GetIntegrationResponsesResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ListDeploymentConfigsResult listDeploymentConfigs() {return listDeploymentConfigs(new ListDeploymentConfigsRequest());}\n",
        "output": "public virtual ListDeploymentConfigsResponse ListDeploymentConfigs(){return ListDeploymentConfigs(new ListDeploymentConfigsRequest());}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CellRangeAddress remove(int rangeIndex) {if (_list.isEmpty()) {throw new RuntimeException(\"List is empty\");}if (rangeIndex < 0 || rangeIndex >= _list.size()) {throw new RuntimeException(\"Range index (\" + rangeIndex+ \") is outside allowable range (0..\" + (_list.size()-1) + \")\");}return _list.remove(rangeIndex);}\n",
        "output": "public CellRangeAddress Remove(int rangeIndex){if (_list.Count == 0){throw new Exception(\"List is empty\");}if (rangeIndex < 0 || rangeIndex >= _list.Count){throw new Exception(\"Range index (\" + rangeIndex+ \") is outside allowable range (0..\" + (_list.Count - 1) + \")\");}CellRangeAddress cra = (CellRangeAddress)_list[rangeIndex];_list.Remove(rangeIndex);return cra;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DimConfig getDimConfig(String dimName) {DimConfig ft = fieldTypes.get(dimName);if (ft == null) {ft = getDefaultDimConfig();}return ft;}\n",
        "output": "public virtual DimConfig GetDimConfig(string dimName){lock (this){DimConfig ft;if (!fieldTypes.TryGetValue(dimName, out ft)){ft = DefaultDimConfig;}return ft;}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeStackResourceDriftsResult describeStackResourceDrifts(DescribeStackResourceDriftsRequest request) {request = beforeClientExecution(request);return executeDescribeStackResourceDrifts(request);}\n",
        "output": "public virtual DescribeStackResourceDriftsResponse DescribeStackResourceDrifts(DescribeStackResourceDriftsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeStackResourceDriftsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeStackResourceDriftsResponseUnmarshaller.Instance;return Invoke<DescribeStackResourceDriftsResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void setParams(String params) {if (!supportsParams()) {throw new UnsupportedOperationException(getName()+\" does not support command line parameters.\");}this.params = params;}\n",
        "output": "public virtual void SetParams(string @params){if (!SupportsParams){throw new NotSupportedException(GetName() + \" does not support command line parameters.\");}this.m_params = @params;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeRepositoryAssociationResult describeRepositoryAssociation(DescribeRepositoryAssociationRequest request) {request = beforeClientExecution(request);return executeDescribeRepositoryAssociation(request);}\n",
        "output": "public virtual DescribeRepositoryAssociationResponse DescribeRepositoryAssociation(DescribeRepositoryAssociationRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeRepositoryAssociationRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeRepositoryAssociationResponseUnmarshaller.Instance;return Invoke<DescribeRepositoryAssociationResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public synchronized Enumeration<V> elements() {return new ValueEnumeration();}\n",
        "output": "public override java.util.Enumeration<V> elements(){lock (this){return new java.util.Hashtable<K, V>.ValueEnumeration(this);}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void set(int index, long value) {final int o = index >>> 4;final int b = index & 15;final int shift = b << 2;blocks[o] = (blocks[o] & ~(15L << shift)) | (value << shift);}\n",
        "output": "public override void Set(int index, long value){int o = (int)((uint)index >> 4);int b = index & 15;int shift = b << 2;blocks[o] = (blocks[o] & ~(15L << shift)) | (value << shift);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public HTMLStripCharFilterFactory(Map<String,String> args) {super(args);escapedTags = getSet(args, \"escapedTags\");if (!args.isEmpty()) {throw new IllegalArgumentException(\"Unknown parameters: \" + args);}}\n",
        "output": "public HTMLStripCharFilterFactory(IDictionary<string, string> args) : base(args){escapedTags = GetSet(args, \"escapedTags\");if (args.Count > 0){throw new System.ArgumentException(\"Unknown parameters: \" + args);}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public int getEntryPathLength() {return pathLen;}\n",
        "output": "public virtual int GetEntryPathLength(){return pathLen;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void serialize(LittleEndianOutput out) {out.writeShort(field_1_option_flag);out.writeShort(field_2_ixals);out.writeShort(field_3_not_used);out.writeByte(field_4_name.length());StringUtil.writeUnicodeStringFlagAndData(out, field_4_name);if(!isOLELink() && !isStdDocumentNameIdentifier()){if(isAutomaticLink()){if(_ddeValues != null) {out.writeByte(_nColumns-1);out.writeShort(_nRows-1);ConstantValueParser.encode(out, _ddeValues);}} else {field_5_name_definition.serialize(out);}}}\n",
        "output": "public override void Serialize(ILittleEndianOutput out1){out1.WriteShort(field_1_option_flag);out1.WriteShort(field_2_ixals);out1.WriteShort(field_3_not_used);out1.WriteByte(field_4_name.Length);StringUtil.WriteUnicodeStringFlagAndData(out1, field_4_name);if (!IsOLELink && !IsStdDocumentNameIdentifier){if (IsAutomaticLink){if (_ddeValues != null){out1.WriteByte(_nColumns - 1);out1.WriteShort(_nRows - 1);ConstantValueParser.Encode(out1, _ddeValues);}}else{field_5_name_definition.Serialize(out1);}}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String toString() {StringBuilder buffer = new StringBuilder();buffer.append(\"[REFRESHALL]\\n\");buffer.append(\"    .options      = \").append(HexDump.shortToHex(_options)).append(\"\\n\");buffer.append(\"[/REFRESHALL]\\n\");return buffer.toString();}\n",
        "output": "public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append(\"[REFRESHALL]\\n\");buffer.Append(\"    .refreshall      = \").Append(RefreshAll).Append(\"\\n\");buffer.Append(\"[/REFRESHALL]\\n\");return buffer.ToString();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ContinueDeploymentResult continueDeployment(ContinueDeploymentRequest request) {request = beforeClientExecution(request);return executeContinueDeployment(request);}\n",
        "output": "public virtual ContinueDeploymentResponse ContinueDeployment(ContinueDeploymentRequest request){var options = new InvokeOptions();options.RequestMarshaller = ContinueDeploymentRequestMarshaller.Instance;options.ResponseUnmarshaller = ContinueDeploymentResponseUnmarshaller.Instance;return Invoke<ContinueDeploymentResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void set(int index, long value) {final int o = index / 3;final int b = index % 3;final int shift = b * 21;blocks[o] = (blocks[o] & ~(2097151L << shift)) | (value << shift);}\n",
        "output": "public override void Set(int index, long value){int o = index / 3;int b = index % 3;int shift = b * 21;blocks[o] = (blocks[o] & ~(2097151L << shift)) | (value << shift);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public long next() throws IOException {if (ord == valueCount) {throw new EOFException();}if (off == blockSize) {refill();}final long value = values[off++];++ord;return value;}\n",
        "output": "public long Next(){if (ord == valueCount){throw new System.IO.EndOfStreamException();}if (off == blockSize){Refill();}long value = values[off++];++ord;return value;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public static final RevFilter between(Date since, Date until) {return between(since.getTime(), until.getTime());}\n",
        "output": "public static RevFilter Between(DateTime since, DateTime until){return Between(since.GetTime(), until.GetTime());}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DeleteVaultResult deleteVault(DeleteVaultRequest request) {request = beforeClientExecution(request);return executeDeleteVault(request);}\n",
        "output": "public virtual DeleteVaultResponse DeleteVault(DeleteVaultRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteVaultRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteVaultResponseUnmarshaller.Instance;return Invoke<DeleteVaultResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public final void reset() {it = cachedStates.getStates();}\n",
        "output": "public override sealed void Reset(){it = cachedStates.GetEnumerator();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void setDetachingSymbolicRef() {detachingSymbolicRef = true;}\n",
        "output": "public virtual void SetDetachingSymbolicRef(){detachingSymbolicRef = true;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ModifyIdentityIdFormatResult modifyIdentityIdFormat(ModifyIdentityIdFormatRequest request) {request = beforeClientExecution(request);return executeModifyIdentityIdFormat(request);}\n",
        "output": "public virtual ModifyIdentityIdFormatResponse ModifyIdentityIdFormat(ModifyIdentityIdFormatRequest request){var options = new InvokeOptions();options.RequestMarshaller = ModifyIdentityIdFormatRequestMarshaller.Instance;options.ResponseUnmarshaller = ModifyIdentityIdFormatResponseUnmarshaller.Instance;return Invoke<ModifyIdentityIdFormatResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void addException(String word, ArrayList<Object> hyphenatedword) {stoplist.put(word, hyphenatedword);}\n",
        "output": "public virtual void AddException(string word, IList<object> hyphenatedword){m_stoplist[word] = hyphenatedword;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public GreekStemFilterFactory(Map<String,String> args) {super(args);if (!args.isEmpty()) {throw new IllegalArgumentException(\"Unknown parameters: \" + args);}}\n",
        "output": "public GreekStemFilterFactory(IDictionary<string, string> args): base(args){if (args.Count > 0){throw new System.ArgumentException(\"Unknown parameters: \" + args);}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public RegisterTypeResult registerType(RegisterTypeRequest request) {request = beforeClientExecution(request);return executeRegisterType(request);}\n",
        "output": "public virtual RegisterTypeResponse RegisterType(RegisterTypeRequest request){var options = new InvokeOptions();options.RequestMarshaller = RegisterTypeRequestMarshaller.Instance;options.ResponseUnmarshaller = RegisterTypeResponseUnmarshaller.Instance;return Invoke<RegisterTypeResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public GetAccessControlEffectResult getAccessControlEffect(GetAccessControlEffectRequest request) {request = beforeClientExecution(request);return executeGetAccessControlEffect(request);}\n",
        "output": "public virtual GetAccessControlEffectResponse GetAccessControlEffect(GetAccessControlEffectRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetAccessControlEffectRequestMarshaller.Instance;options.ResponseUnmarshaller = GetAccessControlEffectResponseUnmarshaller.Instance;return Invoke<GetAccessControlEffectResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public HSSFShapeGroup createGroup(HSSFChildAnchor anchor) {HSSFShapeGroup group = new HSSFShapeGroup(this, anchor);group.setParent(this);group.setAnchor(anchor);shapes.add(group);onCreate(group);return group;}\n",
        "output": "public HSSFShapeGroup CreateGroup(HSSFChildAnchor anchor){HSSFShapeGroup group = new HSSFShapeGroup(this, anchor);group.Parent = this;group.Anchor = anchor;shapes.Add(group);OnCreate(group);return group;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String toExternalString() {final StringBuilder r = new StringBuilder();appendSanitized(r, getName());r.append(\" <\"); appendSanitized(r, getEmailAddress());r.append(\"> \"); r.append(when / 1000);r.append(' ');appendTimezone(r, tzOffset);return r.toString();}\n",
        "output": "public virtual string ToExternalString(){StringBuilder r = new StringBuilder();r.Append(GetName());r.Append(\" <\");r.Append(GetEmailAddress());r.Append(\"> \");r.Append(when / 1000);r.Append(' ');AppendTimezone(r);return r.ToString();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public static FontCharset valueOf(int value){if(value >= _table.length)return null;return _table[value];}\n",
        "output": "public static FontCharset ValueOf(int value){if(value>=0&&value<=255)return _table[value];return null;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public NLPSentenceDetectorOp() {sentenceSplitter = null;}\n",
        "output": "public NLPSentenceDetectorOp(){sentenceSplitter = null;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String resource() {return this.resource;}\n",
        "output": "public override void Validate(){base.Validate();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public QueryScorer(Query query, String field) {init(query, field, null, true);}\n",
        "output": "public QueryScorer(Query query, string field){Init(query, field, null, true);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ActiveTrustedSigners(java.util.List<Signer> items) {setItems(items);}\n",
        "output": "public ActiveTrustedSigners(List<Signer> items){_items = items;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public final String toString() {StringBuilder sb = new StringBuilder();sb.append(getClass().getName());sb.append(\" [\");sb.append(formatReferenceAsString());sb.append(\"]\");return sb.toString();}\n",
        "output": "public override String ToString(){StringBuilder sb = new StringBuilder();sb.Append(GetType().Name);sb.Append(\" [\");sb.Append(FormatReferenceAsString());sb.Append(\"]\");return sb.ToString();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public UpdateNodegroupConfigResult updateNodegroupConfig(UpdateNodegroupConfigRequest request) {request = beforeClientExecution(request);return executeUpdateNodegroupConfig(request);}\n",
        "output": "public virtual UpdateNodegroupConfigResponse UpdateNodegroupConfig(UpdateNodegroupConfigRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateNodegroupConfigRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateNodegroupConfigResponseUnmarshaller.Instance;return Invoke<UpdateNodegroupConfigResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void fill(int fromIndex, int toIndex, long val) {assert val <= maxValue(getBitsPerValue());assert fromIndex <= toIndex;for (int i = fromIndex; i < toIndex; ++i) {set(i, val);}}\n",
        "output": "public virtual void Fill(int fromIndex, int toIndex, long val){Debug.Assert(val <= MaxValue(BitsPerValue));Debug.Assert(fromIndex <= toIndex);for (int i = fromIndex; i < toIndex; ++i){Set(i, val);}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ListTrainingJobsResult listTrainingJobs(ListTrainingJobsRequest request) {request = beforeClientExecution(request);return executeListTrainingJobs(request);}\n",
        "output": "public virtual ListTrainingJobsResponse ListTrainingJobs(ListTrainingJobsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListTrainingJobsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListTrainingJobsResponseUnmarshaller.Instance;return Invoke<ListTrainingJobsResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeProfilingGroupResult describeProfilingGroup(DescribeProfilingGroupRequest request) {request = beforeClientExecution(request);return executeDescribeProfilingGroup(request);}\n",
        "output": "public virtual DescribeProfilingGroupResponse DescribeProfilingGroup(DescribeProfilingGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeProfilingGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeProfilingGroupResponseUnmarshaller.Instance;return Invoke<DescribeProfilingGroupResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public IgnoreNode(List<FastIgnoreRule> rules) {this.rules = rules;}\n",
        "output": "public IgnoreNode(IList<IgnoreRule> rules){this.rules = rules;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public static void fill(char[] array, char value) {for (int i = 0; i < array.length; i++) {array[i] = value;}}\n",
        "output": "public static void fill(char[] array, char value){{for (int i = 0; i < array.Length; i++){array[i] = value;}}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public GetTransitGatewayMulticastDomainAssociationsResult getTransitGatewayMulticastDomainAssociations(GetTransitGatewayMulticastDomainAssociationsRequest request) {request = beforeClientExecution(request);return executeGetTransitGatewayMulticastDomainAssociations(request);}\n",
        "output": "public virtual GetTransitGatewayMulticastDomainAssociationsResponse GetTransitGatewayMulticastDomainAssociations(GetTransitGatewayMulticastDomainAssociationsRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetTransitGatewayMulticastDomainAssociationsRequestMarshaller.Instance;options.ResponseUnmarshaller = GetTransitGatewayMulticastDomainAssociationsResponseUnmarshaller.Instance;return Invoke<GetTransitGatewayMulticastDomainAssociationsResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public LongBuffer compact() {System.arraycopy(backingArray, position + offset, backingArray, offset, remaining());position = limit - position;limit = capacity;mark = UNSET_MARK;return this;}\n",
        "output": "public override java.nio.LongBuffer compact(){System.Array.Copy(backingArray, _position + offset, backingArray, offset, remaining());_position = _limit - _position;_limit = _capacity;_mark = UNSET_MARK;return this;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public GetCelebrityInfoResult getCelebrityInfo(GetCelebrityInfoRequest request) {request = beforeClientExecution(request);return executeGetCelebrityInfo(request);}\n",
        "output": "public virtual GetCelebrityInfoResponse GetCelebrityInfo(GetCelebrityInfoRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetCelebrityInfoRequestMarshaller.Instance;options.ResponseUnmarshaller = GetCelebrityInfoResponseUnmarshaller.Instance;return Invoke<GetCelebrityInfoResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public GetTranscriptResult getTranscript(GetTranscriptRequest request) {request = beforeClientExecution(request);return executeGetTranscript(request);}\n",
        "output": "public virtual GetTranscriptResponse GetTranscript(GetTranscriptRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetTranscriptRequestMarshaller.Instance;options.ResponseUnmarshaller = GetTranscriptResponseUnmarshaller.Instance;return Invoke<GetTranscriptResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DeleteCacheParameterGroupResult deleteCacheParameterGroup(DeleteCacheParameterGroupRequest request) {request = beforeClientExecution(request);return executeDeleteCacheParameterGroup(request);}\n",
        "output": "public virtual DeleteCacheParameterGroupResponse DeleteCacheParameterGroup(DeleteCacheParameterGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteCacheParameterGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteCacheParameterGroupResponseUnmarshaller.Instance;return Invoke<DeleteCacheParameterGroupResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeTagsRequest(java.util.List<Filter> filters) {setFilters(filters);}\n",
        "output": "public DescribeTagsRequest(List<Filter> filters){_filters = filters;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CreateCustomMetadataResult createCustomMetadata(CreateCustomMetadataRequest request) {request = beforeClientExecution(request);return executeCreateCustomMetadata(request);}\n",
        "output": "public virtual CreateCustomMetadataResponse CreateCustomMetadata(CreateCustomMetadataRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateCustomMetadataRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateCustomMetadataResponseUnmarshaller.Instance;return Invoke<CreateCustomMetadataResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public Cluster resumeCluster(ResumeClusterRequest request) {request = beforeClientExecution(request);return executeResumeCluster(request);}\n",
        "output": "public virtual ResumeClusterResponse ResumeCluster(ResumeClusterRequest request){var options = new InvokeOptions();options.RequestMarshaller = ResumeClusterRequestMarshaller.Instance;options.ResponseUnmarshaller = ResumeClusterResponseUnmarshaller.Instance;return Invoke<ResumeClusterResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeMovingAddressesResult describeMovingAddresses(DescribeMovingAddressesRequest request) {request = beforeClientExecution(request);return executeDescribeMovingAddresses(request);}\n",
        "output": "public virtual DescribeMovingAddressesResponse DescribeMovingAddresses(DescribeMovingAddressesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeMovingAddressesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeMovingAddressesResponseUnmarshaller.Instance;return Invoke<DescribeMovingAddressesResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public SearchAddressBooksResult searchAddressBooks(SearchAddressBooksRequest request) {request = beforeClientExecution(request);return executeSearchAddressBooks(request);}\n",
        "output": "public virtual SearchAddressBooksResponse SearchAddressBooks(SearchAddressBooksRequest request){var options = new InvokeOptions();options.RequestMarshaller = SearchAddressBooksRequestMarshaller.Instance;options.ResponseUnmarshaller = SearchAddressBooksResponseUnmarshaller.Instance;return Invoke<SearchAddressBooksResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public UpdateDomainToDomainGroupRequest() {super(\"Domain\", \"2018-01-29\", \"UpdateDomainToDomainGroup\");setMethod(MethodType.POST);}\n",
        "output": "public UpdateDomainToDomainGroupRequest(): base(\"Domain\", \"2018-01-29\", \"UpdateDomainToDomainGroup\"){Method = MethodType.POST;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void add(RevCommit c) {Block b = tail;if (b == null) {b = free.newBlock();b.add(c);head = b;tail = b;return;} else if (b.isFull()) {b = free.newBlock();tail.next = b;tail = b;}b.add(c);}\n",
        "output": "public override void Add(RevCommit c){BlockRevQueue.Block b = tail;if (b == null){b = free.NewBlock();b.Add(c);head = b;tail = b;return;}else{if (b.IsFull()){b = free.NewBlock();tail.next = b;tail = b;}}b.Add(c);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public FloatBuffer put(int index, float c) {checkIndex(index);byteBuffer.putFloat(index * SizeOf.FLOAT, c);return this;}\n",
        "output": "public override java.nio.FloatBuffer put(int index, float c){checkIndex(index);byteBuffer.putFloat(index * libcore.io.SizeOf.FLOAT, c);return this;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void flush() throws IOException {try {beginWrite();dst.flush();} catch (InterruptedIOException e) {throw writeTimedOut(e);} finally {endWrite();}}\n",
        "output": "public override void Flush(){try{BeginWrite();dst.Flush();}catch (ThreadInterruptedException){throw WriteTimedOut();}finally{EndWrite();}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public Set<String> getModified() {return Collections.unmodifiableSet(diff.getModified());}\n",
        "output": "public virtual ICollection<string> GetModified(){return Sharpen.Collections.UnmodifiableSet(diff.GetModified());}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public LongsRef next(int count) throws IOException {assert count > 0;if (ord == valueCount) {throw new EOFException();}if (off == blockSize) {refill();}count = Math.min(count, blockSize - off);count = (int) Math.min(count, valueCount - ord);valuesRef.offset = off;valuesRef.length = count;off += count;ord += count;return valuesRef;}\n",
        "output": "public Int64sRef Next(int count){Debug.Assert(count > 0);if (ord == valueCount){throw new System.IO.EndOfStreamException();}if (off == blockSize){Refill();}count = Math.Min(count, blockSize - off);count = (int)Math.Min(count, valueCount - ord);valuesRef.Offset = off;valuesRef.Length = count;off += count;ord += count;return valuesRef;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ByteBuffer slice() {return new ReadOnlyHeapByteBuffer(backingArray, remaining(), offset + position);}\n",
        "output": "public override java.nio.ByteBuffer slice(){return new java.nio.ReadOnlyHeapByteBuffer(backingArray, remaining(), offset + _position);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public final boolean isEmpty() {return beginA == endA && beginB == endB;}\n",
        "output": "public bool IsEmpty(){return beginA == endA && beginB == endB;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public static final int commitMessage(byte[] b, int ptr) {final int sz = b.length;if (ptr == 0)ptr += 46; while (ptr < sz && b[ptr] == 'p')ptr += 48; return tagMessage(b, ptr);}\n",
        "output": "public static int CommitMessage(byte[] b, int ptr){int sz = b.Length;if (ptr == 0){ptr += 46;}while (ptr < sz && b[ptr] == 'p'){ptr += 48;}return TagMessage(b, ptr);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ValueEval evaluate(ValueEval[] args, OperationEvaluationContext ec) {if (args.length != 2) {return ErrorEval.VALUE_INVALID;}try {double startDateAsNumber = getValue(args[0]);int offsetInMonthAsNumber = (int) getValue(args[1]);Date startDate = DateUtil.getJavaDate(startDateAsNumber);if (startDate == null) {return ErrorEval.VALUE_INVALID;}Calendar calendar = LocaleUtil.getLocaleCalendar();calendar.setTime(startDate);calendar.add(Calendar.MONTH, offsetInMonthAsNumber);return new NumberEval(DateUtil.getExcelDate(calendar.getTime()));} catch (EvaluationException e) {return e.getErrorEval();}}\n",
        "output": "public ValueEval Evaluate(ValueEval[] args, OperationEvaluationContext ec){double result;if (args.Length != 2){return ErrorEval.VALUE_INVALID;}try{double startDateAsNumber = GetValue(args[0]);int offsetInMonthAsNumber = (int)GetValue(args[1]);DateTime startDate = DateUtil.GetJavaDate(startDateAsNumber);DateTime resultDate = startDate.AddMonths(offsetInMonthAsNumber);result = DateUtil.GetExcelDate(resultDate);NumericFunction.CheckValue(result);return new NumberEval(result);}catch (EvaluationException e){return e.GetErrorEval();}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DeleteSuggesterResult deleteSuggester(DeleteSuggesterRequest request) {request = beforeClientExecution(request);return executeDeleteSuggester(request);}\n",
        "output": "public virtual DeleteSuggesterResponse DeleteSuggester(DeleteSuggesterRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteSuggesterRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteSuggesterResponseUnmarshaller.Instance;return Invoke<DeleteSuggesterResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CreatePipelineResult createPipeline(CreatePipelineRequest request) {request = beforeClientExecution(request);return executeCreatePipeline(request);}\n",
        "output": "public virtual CreatePipelineResponse CreatePipeline(CreatePipelineRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreatePipelineRequestMarshaller.Instance;options.ResponseUnmarshaller = CreatePipelineResponseUnmarshaller.Instance;return Invoke<CreatePipelineResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public StopDeliveryStreamEncryptionResult stopDeliveryStreamEncryption(StopDeliveryStreamEncryptionRequest request) {request = beforeClientExecution(request);return executeStopDeliveryStreamEncryption(request);}\n",
        "output": "public virtual StopDeliveryStreamEncryptionResponse StopDeliveryStreamEncryption(StopDeliveryStreamEncryptionRequest request){var options = new InvokeOptions();options.RequestMarshaller = StopDeliveryStreamEncryptionRequestMarshaller.Instance;options.ResponseUnmarshaller = StopDeliveryStreamEncryptionResponseUnmarshaller.Instance;return Invoke<StopDeliveryStreamEncryptionResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DeleteApplicationSnapshotResult deleteApplicationSnapshot(DeleteApplicationSnapshotRequest request) {request = beforeClientExecution(request);return executeDeleteApplicationSnapshot(request);}\n",
        "output": "public virtual DeleteApplicationSnapshotResponse DeleteApplicationSnapshot(DeleteApplicationSnapshotRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteApplicationSnapshotRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteApplicationSnapshotResponseUnmarshaller.Instance;return Invoke<DeleteApplicationSnapshotResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ApplyCommand apply() {return new ApplyCommand(repo);}\n",
        "output": "public virtual ApplyCommand Apply(){return new ApplyCommand(repo);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public RebootCacheClusterRequest(String cacheClusterId, java.util.List<String> cacheNodeIdsToReboot) {setCacheClusterId(cacheClusterId);setCacheNodeIdsToReboot(cacheNodeIdsToReboot);}\n",
        "output": "public RebootCacheClusterRequest(string cacheClusterId, List<string> cacheNodeIdsToReboot){_cacheClusterId = cacheClusterId;_cacheNodeIdsToReboot = cacheNodeIdsToReboot;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ModifyCacheClusterRequest(String cacheClusterId) {setCacheClusterId(cacheClusterId);}\n",
        "output": "public ModifyCacheClusterRequest(string cacheClusterId){_cacheClusterId = cacheClusterId;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public boolean equals(Object obj) {if (this == obj) return true;if (obj == null) return false;if (getClass() != obj.getClass()) return false;ScoreTerm other = (ScoreTerm) obj;if (term == null) {if (other.term != null) return false;} else if (!term.bytesEquals(other.term)) return false;return true;}\n",
        "output": "public override bool Equals(object obj){if (this == obj){return true;}if (obj == null){return false;}if (this.GetType() != obj.GetType()){return false;}ScoreTerm other = (ScoreTerm)obj;if (Term == null){if (other.Term != null){return false;}}else if (!Term.BytesEquals(other.Term)){return false;}return true;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public AssociateTransitGatewayMulticastDomainResult associateTransitGatewayMulticastDomain(AssociateTransitGatewayMulticastDomainRequest request) {request = beforeClientExecution(request);return executeAssociateTransitGatewayMulticastDomain(request);}\n",
        "output": "public virtual AssociateTransitGatewayMulticastDomainResponse AssociateTransitGatewayMulticastDomain(AssociateTransitGatewayMulticastDomainRequest request){var options = new InvokeOptions();options.RequestMarshaller = AssociateTransitGatewayMulticastDomainRequestMarshaller.Instance;options.ResponseUnmarshaller = AssociateTransitGatewayMulticastDomainResponseUnmarshaller.Instance;return Invoke<AssociateTransitGatewayMulticastDomainResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public UpdateContactResult updateContact(UpdateContactRequest request) {request = beforeClientExecution(request);return executeUpdateContact(request);}\n",
        "output": "public virtual UpdateContactResponse UpdateContact(UpdateContactRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateContactRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateContactResponseUnmarshaller.Instance;return Invoke<UpdateContactResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public TableRecord(CellRangeAddress8Bit range) {super(range);field_6_res = 0;}\n",
        "output": "public TableRecord(CellRangeAddress8Bit range): base(range){field_6_res = 0;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CreateProcessingJobResult createProcessingJob(CreateProcessingJobRequest request) {request = beforeClientExecution(request);return executeCreateProcessingJob(request);}\n",
        "output": "public virtual CreateProcessingJobResponse CreateProcessingJob(CreateProcessingJobRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateProcessingJobRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateProcessingJobResponseUnmarshaller.Instance;return Invoke<CreateProcessingJobResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CharSequence subSequence(int start, int end) {checkStartEndRemaining(start, end);CharSequenceAdapter result = copy(this);result.position = position + start;result.limit = position + end;return result;}\n",
        "output": "public override java.lang.CharSequence SubSequence(int start, int end){checkStartEndRemaining(start, end);java.nio.CharSequenceAdapter result = copy(this);result._position = _position + start;result._limit = _position + end;return result;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public GetCoipPoolUsageResult getCoipPoolUsage(GetCoipPoolUsageRequest request) {request = beforeClientExecution(request);return executeGetCoipPoolUsage(request);}\n",
        "output": "public virtual GetCoipPoolUsageResponse GetCoipPoolUsage(GetCoipPoolUsageRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetCoipPoolUsageRequestMarshaller.Instance;options.ResponseUnmarshaller = GetCoipPoolUsageResponseUnmarshaller.Instance;return Invoke<GetCoipPoolUsageResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public UpdateResolverEndpointResult updateResolverEndpoint(UpdateResolverEndpointRequest request) {request = beforeClientExecution(request);return executeUpdateResolverEndpoint(request);}\n",
        "output": "public virtual UpdateResolverEndpointResponse UpdateResolverEndpoint(UpdateResolverEndpointRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateResolverEndpointRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateResolverEndpointResponseUnmarshaller.Instance;return Invoke<UpdateResolverEndpointResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0) {ValueEval veText;try {veText = OperandResolver.getSingleValue(arg0, srcRowIndex, srcColumnIndex);} catch (EvaluationException e) {return e.getErrorEval();}String strText = OperandResolver.coerceValueToString(veText);Double result = convertTextToNumber(strText);if(result == null) result = parseDateTime(strText);if (result == null) {return ErrorEval.VALUE_INVALID;}return new NumberEval(result.doubleValue());}\n",
        "output": "public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0){ValueEval veText;try{veText = OperandResolver.GetSingleValue(arg0, srcRowIndex, srcColumnIndex);}catch (EvaluationException e){return e.GetErrorEval();}String strText = OperandResolver.CoerceValueToString(veText);Double result = ConvertTextToNumber(strText);if (Double.IsNaN(result)){return ErrorEval.VALUE_INVALID;}return new NumberEval(result);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public int addExternalName(ExternalNameRecord rec) {ExternalNameRecord[] tmp = new ExternalNameRecord[_externalNameRecords.length + 1];System.arraycopy(_externalNameRecords, 0, tmp, 0, _externalNameRecords.length);tmp[tmp.length - 1] = rec;_externalNameRecords = tmp;return _externalNameRecords.length - 1;}\n",
        "output": "public int AddExternalName(ExternalNameRecord rec){ExternalNameRecord[] tmp = new ExternalNameRecord[_externalNameRecords.Length + 1];Array.Copy(_externalNameRecords, 0, tmp, 0, _externalNameRecords.Length);tmp[tmp.Length - 1] = rec;_externalNameRecords = tmp;return _externalNameRecords.Length - 1;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribePrincipalIdFormatResult describePrincipalIdFormat(DescribePrincipalIdFormatRequest request) {request = beforeClientExecution(request);return executeDescribePrincipalIdFormat(request);}\n",
        "output": "public virtual DescribePrincipalIdFormatResponse DescribePrincipalIdFormat(DescribePrincipalIdFormatRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribePrincipalIdFormatRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribePrincipalIdFormatResponseUnmarshaller.Instance;return Invoke<DescribePrincipalIdFormatResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ListPartnerEventSourceAccountsResult listPartnerEventSourceAccounts(ListPartnerEventSourceAccountsRequest request) {request = beforeClientExecution(request);return executeListPartnerEventSourceAccounts(request);}\n",
        "output": "public virtual ListPartnerEventSourceAccountsResponse ListPartnerEventSourceAccounts(ListPartnerEventSourceAccountsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListPartnerEventSourceAccountsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListPartnerEventSourceAccountsResponseUnmarshaller.Instance;return Invoke<ListPartnerEventSourceAccountsResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public File getFile() {return file;}\n",
        "output": "public virtual FilePath GetFile(){return file;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void onChanged() {if (mSelectedIds.size() > 0) {return;}chooseListToShow();ensureSomeGroupIsExpanded();}\n",
        "output": "public override void onChanged(){this._enclosing.refreshExpGroupMetadataList(true, true);this._enclosing.notifyDataSetChanged();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String getTextAsString() {if (this.text == null)return null;elsereturn this.text.toString();}\n",
        "output": "public virtual string GetTextAsString(){if (this.m_text == null)return null;elsereturn this.m_text.ToString();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public LongBuffer put(long[] src, int srcOffset, int longCount) {Arrays.checkOffsetAndCount(src.length, srcOffset, longCount);if (longCount > remaining()) {throw new BufferOverflowException();}for (int i = srcOffset; i < srcOffset + longCount; ++i) {put(src[i]);}return this;}\n",
        "output": "public virtual java.nio.LongBuffer put(long[] src, int srcOffset, int longCount){java.util.Arrays.checkOffsetAndCount(src.Length, srcOffset, longCount);if (longCount > remaining()){throw new java.nio.BufferOverflowException();}{for (int i = srcOffset; i < srcOffset + longCount; ++i){put(src[i]);}}return this;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "@Override public boolean remove(Object object) {synchronized (CopyOnWriteArrayList.this) {int index = indexOf(object);if (index == -1) {return false;}remove(index);return true;}}\n",
        "output": "public virtual bool remove(object o){lock (this){int index = indexOf(o);if (index == -1){return false;}remove(index);return true;}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public long length() {if (onDiskFile == null) {return super.length();}return onDiskFile.length();}\n",
        "output": "public override long Length(){if (onDiskFile == null){return base.Length();}return onDiskFile.Length();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public FieldBoostMapFCListener(QueryConfigHandler config) {this.config = config;}\n",
        "output": "public FieldBoostMapFCListener(QueryConfigHandler config){this.config = config;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public StartActivityStreamResult startActivityStream(StartActivityStreamRequest request) {request = beforeClientExecution(request);return executeStartActivityStream(request);}\n",
        "output": "public virtual StartActivityStreamResponse StartActivityStream(StartActivityStreamRequest request){var options = new InvokeOptions();options.RequestMarshaller = StartActivityStreamRequestMarshaller.Instance;options.ResponseUnmarshaller = StartActivityStreamResponseUnmarshaller.Instance;return Invoke<StartActivityStreamResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public Hyphenation hyphenate(String word, int remainCharCount,int pushCharCount) {char[] w = word.toCharArray();return hyphenate(w, 0, w.length, remainCharCount, pushCharCount);}\n",
        "output": "public virtual Hyphenation Hyphenate(string word, int remainCharCount, int pushCharCount){char[] w = word.ToCharArray();return Hyphenate(w, 0, w.Length, remainCharCount, pushCharCount);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CreateSmsTemplateResult createSmsTemplate(CreateSmsTemplateRequest request) {request = beforeClientExecution(request);return executeCreateSmsTemplate(request);}\n",
        "output": "public virtual CreateSmsTemplateResponse CreateSmsTemplate(CreateSmsTemplateRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateSmsTemplateRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateSmsTemplateResponseUnmarshaller.Instance;return Invoke<CreateSmsTemplateResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void clear() {int n = mSize;Object[] values = mValues;for (int i = 0; i < n; i++) {values[i] = null;}mSize = 0;mGarbage = false;}\n",
        "output": "public virtual void clear(){int n = mSize;object[] values = mValues;{for (int i = 0; i < n; i++){values[i] = null;}}mSize = 0;mGarbage = false;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String toStringTree(Parser parser) {return toString();}\n",
        "output": "public virtual string ToStringTree(Parser parser){return ToString();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public long get(int index) {final int o = index >>> 2;final int b = index & 3;final int shift = b << 4;return (blocks[o] >>> shift) & 65535L;}\n",
        "output": "public override long Get(int index){int o = (int)((uint)index >> 2);int b = index & 3;int shift = b << 4;return ((long)((ulong)blocks[o] >> shift)) & 65535L;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String toString() {return getType().name() + \": \" + getOldId().name() + \" \"+ getNewId().name() + \" \" + getRefName();}\n",
        "output": "public override string ToString(){return GetType().ToString() + \": \" + GetOldId().Name + \" \" + GetNewId().Name + \" \"+ GetRefName();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval text, ValueEval number_times) {ValueEval veText1;try {veText1 = OperandResolver.getSingleValue(text, srcRowIndex, srcColumnIndex);} catch (EvaluationException e) {return e.getErrorEval();}String strText1 = OperandResolver.coerceValueToString(veText1);double numberOfTime = 0;try {numberOfTime = OperandResolver.coerceValueToDouble(number_times);} catch (EvaluationException e) {return ErrorEval.VALUE_INVALID;}int numberOfTimeInt = (int)numberOfTime;StringBuilder strb = new StringBuilder(strText1.length() * numberOfTimeInt);for(int i = 0; i < numberOfTimeInt; i++) {strb.append(strText1);}if (strb.toString().length() > 32767) {return ErrorEval.VALUE_INVALID;}return new StringEval(strb.toString());}\n",
        "output": "public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval text, ValueEval number_times){ValueEval veText1;try{veText1 = OperandResolver.GetSingleValue(text, srcRowIndex, srcColumnIndex);}catch (EvaluationException e){return e.GetErrorEval();}String strText1 = OperandResolver.CoerceValueToString(veText1);double numberOfTime = 0;try{numberOfTime = OperandResolver.CoerceValueToDouble(number_times);}catch (EvaluationException){return ErrorEval.VALUE_INVALID;}int numberOfTimeInt = (int)numberOfTime;StringBuilder strb = new StringBuilder(strText1.Length * numberOfTimeInt);for (int i = 0; i < numberOfTimeInt; i++){strb.Append(strText1);}if (strb.ToString().Length > 32767){return ErrorEval.VALUE_INVALID;}return new StringEval(strb.ToString());}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public Entry<K, V> lastEntry() {return immutableCopy(endpoint(false));}\n",
        "output": "public java.util.MapClass.Entry<K, V> lastEntry(){return this._enclosing.immutableCopy(this.endpoint(false));}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DeleteEvaluationResult deleteEvaluation(DeleteEvaluationRequest request) {request = beforeClientExecution(request);return executeDeleteEvaluation(request);}\n",
        "output": "public virtual DeleteEvaluationResponse DeleteEvaluation(DeleteEvaluationRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteEvaluationRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteEvaluationResponseUnmarshaller.Instance;return Invoke<DeleteEvaluationResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ContinueRecord(RecordInputStream in) {_data = in.readRemainder();}\n",
        "output": "public ContinueRecord(RecordInputStream in1){field_1_data = in1.ReadRemainder();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CreateFilterResult createFilter(CreateFilterRequest request) {request = beforeClientExecution(request);return executeCreateFilter(request);}\n",
        "output": "public virtual CreateFilterResponse CreateFilter(CreateFilterRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateFilterRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateFilterResponseUnmarshaller.Instance;return Invoke<CreateFilterResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CharSequence subSequence(int start, int end) {checkStartEndRemaining(start, end);CharBuffer result = duplicate();result.limit(position + end);result.position(position + start);return result;}\n",
        "output": "public override java.lang.CharSequence SubSequence(int start, int end){checkStartEndRemaining(start, end);java.nio.CharBuffer result = duplicate();result.limit(_position + end);result.position(_position + start);return result;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CreateTrafficMirrorSessionResult createTrafficMirrorSession(CreateTrafficMirrorSessionRequest request) {request = beforeClientExecution(request);return executeCreateTrafficMirrorSession(request);}\n",
        "output": "public virtual CreateTrafficMirrorSessionResponse CreateTrafficMirrorSession(CreateTrafficMirrorSessionRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateTrafficMirrorSessionRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateTrafficMirrorSessionResponseUnmarshaller.Instance;return Invoke<CreateTrafficMirrorSessionResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CreateNodegroupResult createNodegroup(CreateNodegroupRequest request) {request = beforeClientExecution(request);return executeCreateNodegroup(request);}\n",
        "output": "public virtual CreateNodegroupResponse CreateNodegroup(CreateNodegroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateNodegroupRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateNodegroupResponseUnmarshaller.Instance;return Invoke<CreateNodegroupResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public SoraniStemFilter create(TokenStream input) {return new SoraniStemFilter(input);}\n",
        "output": "public override TokenStream Create(TokenStream input){return new SoraniStemFilter(input);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public UpdateCustomVerificationEmailTemplateResult updateCustomVerificationEmailTemplate(UpdateCustomVerificationEmailTemplateRequest request) {request = beforeClientExecution(request);return executeUpdateCustomVerificationEmailTemplate(request);}\n",
        "output": "public virtual UpdateCustomVerificationEmailTemplateResponse UpdateCustomVerificationEmailTemplate(UpdateCustomVerificationEmailTemplateRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateCustomVerificationEmailTemplateRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateCustomVerificationEmailTemplateResponseUnmarshaller.Instance;return Invoke<UpdateCustomVerificationEmailTemplateResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public static FormulaError forInt(int type) throws IllegalArgumentException {FormulaError err = imap.get(type);if(err == null) err = bmap.get((byte)type);if(err == null) throw new IllegalArgumentException(\"Unknown error type: \" + type);return err;}\n",
        "output": "public static FormulaError ForInt(int type){if (imap.ContainsKey(type))return imap[type];if (bmap.ContainsKey((byte)type))return bmap[(byte)type];throw new ArgumentException(\"Unknown error type: \" + type);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DeleteSubnetGroupResult deleteSubnetGroup(DeleteSubnetGroupRequest request) {request = beforeClientExecution(request);return executeDeleteSubnetGroup(request);}\n",
        "output": "public virtual DeleteSubnetGroupResponse DeleteSubnetGroup(DeleteSubnetGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteSubnetGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteSubnetGroupResponseUnmarshaller.Instance;return Invoke<DeleteSubnetGroupResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String toString() {return getClass().getName() + \" [\" +_error.getString() +\"]\";}\n",
        "output": "public override String ToString(){StringBuilder sb = new StringBuilder(64);sb.Append(GetType().Name).Append(\" [\");sb.Append(_error.String);sb.Append(\"]\");return sb.ToString();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public Object toObject() {assert exists || 0.0D == value;return exists ? value : null;}\n",
        "output": "public override object ToObject(){return Exists ? (object)Value : null;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void destroy() {super.destroy();if (onDiskFile != null) {try {if (!onDiskFile.delete())onDiskFile.deleteOnExit();} finally {onDiskFile = null;}}}\n",
        "output": "public override void Destroy(){base.Destroy();if (onDiskFile != null){try{if (!onDiskFile.Delete()){onDiskFile.DeleteOnExit();}}finally{onDiskFile = null;}}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DecreaseReplicationFactorResult decreaseReplicationFactor(DecreaseReplicationFactorRequest request) {request = beforeClientExecution(request);return executeDecreaseReplicationFactor(request);}\n",
        "output": "public virtual DecreaseReplicationFactorResponse DecreaseReplicationFactor(DecreaseReplicationFactorRequest request){var options = new InvokeOptions();options.RequestMarshaller = DecreaseReplicationFactorRequestMarshaller.Instance;options.ResponseUnmarshaller = DecreaseReplicationFactorResponseUnmarshaller.Instance;return Invoke<DecreaseReplicationFactorResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public Counta(){_predicate = defaultPredicate;}\n",
        "output": "public Counta(){_predicate = defaultPredicate;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public EvaluationWorkbook getWorkbook() {return _workbook;}\n",
        "output": "public IEvaluationWorkbook GetWorkbook(){return _workbook;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeRouteTablesResult describeRouteTables() {return describeRouteTables(new DescribeRouteTablesRequest());}\n",
        "output": "public virtual DescribeRouteTablesResponse DescribeRouteTables(){return DescribeRouteTables(new DescribeRouteTablesRequest());}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CreateAssessmentTemplateResult createAssessmentTemplate(CreateAssessmentTemplateRequest request) {request = beforeClientExecution(request);return executeCreateAssessmentTemplate(request);}\n",
        "output": "public virtual CreateAssessmentTemplateResponse CreateAssessmentTemplate(CreateAssessmentTemplateRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateAssessmentTemplateRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateAssessmentTemplateResponseUnmarshaller.Instance;return Invoke<CreateAssessmentTemplateResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DeleteProjectResult deleteProject(DeleteProjectRequest request) {request = beforeClientExecution(request);return executeDeleteProject(request);}\n",
        "output": "public virtual DeleteProjectResponse DeleteProject(DeleteProjectRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteProjectRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteProjectResponseUnmarshaller.Instance;return Invoke<DeleteProjectResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DeleteUserPolicyRequest(String userName, String policyName) {setUserName(userName);setPolicyName(policyName);}\n",
        "output": "public DeleteUserPolicyRequest(string userName, string policyName){_userName = userName;_policyName = policyName;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public TermVectorsReader clone() {return new CompressingTermVectorsReader(this);}\n",
        "output": "public override object Clone(){return new CompressingTermVectorsReader(this);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void close() {if (sock != null) {try {sch.releaseSession(sock);} finally {sock = null;}}}\n",
        "output": "public override void Close(){if (sock != null){try{sch.ReleaseSession(sock);}finally{sock = null;}}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public LongBuffer put(long c) {throw new ReadOnlyBufferException();}\n",
        "output": "public override java.nio.LongBuffer put(long c){throw new java.nio.ReadOnlyBufferException();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public int serialize( int offset, byte[] data ) {LOG.log( DEBUG, \"Serializing Workbook with offsets\" );int pos = 0;SSTRecord lSST = null;int sstPos = 0;boolean wroteBoundSheets = false;for ( org.apache.poi.hssf.record.Record record : records.getRecords() ) {int len = 0;if (record instanceof SSTRecord) {lSST = (SSTRecord)record;sstPos = pos;}if (record.getSid() == ExtSSTRecord.sid && lSST != null) {record = lSST.createExtSSTRecord(sstPos + offset);}if (record instanceof BoundSheetRecord) {if(!wroteBoundSheets) {for (BoundSheetRecord bsr : boundsheets) {len += bsr.serialize(pos+offset+len, data);}wroteBoundSheets = true;}} else {len = record.serialize( pos + offset, data );}pos += len;}LOG.log( DEBUG, \"Exiting serialize workbook\" );return pos;}\n",
        "output": "public int Serialize(int offset, byte[] data){int pos = 0;SSTRecord sst = null;int sstPos = 0;bool wroteBoundSheets = false;for (int k = 0; k < records.Count; k++){Record record = records[k];if (record.Sid != RecalcIdRecord.sid || ((RecalcIdRecord)record).IsNeeded){int len = 0;if (record is SSTRecord){sst = (SSTRecord)record;sstPos = pos;}if (record.Sid == ExtSSTRecord.sid && sst != null){record = sst.CreateExtSSTRecord(sstPos + offset);}if (record is BoundSheetRecord){if (!wroteBoundSheets){for (int i = 0; i < boundsheets.Count; i++){len += ((BoundSheetRecord)boundsheets[i]).Serialize(pos + offset + len, data);}wroteBoundSheets = true;}}else{len = record.Serialize(pos + offset, data);}pos += len;   }}return pos;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeClusterSecurityGroupsResult describeClusterSecurityGroups() {return describeClusterSecurityGroups(new DescribeClusterSecurityGroupsRequest());}\n",
        "output": "public virtual DescribeClusterSecurityGroupsResponse DescribeClusterSecurityGroups(){return DescribeClusterSecurityGroups(new DescribeClusterSecurityGroupsRequest());}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public Explanation explain(Explanation freq, long norm) {return Explanation.match(score(freq.getValue().floatValue(), norm),\"score(freq=\" + freq.getValue() +\"), with freq of:\",Collections.singleton(freq));}\n",
        "output": "public virtual Explanation Explain(int doc, Explanation freq){Explanation result = new Explanation(Score(doc, freq.Value), \"score(doc=\" + doc + \",freq=\" + freq.Value + \"), with freq of:\");result.AddDetail(freq);return result;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DisassociatePhoneNumberFromUserResult disassociatePhoneNumberFromUser(DisassociatePhoneNumberFromUserRequest request) {request = beforeClientExecution(request);return executeDisassociatePhoneNumberFromUser(request);}\n",
        "output": "public virtual DisassociatePhoneNumberFromUserResponse DisassociatePhoneNumberFromUser(DisassociatePhoneNumberFromUserRequest request){var options = new InvokeOptions();options.RequestMarshaller = DisassociatePhoneNumberFromUserRequestMarshaller.Instance;options.ResponseUnmarshaller = DisassociatePhoneNumberFromUserResponseUnmarshaller.Instance;return Invoke<DisassociatePhoneNumberFromUserResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public boolean has(AnyObjectId objectId, int typeHint) throws IOException {try {open(objectId, typeHint);return true;} catch (MissingObjectException notFound) {return false;}}\n",
        "output": "public virtual bool Has(AnyObjectId objectId, int typeHint){try{Open(objectId, typeHint);return true;}catch (MissingObjectException){return false;}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String toString(){StringBuilder buffer = new StringBuilder();buffer.append(\"[ATTACHEDLABEL]\\n\");buffer.append(\"    .formatFlags          = \").append(\"0x\").append(HexDump.toHex(  getFormatFlags ())).append(\" (\").append( getFormatFlags() ).append(\" )\");buffer.append(System.getProperty(\"line.separator\"));buffer.append(\"         .showActual               = \").append(isShowActual()).append('\\n');buffer.append(\"         .showPercent              = \").append(isShowPercent()).append('\\n');buffer.append(\"         .labelAsPercentage        = \").append(isLabelAsPercentage()).append('\\n');buffer.append(\"         .smoothedLine             = \").append(isSmoothedLine()).append('\\n');buffer.append(\"         .showLabel                = \").append(isShowLabel()).append('\\n');buffer.append(\"         .showBubbleSizes          = \").append(isShowBubbleSizes()).append('\\n');buffer.append(\"[/ATTACHEDLABEL]\\n\");return buffer.toString();}\n",
        "output": "public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append(\"[ATTACHEDLABEL]\\n\");buffer.Append(\"    .formatFlags          = \").Append(\"0x\").Append(HexDump.ToHex(FormatFlags)).Append(\" (\").Append(FormatFlags).Append(\" )\");buffer.Append(Environment.NewLine);buffer.Append(\"         .showActual               = \").Append(IsShowActual).Append('\\n');buffer.Append(\"         .showPercent              = \").Append(IsShowPercent).Append('\\n');buffer.Append(\"         .labelAsPercentage        = \").Append(IsLabelAsPercentage).Append('\\n');buffer.Append(\"         .smoothedLine             = \").Append(IsSmoothedLine).Append('\\n');buffer.Append(\"         .showLabel                = \").Append(IsShowLabel).Append('\\n');buffer.Append(\"         .showBubbleSizes          = \").Append(IsShowBubbleSizes).Append('\\n');buffer.Append(\"[/ATTACHEDLABEL]\\n\");return buffer.ToString();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String toString(String field) {StringBuilder buffer = new StringBuilder();buffer.append(\"spanOr([\");Iterator<SpanQuery> i = clauses.iterator();while (i.hasNext()) {SpanQuery clause = i.next();buffer.append(clause.toString(field));if (i.hasNext()) {buffer.append(\", \");}}buffer.append(\"])\");return buffer.toString();}\n",
        "output": "public override string ToString(string field){StringBuilder buffer = new StringBuilder();buffer.Append(\"spanOr([\");bool first = true;foreach (SpanQuery clause in clauses){if (!first) buffer.Append(\", \");buffer.Append(clause.ToString(field));first = false;}buffer.Append(\"])\");buffer.Append(ToStringUtils.Boost(Boost));return buffer.ToString();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DisableInsightRulesResult disableInsightRules(DisableInsightRulesRequest request) {request = beforeClientExecution(request);return executeDisableInsightRules(request);}\n",
        "output": "public virtual DisableInsightRulesResponse DisableInsightRules(DisableInsightRulesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DisableInsightRulesRequestMarshaller.Instance;options.ResponseUnmarshaller = DisableInsightRulesResponseUnmarshaller.Instance;return Invoke<DisableInsightRulesResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public BootstrapActionConfig newRunIf(String condition, BootstrapActionConfig config) {List<String> args = config.getScriptBootstrapAction().getArgs();args.add(0, condition);args.add(1, config.getScriptBootstrapAction().getPath());return new BootstrapActionConfig().withName(\"Run If, \" + config.getName()).withScriptBootstrapAction(new ScriptBootstrapActionConfig().withPath(\"s3:.withArgs(args));}\n",
        "output": "public BootstrapActionConfig NewRunIf(string condition, BootstrapActionConfig config){List<string> args = config.ScriptBootstrapAction.Args;args.Add(condition);args.Add(config.ScriptBootstrapAction.Path);return new BootstrapActionConfig{Name = \"Run If, \" + config.Name,ScriptBootstrapAction = new ScriptBootstrapActionConfig{Path = \"s3:Args = args}};}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public final CharBuffer get(char[] dst, int dstOffset, int charCount) {Arrays.checkOffsetAndCount(dst.length, dstOffset, charCount);if (charCount > remaining()) {throw new BufferUnderflowException();}int newPosition = position + charCount;sequence.toString().getChars(position, newPosition, dst, dstOffset);position = newPosition;return this;}\n",
        "output": "public sealed override java.nio.CharBuffer get(char[] dst, int dstOffset, int charCount){java.util.Arrays.checkOffsetAndCount(dst.Length, dstOffset, charCount);if (charCount > remaining()){throw new java.nio.BufferUnderflowException();}int newPosition = _position + charCount;Sharpen.StringHelper.GetCharsForString(sequence.ToString(), _position, newPosition, dst, dstOffset);_position = newPosition;return this;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public Set<String> getNames(String section, String subsection) {return getState().getNames(section, subsection);}\n",
        "output": "public virtual ICollection<string> GetNames(string section, string subsection){return GetState().GetNames(section, subsection);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CreateBrokerResult createBroker(CreateBrokerRequest request) {request = beforeClientExecution(request);return executeCreateBroker(request);}\n",
        "output": "public virtual CreateBrokerResponse CreateBroker(CreateBrokerRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateBrokerRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateBrokerResponseUnmarshaller.Instance;return Invoke<CreateBrokerResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void onAbsorb(int velocity) {mState = STATE_ABSORB;velocity = Math.max(MIN_VELOCITY, Math.abs(velocity));mStartTime = AnimationUtils.currentAnimationTimeMillis();mDuration = 0.1f + (velocity * 0.03f);mEdgeAlphaStart = 0.f;mEdgeScaleY = mEdgeScaleYStart = 0.f;mGlowAlphaStart = 0.5f;mGlowScaleYStart = 0.f;mEdgeAlphaFinish = Math.max(0, Math.min(velocity * VELOCITY_EDGE_FACTOR, 1));mEdgeScaleYFinish = Math.max(HELD_EDGE_SCALE_Y, Math.min(velocity * VELOCITY_EDGE_FACTOR, 1.f));mGlowScaleYFinish = Math.min(0.025f + (velocity * (velocity / 100) * 0.00015f), 1.75f);mGlowAlphaFinish = Math.max(mGlowAlphaStart, Math.min(velocity * VELOCITY_GLOW_FACTOR * .00001f, MAX_ALPHA));}\n",
        "output": "public virtual void onAbsorb(int velocity){mState = STATE_ABSORB;velocity = System.Math.Max(MIN_VELOCITY, System.Math.Abs(velocity));mStartTime = android.view.animation.AnimationUtils.currentAnimationTimeMillis();mDuration = 0.1f + (velocity * 0.03f);mEdgeAlphaStart = 0.0f;mEdgeScaleY = mEdgeScaleYStart = 0.0f;mGlowAlphaStart = 0.5f;mGlowScaleYStart = 0.0f;mEdgeAlphaFinish = System.Math.Max(0, System.Math.Min(velocity * VELOCITY_EDGE_FACTOR, 1));mEdgeScaleYFinish = System.Math.Max(HELD_EDGE_SCALE_Y, System.Math.Min(velocity *VELOCITY_EDGE_FACTOR, 1.0f));mGlowScaleYFinish = System.Math.Min(0.025f + (velocity * (velocity / 100) * 0.00015f), 1.75f);mGlowAlphaFinish = System.Math.Max(mGlowAlphaStart, System.Math.Min(velocity * VELOCITY_GLOW_FACTOR* .00001f, MAX_ALPHA));}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ListSuppressedDestinationsResult listSuppressedDestinations(ListSuppressedDestinationsRequest request) {request = beforeClientExecution(request);return executeListSuppressedDestinations(request);}\n",
        "output": "public virtual ListSuppressedDestinationsResponse ListSuppressedDestinations(ListSuppressedDestinationsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListSuppressedDestinationsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListSuppressedDestinationsResponseUnmarshaller.Instance;return Invoke<ListSuppressedDestinationsResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public List<Pair<K,V>> getPairs() {List<Pair<K,V>> pairs = new ArrayList<Pair<K,V>>();for (K key : keySet()) {for (V value : get(key)) {pairs.add(new Pair<K,V>(key, value));}}return pairs;}\n",
        "output": "public virtual IList<Tuple<K, V>> GetPairs(){IList<Tuple<K, V>> pairs = new ArrayList<Tuple<K, V>>();foreach (KeyValuePair<K, IList<V>> pair in this){foreach (V value in pair.Value){pairs.Add(Tuple.Create(pair.Key, value));}}return pairs;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void setParams(String params) {super.setParams(params);int k = params.indexOf(\",\");name = params.substring(0,k).trim();value = params.substring(k+1).trim();}\n",
        "output": "public override void SetParams(string @params){base.SetParams(@params);int k = @params.IndexOf(',');name = @params.Substring(0, k - 0).Trim();value = @params.Substring(k + 1).Trim();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "@Override public V put(K key, V value) {if (!isInBounds(key)) {throw outOfBounds(key, fromBound, toBound);}return putInternal(key, value);}\n",
        "output": "public override V put(K key, V value){if (!this.isInBounds(key)){throw this.outOfBounds(key, this.fromBound, this.toBound);}return this._enclosing.putInternal(key, value);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DeregisterImageRequest(String imageId) {setImageId(imageId);}\n",
        "output": "public DeregisterImageRequest(string imageId){_imageId = imageId;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public GetApplicationResult getApplication(GetApplicationRequest request) {request = beforeClientExecution(request);return executeGetApplication(request);}\n",
        "output": "public virtual GetApplicationResponse GetApplication(GetApplicationRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetApplicationRequestMarshaller.Instance;options.ResponseUnmarshaller = GetApplicationResponseUnmarshaller.Instance;return Invoke<GetApplicationResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeProblemObservationsResult describeProblemObservations(DescribeProblemObservationsRequest request) {request = beforeClientExecution(request);return executeDescribeProblemObservations(request);}\n",
        "output": "public virtual DescribeProblemObservationsResponse DescribeProblemObservations(DescribeProblemObservationsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeProblemObservationsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeProblemObservationsResponseUnmarshaller.Instance;return Invoke<DescribeProblemObservationsResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public int fillFields(byte[] data, int offset, EscherRecordFactory recordFactory) {int bytesAfterHeader = readHeader( data, offset );int pos = offset + HEADER_SIZE;System.arraycopy( data, pos, field_1_UID, 0, 16 ); pos += 16;field_2_marker = data[pos]; pos++;setPictureData(data, pos, bytesAfterHeader - 17);return bytesAfterHeader + HEADER_SIZE;}\n",
        "output": "public override int FillFields(byte[] data, int offset, IEscherRecordFactory recordFactory){int bytesAfterHeader = ReadHeader(data, offset);int pos = offset + HEADER_SIZE;field_1_UID = new byte[16];Array.Copy(data, pos, field_1_UID, 0, 16); pos += 16;field_2_marker = data[pos]; pos++;field_pictureData = new byte[bytesAfterHeader - 17];Array.Copy(data, pos, field_pictureData, 0, field_pictureData.Length);return bytesAfterHeader + HEADER_SIZE;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public static boolean endsWith(BytesRef ref, BytesRef suffix) {int startAt = ref.length - suffix.length;if (startAt < 0) {return false;}return Arrays.equals(ref.bytes, ref.offset + startAt, ref.offset + startAt + suffix.length,suffix.bytes, suffix.offset, suffix.offset + suffix.length);}\n",
        "output": "public static bool EndsWith(BytesRef @ref, BytesRef suffix) {return SliceEquals(@ref, suffix, @ref.Length - suffix.Length);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DeleteOptionGroupResult deleteOptionGroup(DeleteOptionGroupRequest request) {request = beforeClientExecution(request);return executeDeleteOptionGroup(request);}\n",
        "output": "public virtual DeleteOptionGroupResponse DeleteOptionGroup(DeleteOptionGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteOptionGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteOptionGroupResponseUnmarshaller.Instance;return Invoke<DeleteOptionGroupResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public static String getFromUnicodeLE(byte[] string) {if (string.length == 0) {return \"\";}return getFromUnicodeLE(string, 0, string.length / 2);}\n",
        "output": "public static String GetFromUnicodeLE(byte[] str){if (str.Length == 0) { return \"\"; }return GetFromUnicodeLE(str, 0, str.Length / 2);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CellRangeAddressList() {_list = new ArrayList<>();}\n",
        "output": "public CellRangeAddressList(){_list = new ArrayList();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ValueEval evaluate(ValueEval[] args, OperationEvaluationContext ec) {throw new NotImplementedFunctionException(_functionName);}\n",
        "output": "public ValueEval Evaluate(ValueEval[] args, OperationEvaluationContext ec){throw new NotImplementedFunctionException(_functionName);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeOptionGroupsResult describeOptionGroups() {return describeOptionGroups(new DescribeOptionGroupsRequest());}\n",
        "output": "public virtual DescribeOptionGroupsResponse DescribeOptionGroups(){return DescribeOptionGroups(new DescribeOptionGroupsRequest());}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DisableVpcClassicLinkResult disableVpcClassicLink(DisableVpcClassicLinkRequest request) {request = beforeClientExecution(request);return executeDisableVpcClassicLink(request);}\n",
        "output": "public virtual DisableVpcClassicLinkResponse DisableVpcClassicLink(DisableVpcClassicLinkRequest request){var options = new InvokeOptions();options.RequestMarshaller = DisableVpcClassicLinkRequestMarshaller.Instance;options.ResponseUnmarshaller = DisableVpcClassicLinkResponseUnmarshaller.Instance;return Invoke<DisableVpcClassicLinkResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String toString() {StringBuilder buffer = new StringBuilder();buffer.append(\"[SXIDSTM]\\n\");buffer.append(\"    .idstm      =\").append(HexDump.shortToHex(idstm)).append('\\n');buffer.append(\"[/SXIDSTM]\\n\");return buffer.toString();}\n",
        "output": "public override string ToString(){StringBuilder buffer = new StringBuilder();buffer.Append(\"[SXIDSTM]\\n\");buffer.Append(\"    .idstm      =\").Append(HexDump.ShortToHex(idstm)).Append('\\n');buffer.Append(\"[/SXIDSTM]\\n\");return buffer.ToString();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ListStackInstancesResult listStackInstances(ListStackInstancesRequest request) {request = beforeClientExecution(request);return executeListStackInstances(request);}\n",
        "output": "public virtual ListStackInstancesResponse ListStackInstances(ListStackInstancesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListStackInstancesRequestMarshaller.Instance;options.ResponseUnmarshaller = ListStackInstancesResponseUnmarshaller.Instance;return Invoke<ListStackInstancesResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeCompanyNetworkConfigurationResult describeCompanyNetworkConfiguration(DescribeCompanyNetworkConfigurationRequest request) {request = beforeClientExecution(request);return executeDescribeCompanyNetworkConfiguration(request);}\n",
        "output": "public virtual DescribeCompanyNetworkConfigurationResponse DescribeCompanyNetworkConfiguration(DescribeCompanyNetworkConfigurationRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeCompanyNetworkConfigurationRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeCompanyNetworkConfigurationResponseUnmarshaller.Instance;return Invoke<DescribeCompanyNetworkConfigurationResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public final CoderResult flush(CharBuffer out) {if (status != END && status != INIT) {throw new IllegalStateException();}CoderResult result = implFlush(out);if (result == CoderResult.UNDERFLOW) {status = FLUSH;}return result;}\n",
        "output": "public java.nio.charset.CoderResult flush(java.nio.CharBuffer @out){if (status != END && status != INIT){throw new System.InvalidOperationException();}java.nio.charset.CoderResult result = implFlush(@out);if (result == java.nio.charset.CoderResult.UNDERFLOW){status = FLUSH;}return result;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeDBClustersResult describeDBClusters(DescribeDBClustersRequest request) {request = beforeClientExecution(request);return executeDescribeDBClusters(request);}\n",
        "output": "public virtual DescribeDBClustersResponse DescribeDBClusters(DescribeDBClustersRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeDBClustersRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeDBClustersResponseUnmarshaller.Instance;return Invoke<DescribeDBClustersResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public GetDocumentVersionResult getDocumentVersion(GetDocumentVersionRequest request) {request = beforeClientExecution(request);return executeGetDocumentVersion(request);}\n",
        "output": "public virtual GetDocumentVersionResponse GetDocumentVersion(GetDocumentVersionRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetDocumentVersionRequestMarshaller.Instance;options.ResponseUnmarshaller = GetDocumentVersionResponseUnmarshaller.Instance;return Invoke<GetDocumentVersionResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public TermData subtract(TermData t1, TermData t2) {if (t2 == NO_OUTPUT) {return t1;}TermData ret;if (statsEqual(t1, t2) && bytesEqual(t1, t2)) {ret = NO_OUTPUT;} else {ret = new TermData(t1.bytes, t1.docFreq, t1.totalTermFreq);}return ret;}\n",
        "output": "public override TermData Subtract(TermData t1, TermData t2){if (Equals(t2, NO_OUTPUT))return t1;Debug.Assert(t1.longs.Length == t2.longs.Length);int pos = 0;long diff = 0;var share = new long[_longsSize];while (pos < _longsSize){share[pos] = t1.longs[pos] - t2.longs[pos];diff += share[pos];pos++;}TermData ret;if (diff == 0 && StatsEqual(t1, t2) && BytesEqual(t1, t2)){ret = NO_OUTPUT;}else{ret = new TermData(share, t1.bytes, t1.docFreq, t1.totalTermFreq);}return ret;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ModifyCapacityReservationResult modifyCapacityReservation(ModifyCapacityReservationRequest request) {request = beforeClientExecution(request);return executeModifyCapacityReservation(request);}\n",
        "output": "public virtual ModifyCapacityReservationResponse ModifyCapacityReservation(ModifyCapacityReservationRequest request){var options = new InvokeOptions();options.RequestMarshaller = ModifyCapacityReservationRequestMarshaller.Instance;options.ResponseUnmarshaller = ModifyCapacityReservationResponseUnmarshaller.Instance;return Invoke<ModifyCapacityReservationResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "@Override public int size() {synchronized (mutex) {return c.size();}}\n",
        "output": "public virtual int size(){lock (mutex){return c.size();}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {for (int j = 0; j < iterations; ++j) {values[valuesOffset++] = blocks[blocksOffset++] & 0xFF;}}\n",
        "output": "public override void Decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations){for (int j = 0; j < iterations; ++j){values[valuesOffset++] = blocks[blocksOffset++] & 0xFF;}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public int length() throws UnsupportedOperationException {if (this.type == TYPE_MALFORMED_INPUT || this.type == TYPE_UNMAPPABLE_CHAR) {return this.length;}throw new UnsupportedOperationException(\"length meaningless for \" + toString());}\n",
        "output": "public virtual int length(){if (this.type == TYPE_MALFORMED_INPUT || this.type == TYPE_UNMAPPABLE_CHAR){return this._length;}throw new System.NotSupportedException(\"length meaningless for \" + ToString());}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String toFormulaString() {throw invalid();}\n",
        "output": "public override String ToFormulaString(){throw Invalid();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public E next() {if (iterator.nextIndex() < end) {return iterator.next();}throw new NoSuchElementException();}\n",
        "output": "public E next(){if (iterator.nextIndex() < end){return iterator.next();}throw new java.util.NoSuchElementException();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public static String toHex(long value) {StringBuilder sb = new StringBuilder(16);writeHex(sb, value, 16, \"\");return sb.toString();}\n",
        "output": "public static string ToHex(byte value){return ToHex((long)value, 2);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public long get(int index) {final int o = index >>> 6;final int b = index & 63;final int shift = b << 0;return (blocks[o] >>> shift) & 1L;}\n",
        "output": "public override long Get(int index){int o = (int)((uint)index >> 6);int b = index & 63;int shift = b << 0;return ((long)((ulong)blocks[o] >> shift)) & 1L;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public int[] clear() {start = end = null;return super.clear();}\n",
        "output": "public override int[] Clear(){start = end = null;return base.Clear();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public TokenStream init(TokenStream tokenStream) {termAtt = tokenStream.addAttribute(CharTermAttribute.class);return null;}\n",
        "output": "public virtual TokenStream Init(TokenStream tokenStream){termAtt = tokenStream.AddAttribute<ICharTermAttribute>();return null;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public UpdateGameServerGroupResult updateGameServerGroup(UpdateGameServerGroupRequest request) {request = beforeClientExecution(request);return executeUpdateGameServerGroup(request);}\n",
        "output": "public virtual UpdateGameServerGroupResponse UpdateGameServerGroup(UpdateGameServerGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateGameServerGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateGameServerGroupResponseUnmarshaller.Instance;return Invoke<UpdateGameServerGroupResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public UnmappableCharacterException(int length) {this.inputLength = length;}\n",
        "output": "public UnmappableCharacterException(int length){this.inputLength = length;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public UpdateIdentityProviderConfigurationResult updateIdentityProviderConfiguration(UpdateIdentityProviderConfigurationRequest request) {request = beforeClientExecution(request);return executeUpdateIdentityProviderConfiguration(request);}\n",
        "output": "public virtual UpdateIdentityProviderConfigurationResponse UpdateIdentityProviderConfiguration(UpdateIdentityProviderConfigurationRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateIdentityProviderConfigurationRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateIdentityProviderConfigurationResponseUnmarshaller.Instance;return Invoke<UpdateIdentityProviderConfigurationResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "@Override public int lastIndexOf(Object object) {Object[] a = array;if (object != null) {for (int i = size - 1; i >= 0; i--) {if (object.equals(a[i])) {return i;}}} else {for (int i = size - 1; i >= 0; i--) {if (a[i] == null) {return i;}}}return -1;}\n",
        "output": "public override int lastIndexOf(object @object){if (@object != null){{for (int i = a.Length - 1; i >= 0; i--){if (@object.Equals(a[i])){return i;}}}}else{{for (int i = a.Length - 1; i >= 0; i--){if ((object)a[i] == null){return i;}}}}return -1;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ConstantScoreQueryBuilder(QueryBuilderFactory queryFactory) {this.queryFactory = queryFactory;}\n",
        "output": "public ConstantScoreQueryBuilder(FilterBuilderFactory filterFactory){this.filterFactory = filterFactory;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public int getNumberOfOnChannelTokens() {int n = 0;fill();for (int i = 0; i < tokens.size(); i++) {Token t = tokens.get(i);if ( t.getChannel()==channel ) n++;if ( t.getType()==Token.EOF ) break;}return n;}\n",
        "output": "public virtual int GetNumberOfOnChannelTokens(){int n = 0;Fill();for (int i = 0; i < tokens.Count; i++){IToken t = tokens[i];if (t.Channel == channel){n++;}if (t.Type == TokenConstants.EOF){break;}}return n;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public POIFSDocumentPath(final String [] components)throws IllegalArgumentException{if (components == null){this.components = new String[ 0 ];}else{this.components = new String[ components.length ];for (int j = 0; j < components.length; j++){if ((components[ j ] == null)|| (components[ j ].length() == 0)){throw new IllegalArgumentException(\"components cannot contain null or empty strings\");}this.components[ j ] = components[ j ];}}}\n",
        "output": "public POIFSDocumentPath(string[] components){if (components == null){this.components = new string[0];}else{this.components = new string[components.Length];for (int i = 0; i < components.Length; i++){if ((components[i] == null)|| (components[i].Length == 0)){throw new ArgumentException(\"components cannot contain null or empty strings\");}this.components[i] = components[i];}}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public SQLException(String theReason) {this(theReason, null, 0);}\n",
        "output": "public SQLException(string error) : base(error){throw new System.NotImplementedException();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ListFragmentsResult listFragments(ListFragmentsRequest request) {request = beforeClientExecution(request);return executeListFragments(request);}\n",
        "output": "public virtual ListFragmentsResponse ListFragments(ListFragmentsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListFragmentsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListFragmentsResponseUnmarshaller.Instance;return Invoke<ListFragmentsResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public QueryBuilder getQueryBuilder(String nodeName) {return builders.get(nodeName);}\n",
        "output": "public virtual IQueryBuilder GetQueryBuilder(string nodeName){IQueryBuilder result;builders.TryGetValue(nodeName, out result);return result;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CreateDirectoryResult createDirectory(CreateDirectoryRequest request) {request = beforeClientExecution(request);return executeCreateDirectory(request);}\n",
        "output": "public virtual CreateDirectoryResponse CreateDirectory(CreateDirectoryRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateDirectoryRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateDirectoryResponseUnmarshaller.Instance;return Invoke<CreateDirectoryResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public int getExternalSheetIndex(String workbookName, String sheetName) {return getOrCreateLinkTable().getExternalSheetIndex(workbookName, sheetName, sheetName);}\n",
        "output": "public int GetExternalSheetIndex(String workbookName, String sheetName){return OrCreateLinkTable.GetExternalSheetIndex(workbookName, sheetName, sheetName);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public V getValue() {return value;}\n",
        "output": "public virtual V getValue(){return value;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public K getKey() {return key;}\n",
        "output": "public virtual K getKey(){return key;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public boolean hasTransparentBounds() {return transparentBounds;}\n",
        "output": "public bool hasTransparentBounds(){return transparentBounds;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void setKeepEmpty(boolean empty) {keepEmpty = empty;}\n",
        "output": "public virtual void SetKeepEmpty(bool empty){keepEmpty = empty;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public XPathRuleAnywhereElement(String ruleName, int ruleIndex) {super(ruleName);this.ruleIndex = ruleIndex;}\n",
        "output": "public XPathRuleAnywhereElement(string ruleName, int ruleIndex): base(ruleName){this.ruleIndex = ruleIndex;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public int getHeight(){return _height;}\n",
        "output": "public int GetHeight(){return height;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public final void write(OpenStringBuilder arr) {write(arr.buf, 0, len);}\n",
        "output": "public void Write(OpenStringBuilder arr){Write(arr.m_buf, 0, arr.Length); }\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void jumpDrawablesToCurrentState() {super.jumpDrawablesToCurrentState();if (mThumb != null) mThumb.jumpToCurrentState();}\n",
        "output": "public override void jumpDrawablesToCurrentState(){base.jumpDrawablesToCurrentState();if (mThumb != null){mThumb.jumpToCurrentState();}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void setParams(String params) {super.setParams(params);final StreamTokenizer stok = new StreamTokenizer(new StringReader(params));stok.quoteChar('\"');stok.quoteChar('\\'');stok.eolIsSignificant(false);stok.ordinaryChar(',');try {while (stok.nextToken() != StreamTokenizer.TT_EOF) {switch (stok.ttype) {case ',': {break;}case '\\'':case '\\\"':case StreamTokenizer.TT_WORD: {analyzerNames.add(stok.sval);break;}default: {throw new RuntimeException(\"Unexpected token: \" + stok.toString());}}}} catch (RuntimeException e) {if (e.getMessage().startsWith(\"Line #\")) {throw e;} else {throw new RuntimeException(\"Line #\" + (stok.lineno() + getAlgLineNum()) + \": \", e);}} catch (Throwable t) {throw new RuntimeException(\"Line #\" + (stok.lineno() + getAlgLineNum()) + \": \", t);}}\n",
        "output": "public override void SetParams(string @params){base.SetParams(@params);StreamTokenizer stok = new StreamTokenizer(new StringReader(@params));stok.QuoteChar('\"');stok.QuoteChar('\\'');stok.EndOfLineIsSignificant = false;stok.OrdinaryChar(',');try{while (stok.NextToken() != StreamTokenizer.TokenType_EndOfStream){switch (stok.TokenType){case ',':{break;}case '\\'':case '\\\"':case StreamTokenizer.TokenType_Word:{analyzerNames.Add(stok.StringValue);break;}default:{throw new Exception(\"Unexpected token: \" + stok.ToString());}}}}catch (Exception e){if (e.Message.StartsWith(\"Line #\", StringComparison.Ordinal)){throw; }else{throw new Exception(\"Line #\" + (stok.LineNumber + AlgLineNum) + \": \", e);}}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeVolumesResult describeVolumes(DescribeVolumesRequest request) {request = beforeClientExecution(request);return executeDescribeVolumes(request);}\n",
        "output": "public virtual DescribeVolumesResponse DescribeVolumes(DescribeVolumesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeVolumesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeVolumesResponseUnmarshaller.Instance;return Invoke<DescribeVolumesResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeFlowLogsResult describeFlowLogs(DescribeFlowLogsRequest request) {request = beforeClientExecution(request);return executeDescribeFlowLogs(request);}\n",
        "output": "public virtual DescribeFlowLogsResponse DescribeFlowLogs(DescribeFlowLogsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeFlowLogsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeFlowLogsResponseUnmarshaller.Instance;return Invoke<DescribeFlowLogsResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public UpdateMethodResult updateMethod(UpdateMethodRequest request) {request = beforeClientExecution(request);return executeUpdateMethod(request);}\n",
        "output": "public virtual UpdateMethodResponse UpdateMethod(UpdateMethodRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateMethodRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateMethodResponseUnmarshaller.Instance;return Invoke<UpdateMethodResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public GetAuthorizationTokenRequest() {super(\"cr\", \"2016-06-07\", \"GetAuthorizationToken\", \"cr\");setUriPattern(\"/tokens\");setMethod(MethodType.GET);}\n",
        "output": "public GetAuthorizationTokenRequest(): base(\"cr\", \"2016-06-07\", \"GetAuthorizationToken\", \"cr\", \"openAPI\"){UriPattern = \"/tokens\";Method = MethodType.GET;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public StopContactResult stopContact(StopContactRequest request) {request = beforeClientExecution(request);return executeStopContact(request);}\n",
        "output": "public virtual StopContactResponse StopContact(StopContactRequest request){var options = new InvokeOptions();options.RequestMarshaller = StopContactRequestMarshaller.Instance;options.ResponseUnmarshaller = StopContactResponseUnmarshaller.Instance;return Invoke<StopContactResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CreateDataSetResult createDataSet(CreateDataSetRequest request) {request = beforeClientExecution(request);return executeCreateDataSet(request);}\n",
        "output": "public virtual CreateDataSetResponse CreateDataSet(CreateDataSetRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateDataSetRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateDataSetResponseUnmarshaller.Instance;return Invoke<CreateDataSetResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ObjectDatabase newCachedDatabase() {return this;}\n",
        "output": "public virtual NGit.ObjectDatabase NewCachedDatabase(){return this;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CreateJourneyResult createJourney(CreateJourneyRequest request) {request = beforeClientExecution(request);return executeCreateJourney(request);}\n",
        "output": "public virtual CreateJourneyResponse CreateJourney(CreateJourneyRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateJourneyRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateJourneyResponseUnmarshaller.Instance;return Invoke<CreateJourneyResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DeleteDashboardsResult deleteDashboards(DeleteDashboardsRequest request) {request = beforeClientExecution(request);return executeDeleteDashboards(request);}\n",
        "output": "public virtual DeleteDashboardsResponse DeleteDashboards(DeleteDashboardsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteDashboardsRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteDashboardsResponseUnmarshaller.Instance;return Invoke<DeleteDashboardsResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public UpgradeIndexMergePolicy(MergePolicy in) {super(in);}\n",
        "output": "public UpgradeIndexMergePolicy(MergePolicy @base){this.m_base = @base;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public GetHealthCheckCountResult getHealthCheckCount(GetHealthCheckCountRequest request) {request = beforeClientExecution(request);return executeGetHealthCheckCount(request);}\n",
        "output": "public virtual GetHealthCheckCountResponse GetHealthCheckCount(GetHealthCheckCountRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetHealthCheckCountRequestMarshaller.Instance;options.ResponseUnmarshaller = GetHealthCheckCountResponseUnmarshaller.Instance;return Invoke<GetHealthCheckCountResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ChartStartBlockRecord(RecordInputStream in) {rt = in.readShort();grbitFrt = in.readShort();iObjectKind = in.readShort();iObjectContext = in.readShort();iObjectInstance1 = in.readShort();iObjectInstance2 = in.readShort();}\n",
        "output": "public ChartStartBlockRecord(RecordInputStream in1){rt = in1.ReadShort();grbitFrt = in1.ReadShort();iObjectKind = in1.ReadShort();iObjectContext = in1.ReadShort();iObjectInstance1 = in1.ReadShort();iObjectInstance2 = in1.ReadShort();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public SeriesRecord(RecordInputStream in) {field_1_categoryDataType = in.readShort();field_2_valuesDataType   = in.readShort();field_3_numCategories    = in.readShort();field_4_numValues        = in.readShort();field_5_bubbleSeriesType = in.readShort();field_6_numBubbleValues  = in.readShort();}\n",
        "output": "public SeriesRecord(RecordInputStream in1){field_1_categoryDataType = in1.ReadShort();field_2_valuesDataType = in1.ReadShort();field_3_numCategories = in1.ReadShort();field_4_numValues = in1.ReadShort();field_5_bubbleSeriesType = in1.ReadShort();field_6_numBubbleValues = in1.ReadShort();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public static Class<? extends CharFilterFactory> lookupClass(String name) {return loader.lookupClass(name);}\n",
        "output": "public static Type LookupClass(string name){return loader.LookupClass(name);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public GetPublicKeyResult getPublicKey(GetPublicKeyRequest request) {request = beforeClientExecution(request);return executeGetPublicKey(request);}\n",
        "output": "public virtual GetPublicKeyResponse GetPublicKey(GetPublicKeyRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetPublicKeyRequestMarshaller.Instance;options.ResponseUnmarshaller = GetPublicKeyResponseUnmarshaller.Instance;return Invoke<GetPublicKeyResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CreateLocalGatewayRouteTableVpcAssociationResult createLocalGatewayRouteTableVpcAssociation(CreateLocalGatewayRouteTableVpcAssociationRequest request) {request = beforeClientExecution(request);return executeCreateLocalGatewayRouteTableVpcAssociation(request);}\n",
        "output": "public virtual CreateLocalGatewayRouteTableVpcAssociationResponse CreateLocalGatewayRouteTableVpcAssociation(CreateLocalGatewayRouteTableVpcAssociationRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateLocalGatewayRouteTableVpcAssociationRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateLocalGatewayRouteTableVpcAssociationResponseUnmarshaller.Instance;return Invoke<CreateLocalGatewayRouteTableVpcAssociationResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public static boolean toBoolean(String stringValue) {if (stringValue == null)throw new NullPointerException(JGitText.get().expectedBooleanStringValue);final Boolean bool = toBooleanOrNull(stringValue);if (bool == null)throw new IllegalArgumentException(MessageFormat.format(JGitText.get().notABoolean, stringValue));return bool.booleanValue();}\n",
        "output": "public static bool ToBoolean(string stringValue){if (stringValue == null){throw new ArgumentNullException(JGitText.Get().expectedBooleanStringValue);}bool? @bool = ToBooleanOrNull(stringValue);if (@bool == null){throw new ArgumentException(MessageFormat.Format(JGitText.Get().notABoolean, stringValue));}return @bool.Value;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public Set<String> getAdded() {return Collections.unmodifiableSet(diff.getAdded());}\n",
        "output": "public virtual ICollection<string> GetAdded(){return Sharpen.Collections.UnmodifiableSet(diff.GetAdded());}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public Set<String> getNames(String section) {return getNames(section, null);}\n",
        "output": "public virtual ICollection<string> GetNames(string section){return GetNames(section, null);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeCacheClustersResult describeCacheClusters(DescribeCacheClustersRequest request) {request = beforeClientExecution(request);return executeDescribeCacheClusters(request);}\n",
        "output": "public virtual DescribeCacheClustersResponse DescribeCacheClusters(DescribeCacheClustersRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeCacheClustersRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeCacheClustersResponseUnmarshaller.Instance;return Invoke<DescribeCacheClustersResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public List<String> getUnmergedPaths() {return unmergedPaths;}\n",
        "output": "public virtual IList<string> GetUnmergedPaths(){return unmergedPaths;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ValueEval evaluate(ValueEval[] args, OperationEvaluationContext ec) {if (args.length != 2) {return ErrorEval.VALUE_INVALID;}return evaluate(ec.getRowIndex(), ec.getColumnIndex(), args[0], args[1]);}\n",
        "output": "public ValueEval Evaluate(ValueEval[] args, OperationEvaluationContext ec){if (args.Length != 2){return ErrorEval.VALUE_INVALID;}return Evaluate(ec.RowIndex, ec.ColumnIndex, args[0], args[1]);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public int addString(UnicodeString string){field_1_num_strings++;UnicodeString ucs = ( string == null ) ? EMPTY_STRING: string;int rval;int index = field_3_strings.getIndex(ucs);if ( index != -1 ) {rval = index;} else {rval = field_3_strings.size();field_2_num_unique_strings++;SSTDeserializer.addToStringTable( field_3_strings, ucs );}return rval;}\n",
        "output": "public int AddString(UnicodeString str){field_1_num_strings++;UnicodeString ucs = (str == null) ? EMPTY_STRING: str;int rval;int index = field_3_strings.GetIndex(ucs);if (index != -1){rval = index;}else{rval = field_3_strings.Size;field_2_num_unique_strings++;SSTDeserializer.AddToStringTable(field_3_strings, ucs);}return rval;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public long getDeltaSearchMemoryLimit() {return deltaSearchMemoryLimit;}\n",
        "output": "public virtual long GetDeltaSearchMemoryLimit(){return deltaSearchMemoryLimit;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String toString() {return \"Token(\\\"\" + new String(surfaceForm, offset, length) + \"\\\" pos=\" + position + \" length=\" + length +\" posLen=\" + positionLength + \" type=\" + type + \" wordId=\" + wordId +\" leftID=\" + dictionary.getLeftId(wordId) + \")\";}\n",
        "output": "public override string ToString(){return \"Token(\\\"\" + new string(surfaceForm, offset, length) + \"\\\" pos=\" + position + \" length=\" + length +\" posLen=\" + positionLength + \" type=\" + type + \" wordId=\" + wordId +\" leftID=\" + dictionary.GetLeftId(wordId) + \")\";}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String toFormulaString(FormulaRenderingWorkbook book) {return ExternSheetNameResolver.prependSheetName(book, field_1_index_extern_sheet, formatReferenceAsString());}\n",
        "output": "public String ToFormulaString(IFormulaRenderingWorkbook book){return ExternSheetNameResolver.PrependSheetName(book, field_1_index_extern_sheet, FormatReferenceAsString());}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public E get(int index) {return (E) elements[index];}\n",
        "output": "public virtual E get(int index){return (E)elements[index];}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public byte[] getCachedBytes() {return data;}\n",
        "output": "public override byte[] GetCachedBytes(){return data;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeConnectionsResult describeConnections() {return describeConnections(new DescribeConnectionsRequest());}\n",
        "output": "public virtual DescribeConnectionsResponse DescribeConnections(){return DescribeConnections(new DescribeConnectionsRequest());}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void ensureCapacity(int minimumCapacity) {Object[] a = array;if (a.length < minimumCapacity) {Object[] newArray = new Object[minimumCapacity];System.arraycopy(a, 0, newArray, 0, size);array = newArray;modCount++;}}\n",
        "output": "public virtual void ensureCapacity(int minimumCapacity){object[] a = array;if (a.Length < minimumCapacity){object[] newArray = new object[minimumCapacity];System.Array.Copy(a, 0, newArray, 0, _size);array = newArray;modCount++;}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DeleteLifecycleHookResult deleteLifecycleHook(DeleteLifecycleHookRequest request) {request = beforeClientExecution(request);return executeDeleteLifecycleHook(request);}\n",
        "output": "public virtual DeleteLifecycleHookResponse DeleteLifecycleHook(DeleteLifecycleHookRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteLifecycleHookRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteLifecycleHookResponseUnmarshaller.Instance;return Invoke<DeleteLifecycleHookResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public final float maxBytesPerChar() {return maxBytesPerChar;}\n",
        "output": "public float maxBytesPerChar(){return _maxBytesPerChar;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public BlankCellRectangleGroup(int firstRowIndex, int firstColumnIndex, int lastColumnIndex) {_firstRowIndex = firstRowIndex;_firstColumnIndex = firstColumnIndex;_lastColumnIndex = lastColumnIndex;_lastRowIndex = firstRowIndex;}\n",
        "output": "public BlankCellRectangleGroup(int firstRowIndex, int firstColumnIndex, int lastColumnIndex){_firstRowIndex = firstRowIndex;_firstColumnIndex = firstColumnIndex;_lastColumnIndex = lastColumnIndex;_lastRowIndex = firstRowIndex;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public int findEndOfRowOutlineGroup(int row) {int level = getRow( row ).getOutlineLevel();int currentRow;for (currentRow = row; currentRow < getLastRowNum(); currentRow++) {if (getRow(currentRow) == null || getRow(currentRow).getOutlineLevel() < level) {break;}}return currentRow-1;}\n",
        "output": "public int FindEndOfRowOutlineGroup(int row){int level = GetRow(row).OutlineLevel;int currentRow;for (currentRow = row; currentRow < this.LastRowNum; currentRow++){if (GetRow(currentRow) == null || GetRow(currentRow).OutlineLevel < level){break;}}return currentRow - 1;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String getEncoding() {if (encoder == null) {return null;}return HistoricalCharsetNames.get(encoder.charset());}\n",
        "output": "public virtual string getEncoding(){if (encoder == null){return null;}return java.io.HistoricalCharsetNames.get(encoder.charset());}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void clearAllCachedResultValues() {_cache.clear();_sheetIndexesBySheet.clear();_workbook.clearAllCachedResultValues();}\n",
        "output": "public void ClearAllCachedResultValues(){_cache.Clear();_sheetIndexesBySheet.Clear();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public final String toString() {StringBuilder sb = new StringBuilder();String recordName = getRecordName();sb.append(\"[\").append(recordName).append(\"]\\n\");sb.append(\"    .row    = \").append(HexDump.shortToHex(getRow())).append(\"\\n\");sb.append(\"    .col    = \").append(HexDump.shortToHex(getColumn())).append(\"\\n\");if (isBiff2()) {sb.append(\"    .cellattrs = \").append(HexDump.shortToHex(getCellAttrs())).append(\"\\n\");} else {sb.append(\"    .xfindex   = \").append(HexDump.shortToHex(getXFIndex())).append(\"\\n\");}appendValueText(sb);sb.append(\"\\n\");sb.append(\"[/\").append(recordName).append(\"]\\n\");return sb.toString();}\n",
        "output": "public override String ToString(){StringBuilder sb = new StringBuilder();String recordName = this.RecordName;sb.Append(\"[\").Append(recordName).Append(\"]\\n\");sb.Append(\"    .row    = \").Append(HexDump.ShortToHex(Row)).Append(\"\\n\");sb.Append(\"    .col    = \").Append(HexDump.ShortToHex(Column)).Append(\"\\n\");if (IsBiff2){sb.Append(\"    .cellattrs = \").Append(HexDump.ShortToHex(CellAttrs)).Append(\"\\n\");}else{sb.Append(\"    .xFindex   = \").Append(HexDump.ShortToHex(XFIndex)).Append(\"\\n\");}AppendValueText(sb);sb.Append(\"\\n\");sb.Append(\"[/\").Append(recordName).Append(\"]\\n\");return sb.ToString();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeDBClusterEndpointsResult describeDBClusterEndpoints(DescribeDBClusterEndpointsRequest request) {request = beforeClientExecution(request);return executeDescribeDBClusterEndpoints(request);}\n",
        "output": "public virtual DescribeDBClusterEndpointsResponse DescribeDBClusterEndpoints(DescribeDBClusterEndpointsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeDBClusterEndpointsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeDBClusterEndpointsResponseUnmarshaller.Instance;return Invoke<DescribeDBClusterEndpointsResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public boolean renameTo(final String newName){boolean rval = false;if (!isRoot()){rval = _parent.changeName(getName(), newName);}return rval;}\n",
        "output": "public bool RenameTo(String newName){bool rval = false;if (!IsRoot){rval = _parent.ChangeName(Name, newName);}return rval;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public Explanation explain(Explanation freq, long norm) {List<Explanation> subs = new ArrayList<>();for (SimScorer subScorer : subScorers) {subs.add(subScorer.explain(freq, norm));}return Explanation.match(score(freq.getValue().floatValue(), norm), \"sum of:\", subs);}\n",
        "output": "public override Explanation Explain(int doc, Explanation freq){Explanation expl = new Explanation(Score(doc, freq.Value), \"sum of:\");foreach (SimScorer subScorer in subScorers){expl.AddDetail(subScorer.Explain(doc, freq));}return expl;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DocTermsIndexDocValues(ValueSource vs, LeafReaderContext context, String field) throws IOException {this(vs, open(context, field));}\n",
        "output": "public DocTermsIndexDocValues(ValueSource vs, AtomicReaderContext context, string field){try{m_termsIndex = FieldCache.DEFAULT.GetTermsIndex(context.AtomicReader, field);}catch (Exception e){throw new DocTermsIndexException(field, e);}this.m_vs = vs;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public static int compareTo(Ref o1, Ref o2) {return o1.getName().compareTo(o2.getName());}\n",
        "output": "public static int CompareTo(Ref o1, string o2){return Sharpen.Runtime.CompareOrdinal(o1.GetName(), o2);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public Dimension getImageDimension(){InternalWorkbook iwb = getPatriarch().getSheet().getWorkbook().getWorkbook();EscherBSERecord bse = iwb.getBSERecord(getPictureIndex());byte[] data = bse.getBlipRecord().getPicturedata();int type = bse.getBlipTypeWin32();return ImageUtils.getImageDimension(new ByteArrayInputStream(data), type);}\n",
        "output": "public Size GetImageDimension(){InternalWorkbook iwb = (_patriarch.Sheet.Workbook as HSSFWorkbook).Workbook;EscherBSERecord bse = iwb.GetBSERecord(PictureIndex);byte[] data = bse.BlipRecord.PictureData;using (MemoryStream ms = new MemoryStream(data)){using (Image img = Image.FromStream(ms)){return img.Size;}}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public static double var(double[] v) {double r = Double.NaN;if (v!=null && v.length > 1) {r = devsq(v) / (v.length - 1);}return r;}\n",
        "output": "public static double var(double[] v){double r = Double.NaN;if (v != null && v.Length > 1){r = devsq(v) / (v.Length - 1);}return r;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public UpdateCloudFrontOriginAccessIdentityRequest(CloudFrontOriginAccessIdentityConfig cloudFrontOriginAccessIdentityConfig, String id, String ifMatch) {setCloudFrontOriginAccessIdentityConfig(cloudFrontOriginAccessIdentityConfig);setId(id);setIfMatch(ifMatch);}\n",
        "output": "public UpdateCloudFrontOriginAccessIdentityRequest(string id, string ifMatch, CloudFrontOriginAccessIdentityConfig cloudFrontOriginAccessIdentityConfig){_id = id;_ifMatch = ifMatch;_cloudFrontOriginAccessIdentityConfig = cloudFrontOriginAccessIdentityConfig;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DiffCommand setDestinationPrefix(String destinationPrefix) {this.destinationPrefix = destinationPrefix;return this;}\n",
        "output": "public virtual NGit.Api.DiffCommand SetDestinationPrefix(string destinationPrefix){this.destinationPrefix = destinationPrefix;return this;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public int available() throws IOException {return IoBridge.available(fd);}\n",
        "output": "public override int available(){throw new System.NotImplementedException();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "final public SrndQuery NotQuery() throws ParseException {SrndQuery q;ArrayList<SrndQuery> queries = null;Token oprt = null;q = NQuery();label_4:while (true) {switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {case NOT:;break;default:jj_la1[2] = jj_gen;break label_4;}oprt = jj_consume_token(NOT);if (queries == null) {queries = new ArrayList<SrndQuery>();queries.add(q);}q = NQuery();queries.add(q);}{if (true) return (queries == null) ? q : getNotQuery(queries, oprt);}throw new Error(\"Missing return statement in function\");}\n",
        "output": "public SrndQuery NotQuery(){SrndQuery q;IList<SrndQuery> queries = null;Token oprt = null;q = NQuery();while (true){switch ((jj_ntk == -1) ? Jj_ntk() : jj_ntk){case RegexpToken.NOT:;break;default:jj_la1[2] = jj_gen;goto label_4;}oprt = Jj_consume_token(RegexpToken.NOT);if (queries == null){queries = new List<SrndQuery>();queries.Add(q);}q = NQuery();queries.Add(q);}label_4:{ if (true) return (queries == null) ? q : GetNotQuery(queries, oprt); }throw new Exception(\"Missing return statement in function\");}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String toString() {StringBuilder sb = new StringBuilder();sb.append('[').append(\"USERSVIEWEND\").append(\"] (0x\");sb.append(Integer.toHexString(sid).toUpperCase(Locale.ROOT)).append(\")\\n\");sb.append(\"  rawData=\").append(HexDump.toHex(_rawData)).append(\"\\n\");sb.append(\"[/\").append(\"USERSVIEWEND\").append(\"]\\n\");return sb.toString();}\n",
        "output": "public override String ToString(){StringBuilder sb = new StringBuilder();sb.Append(\"[\").Append(\"USERSVIEWEND\").Append(\"] (0x\");sb.Append(StringUtil.ToHexString(sid).ToUpper() + \")\\n\");sb.Append(\"  rawData=\").Append(HexDump.ToHex(_rawData)).Append(\"\\n\");sb.Append(\"[/\").Append(\"USERSVIEWEND\").Append(\"]\\n\");return sb.ToString();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public FloatBuffer asReadOnlyBuffer() {FloatToByteBufferAdapter buf = new FloatToByteBufferAdapter(byteBuffer.asReadOnlyBuffer());buf.limit = limit;buf.position = position;buf.mark = mark;buf.byteBuffer.order = byteBuffer.order;return buf;}\n",
        "output": "public override java.nio.FloatBuffer asReadOnlyBuffer(){java.nio.FloatToByteBufferAdapter buf = new java.nio.FloatToByteBufferAdapter(byteBuffer.asReadOnlyBuffer());buf._limit = _limit;buf._position = _position;buf._mark = _mark;buf.byteBuffer._order = byteBuffer._order;return buf;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public LogCommand log() {return new LogCommand(repo);}\n",
        "output": "public virtual LogCommand Log(){return new LogCommand(repo);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CreateDomainResult createDomain(CreateDomainRequest request) {request = beforeClientExecution(request);return executeCreateDomain(request);}\n",
        "output": "public virtual CreateDomainResponse CreateDomain(CreateDomainRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateDomainRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateDomainResponseUnmarshaller.Instance;return Invoke<CreateDomainResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public int getWeight() {return WEIGHT_UNKNOWN;}\n",
        "output": "public virtual int GetWeight(){return WEIGHT_UNKNOWN;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ChartStartObjectRecord(RecordInputStream in) {rt = in.readShort();grbitFrt = in.readShort();iObjectKind = in.readShort();iObjectContext = in.readShort();iObjectInstance1 = in.readShort();iObjectInstance2 = in.readShort();}\n",
        "output": "public ChartStartObjectRecord(RecordInputStream in1){rt = in1.ReadShort();grbitFrt = in1.ReadShort();iObjectKind = in1.ReadShort();iObjectContext = in1.ReadShort();iObjectInstance1 = in1.ReadShort();iObjectInstance2 = in1.ReadShort();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void remove() {if (lastReturned == null)throw new IllegalStateException();ConcurrentHashMap.this.remove(lastReturned.key);lastReturned = null;}\n",
        "output": "public virtual void remove(){if (this.lastEntryReturned == null){throw new System.InvalidOperationException();}if (this._enclosing.modCount != this.expectedModCount){throw new java.util.ConcurrentModificationException();}this._enclosing.remove(this.lastEntryReturned.key);this.lastEntryReturned = null;this.expectedModCount = this._enclosing.modCount;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeMetricCollectionTypesResult describeMetricCollectionTypes(DescribeMetricCollectionTypesRequest request) {request = beforeClientExecution(request);return executeDescribeMetricCollectionTypes(request);}\n",
        "output": "public virtual DescribeMetricCollectionTypesResponse DescribeMetricCollectionTypes(DescribeMetricCollectionTypesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeMetricCollectionTypesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeMetricCollectionTypesResponseUnmarshaller.Instance;return Invoke<DescribeMetricCollectionTypesResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public UpdateFieldLevelEncryptionProfileResult updateFieldLevelEncryptionProfile(UpdateFieldLevelEncryptionProfileRequest request) {request = beforeClientExecution(request);return executeUpdateFieldLevelEncryptionProfile(request);}\n",
        "output": "public virtual UpdateFieldLevelEncryptionProfileResponse UpdateFieldLevelEncryptionProfile(UpdateFieldLevelEncryptionProfileRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateFieldLevelEncryptionProfileRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateFieldLevelEncryptionProfileResponseUnmarshaller.Instance;return Invoke<UpdateFieldLevelEncryptionProfileResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public Ref getLeaf() {return this;}\n",
        "output": "public virtual Ref GetLeaf(){return this;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public int lastIndexOf(Object object) {if (object != null) {for (int i = a.length - 1; i >= 0; i--) {if (object.equals(a[i])) {return i;}}} else {for (int i = a.length - 1; i >= 0; i--) {if (a[i] == null) {return i;}}}return -1;}\n",
        "output": "public override int lastIndexOf(object @object){if (@object != null){{for (int i = a.Length - 1; i >= 0; i--){if (@object.Equals(a[i])){return i;}}}}else{{for (int i = a.Length - 1; i >= 0; i--){if ((object)a[i] == null){return i;}}}}return -1;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DefaultBulkScorer(Scorer scorer) {if (scorer == null) {throw new NullPointerException();}this.scorer = scorer;this.iterator = scorer.iterator();this.twoPhase = scorer.twoPhaseIterator();}\n",
        "output": "public DefaultBulkScorer(Scorer scorer){if (scorer == null){throw new System.NullReferenceException();}this.scorer = scorer;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CreateRepoAuthorizationRequest() {super(\"cr\", \"2016-06-07\", \"CreateRepoAuthorization\", \"cr\");setUriPattern(\"/repos/[RepoNamespace]/[RepoName]/authorizations\");setMethod(MethodType.PUT);}\n",
        "output": "public CreateRepoAuthorizationRequest(): base(\"cr\", \"2016-06-07\", \"CreateRepoAuthorization\", \"cr\", \"openAPI\"){UriPattern = \"/repos/[RepoNamespace]/[RepoName]/authorizations\";Method = MethodType.PUT;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public TokenStream create(TokenStream input) {return new PortugueseLightStemFilter(input);}\n",
        "output": "public override TokenStream Create(TokenStream input){return new PortugueseLightStemFilter(input);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String toString() {StringBuilder buffer = new StringBuilder();buffer.append(\"[TABLESTYLES]\\n\");buffer.append(\"    .rt      =\").append(HexDump.shortToHex(rt)).append('\\n');buffer.append(\"    .grbitFrt=\").append(HexDump.shortToHex(grbitFrt)).append('\\n');buffer.append(\"    .unused  =\").append(HexDump.toHex(unused)).append('\\n');buffer.append(\"    .cts=\").append(HexDump.intToHex(cts)).append('\\n');buffer.append(\"    .rgchDefListStyle=\").append(rgchDefListStyle).append('\\n');buffer.append(\"    .rgchDefPivotStyle=\").append(rgchDefPivotStyle).append('\\n');buffer.append(\"[/TABLESTYLES]\\n\");return buffer.toString();}\n",
        "output": "public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append(\"[TABLESTYLES]\\n\");buffer.Append(\"    .rt      =\").Append(HexDump.ShortToHex(rt)).Append('\\n');buffer.Append(\"    .grbitFrt=\").Append(HexDump.ShortToHex(grbitFrt)).Append('\\n');buffer.Append(\"    .unused  =\").Append(HexDump.ToHex(unused)).Append('\\n');buffer.Append(\"    .cts=\").Append(HexDump.IntToHex(cts)).Append('\\n');buffer.Append(\"    .rgchDefListStyle=\").Append(rgchDefListStyle).Append('\\n');buffer.Append(\"    .rgchDefPivotStyle=\").Append(rgchDefPivotStyle).Append('\\n');buffer.Append(\"[/TABLESTYLES]\\n\");return buffer.ToString();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public synchronized Enumeration<K> keys() {return new KeyEnumeration();}\n",
        "output": "public override java.util.Enumeration<K> keys(){lock (this){return new java.util.Hashtable<K, V>.KeyEnumeration(this);}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeInstanceTypesResult describeInstanceTypes(DescribeInstanceTypesRequest request) {request = beforeClientExecution(request);return executeDescribeInstanceTypes(request);}\n",
        "output": "public virtual DescribeInstanceTypesResponse DescribeInstanceTypes(DescribeInstanceTypesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeInstanceTypesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeInstanceTypesResponseUnmarshaller.Instance;return Invoke<DescribeInstanceTypesResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public RefUpdate.Result getResult() {return rc;}\n",
        "output": "public virtual RefUpdate.Result GetResult(){return rc;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public UpdateBasePathMappingResult updateBasePathMapping(UpdateBasePathMappingRequest request) {request = beforeClientExecution(request);return executeUpdateBasePathMapping(request);}\n",
        "output": "public virtual UpdateBasePathMappingResponse UpdateBasePathMapping(UpdateBasePathMappingRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateBasePathMappingRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateBasePathMappingResponseUnmarshaller.Instance;return Invoke<UpdateBasePathMappingResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public UpdateDocumentResult updateDocument(UpdateDocumentRequest request) {request = beforeClientExecution(request);return executeUpdateDocument(request);}\n",
        "output": "public virtual UpdateDocumentResponse UpdateDocument(UpdateDocumentRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateDocumentRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateDocumentResponseUnmarshaller.Instance;return Invoke<UpdateDocumentResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void setStreamFileThreshold(int newLimit) {streamFileThreshold = newLimit;}\n",
        "output": "public virtual void SetStreamFileThreshold(int newLimit){streamFileThreshold = newLimit;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String toString() {StringBuilder buffer = new StringBuilder();buffer.append(\"[EXTSST]\\n\");buffer.append(\"    .dsst           = \").append(Integer.toHexString(_stringsPerBucket)).append(\"\\n\");buffer.append(\"    .numInfoRecords = \").append(_sstInfos.length).append(\"\\n\");for (int k = 0; k < _sstInfos.length; k++){buffer.append(\"    .inforecord     = \").append(k).append(\"\\n\");buffer.append(\"    .streampos      = \").append(Integer.toHexString(_sstInfos[k].getStreamPos())).append(\"\\n\");buffer.append(\"    .sstoffset      = \").append(Integer.toHexString(_sstInfos[k].getBucketSSTOffset())).append(\"\\n\");}buffer.append(\"[/EXTSST]\\n\");return buffer.toString();}\n",
        "output": "public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append(\"[EXTSST]\\n\");buffer.Append(\"    .streampos      = \").Append(StringUtil.ToHexString(StreamPos)).Append(\"\\n\");buffer.Append(\"    .bucketsstoffset= \").Append(StringUtil.ToHexString(BucketSSTOffset)).Append(\"\\n\");buffer.Append(\"    .zero           = \").Append(StringUtil.ToHexString(field_3_zero)).Append(\"\\n\");buffer.Append(\"[/EXTSST]\\n\");return buffer.ToString();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void setCRC(int crc) {this.crc = crc;}\n",
        "output": "public virtual void SetCRC(int crc){this.crc = crc;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public RevFilter getRevFilter() {return filter;}\n",
        "output": "public virtual RevFilter GetRevFilter(){return filter;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public SrndPrefixQuery(String prefix, boolean quoted, char truncator) {super(quoted);this.prefix = prefix;prefixRef = new BytesRef(prefix);this.truncator = truncator;}\n",
        "output": "public SrndPrefixQuery(string prefix, bool quoted, char truncator): base(quoted){this.prefix = prefix;prefixRef = new BytesRef(prefix);this.truncator = truncator;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public byte readByte() throws IOException {int v = is.read();if (v == -1) throw new EOFException();return (byte) v;}\n",
        "output": "public override byte ReadByte(){int v = _reader.ReadByte();if (v == -1){throw new EndOfStreamException();}return (byte)v;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public GetWorkGroupResult getWorkGroup(GetWorkGroupRequest request) {request = beforeClientExecution(request);return executeGetWorkGroup(request);}\n",
        "output": "public virtual GetWorkGroupResponse GetWorkGroup(GetWorkGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetWorkGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = GetWorkGroupResponseUnmarshaller.Instance;return Invoke<GetWorkGroupResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public PutBlockPublicAccessConfigurationResult putBlockPublicAccessConfiguration(PutBlockPublicAccessConfigurationRequest request) {request = beforeClientExecution(request);return executePutBlockPublicAccessConfiguration(request);}\n",
        "output": "public virtual PutBlockPublicAccessConfigurationResponse PutBlockPublicAccessConfiguration(PutBlockPublicAccessConfigurationRequest request){var options = new InvokeOptions();options.RequestMarshaller = PutBlockPublicAccessConfigurationRequestMarshaller.Instance;options.ResponseUnmarshaller = PutBlockPublicAccessConfigurationResponseUnmarshaller.Instance;return Invoke<PutBlockPublicAccessConfigurationResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public String toString() {final StringBuilder r = new StringBuilder();r.append('[');for (int i = 0; i < count; i++) {if (i > 0)r.append(\", \"); r.append(entries[i]);}r.append(']');return r.toString();}\n",
        "output": "public override string ToString(){StringBuilder r = new StringBuilder();r.Append('[');for (int i = 0; i < count; i++){if (i > 0){r.Append(\", \");}r.Append(entries[i]);}r.Append(']');return r.ToString();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public int get(int index) {checkIndex(index);return byteBuffer.getInt(index * SizeOf.INT);}\n",
        "output": "public override int get(int index){checkIndex(index);return byteBuffer.getInt(index * libcore.io.SizeOf.INT);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public CreateAlbumRequest() {super(\"CloudPhoto\", \"2017-07-11\", \"CreateAlbum\", \"cloudphoto\");setProtocol(ProtocolType.HTTPS);}\n",
        "output": "public CreateAlbumRequest(): base(\"CloudPhoto\", \"2017-07-11\", \"CreateAlbum\", \"cloudphoto\", \"openAPI\"){Protocol = ProtocolType.HTTPS;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public FileTreeIterator(File root, FS fs, WorkingTreeOptions options) {this(root, fs, options, DefaultFileModeStrategy.INSTANCE);}\n",
        "output": "public FileTreeIterator(FilePath root, FS fs, WorkingTreeOptions options) : base(options){directory = root;this.fs = fs;Init(Entries());}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public int byteAt(int idx) {return bytes[idx].value;}\n",
        "output": "public virtual int ByteAt(int idx){return bytes[idx].Value;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeTypeRegistrationResult describeTypeRegistration(DescribeTypeRegistrationRequest request) {request = beforeClientExecution(request);return executeDescribeTypeRegistration(request);}\n",
        "output": "public virtual DescribeTypeRegistrationResponse DescribeTypeRegistration(DescribeTypeRegistrationRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeTypeRegistrationRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeTypeRegistrationResponseUnmarshaller.Instance;return Invoke<DescribeTypeRegistrationResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public TerminateInstancesResult terminateInstances(TerminateInstancesRequest request) {request = beforeClientExecution(request);return executeTerminateInstances(request);}\n",
        "output": "public virtual TerminateInstancesResponse TerminateInstances(TerminateInstancesRequest request){var options = new InvokeOptions();options.RequestMarshaller = TerminateInstancesRequestMarshaller.Instance;options.ResponseUnmarshaller = TerminateInstancesResponseUnmarshaller.Instance;return Invoke<TerminateInstancesResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DoubleBuffer duplicate() {ByteBuffer bb = byteBuffer.duplicate().order(byteBuffer.order());DoubleToByteBufferAdapter buf = new DoubleToByteBufferAdapter(bb);buf.limit = limit;buf.position = position;buf.mark = mark;return buf;}\n",
        "output": "public override java.nio.DoubleBuffer duplicate(){java.nio.ByteBuffer bb = byteBuffer.duplicate().order(byteBuffer.order());java.nio.DoubleToByteBufferAdapter buf = new java.nio.DoubleToByteBufferAdapter(bb);buf._limit = _limit;buf._position = _position;buf._mark = _mark;return buf;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public OR(SemanticContext a, SemanticContext b) {Set<SemanticContext> operands = new HashSet<SemanticContext>();if ( a instanceof OR ) operands.addAll(Arrays.asList(((OR)a).opnds));else operands.add(a);if ( b instanceof OR ) operands.addAll(Arrays.asList(((OR)b).opnds));else operands.add(b);List<PrecedencePredicate> precedencePredicates = filterPrecedencePredicates(operands);if (!precedencePredicates.isEmpty()) {PrecedencePredicate reduced = Collections.max(precedencePredicates);operands.add(reduced);}this.opnds = operands.toArray(new SemanticContext[operands.size()]);}\n",
        "output": "public OR(SemanticContext a, SemanticContext b){HashSet<SemanticContext> operands = new HashSet<SemanticContext>();if (a is SemanticContext.OR){operands.UnionWith(((OR)a).opnds);}else{operands.Add(a);}if (b is SemanticContext.OR){operands.UnionWith(((OR)b).opnds);}else{operands.Add(b);}IList<SemanticContext.PrecedencePredicate> precedencePredicates = FilterPrecedencePredicates(operands);if (precedencePredicates.Count > 0){SemanticContext.PrecedencePredicate reduced = precedencePredicates.Max();operands.Add(reduced);}this.opnds = operands.ToArray();}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public void serialize(LittleEndianOutput out) {out.writeShort(_formats.length);for(int i=0; i<_formats.length; i++){_formats[i].serialize(out);}}\n",
        "output": "public override void Serialize(ILittleEndianOutput out1){out1.WriteShort(m_formats.Count);for (int i = 0; i < m_formats.Count; i++){((CTFormat)m_formats[i]).Serialize(out1);}}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DescribeAvailabilityOptionsResult describeAvailabilityOptions(DescribeAvailabilityOptionsRequest request) {request = beforeClientExecution(request);return executeDescribeAvailabilityOptions(request);}\n",
        "output": "public virtual DescribeAvailabilityOptionsResponse DescribeAvailabilityOptions(DescribeAvailabilityOptionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeAvailabilityOptionsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeAvailabilityOptionsResponseUnmarshaller.Instance;return Invoke<DescribeAvailabilityOptionsResponse>(request, options);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public int getOffset() {return offset;}\n",
        "output": "public virtual int GetOffset(){return offset;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public static float[] grow(float[] array) {return grow(array, 1 + array.length);}\n",
        "output": "public static float[] Grow(float[] array){return Grow(array, 1 + array.Length);}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public ListMetricsResult listMetrics() {return listMetrics(new ListMetricsRequest());}\n",
        "output": "public virtual ListMetricsResponse ListMetrics(){return ListMetrics(new ListMetricsRequest());}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public int findFirstRecordLocBySid(short sid) {int index = 0;for (org.apache.poi.hssf.record.Record record : records.getRecords() ) {if (record.getSid() == sid) {return index;}index ++;}return -1;}\n",
        "output": "public int FindFirstRecordLocBySid(short sid){int index = 0;for (IEnumerator iterator = records.GetEnumerator(); iterator.MoveNext(); ){Record record = (Record)iterator.Current;if (record.Sid == sid){return index;}index++;}return -1;}\n"
    },
    {
        "instruction": "Translate the following Java code to C#:",
        "input": "public DeleteVpnConnectionRouteResult deleteVpnConnectionRoute(DeleteVpnConnectionRouteRequest request) {request = beforeClientExecution(request);return executeDeleteVpnConnectionRoute(request);}\n",
        "output": "public virtual DeleteVpnConnectionRouteResponse DeleteVpnConnectionRoute(DeleteVpnConnectionRouteRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteVpnConnectionRouteRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteVpnConnectionRouteResponseUnmarshaller.Instance;return Invoke<DeleteVpnConnectionRouteResponse>(request, options);}\n"
    }
]