yijunyu/c-to-rust huggingface dataset:
// Original:
public CherryPickCommand include(String name, AnyObjectId commit) {return include(new ObjectIdRef.Unpeeled(Storage.LOOSE, name,commit.copy()));}

// Translation:
public virtual NGit.Api.CherryPickCommand Include(string name, AnyObjectId commit){return Include(new ObjectIdRef.Unpeeled(RefStorage.LOOSE, name, commit.Copy()));}
// Original:
public short getFormat(String format, boolean createIfNotFound) {for (FormatRecord r : formats) {if (r.getFormatString().equals(format)) {return (short)r.getIndexCode();}}if (createIfNotFound) {return (short)createFormat(format);}return -1;}

// Translation:
public short GetFormat(String format, bool CreateIfNotFound){IEnumerator iterator;for (iterator = formats.GetEnumerator(); iterator.MoveNext(); ){FormatRecord r = (FormatRecord)iterator.Current;if (r.FormatString.Equals(format)){return (short)r.IndexCode;}}if (CreateIfNotFound){return (short)CreateFormat(format);}return -1;}
// Original:
public SpanNearQuery build() {return new SpanNearQuery(clauses.toArray(new SpanQuery[clauses.size()]), slop, ordered);}

// Translation:
public CompositeReaderContext Build(){return (CompositeReaderContext)Build(null, reader, 0, 0);}
// Original:
public int getRowCellBlockSize(int startRow, int endRow) {int result = 0;for(int rowIx=startRow; rowIx<=endRow && rowIx<records.length; rowIx++) {result += getRowSerializedSize(records[rowIx]);}return result;}

// Translation:
public int GetRowCellBlockSize(int startRow, int endRow){MyEnumerator itr = new MyEnumerator(ref records,startRow, endRow);int size = 0;while (itr.MoveNext()){CellValueRecordInterface cell = (CellValueRecordInterface)itr.Current;int row = cell.Row;if (row > endRow)break;if ((row >= startRow) && (row <= endRow))size += ((RecordBase)cell).RecordSize;}return size;}
// Original:
public final boolean incrementToken() {if (!it.hasNext()) {return false;}AttributeSource.State state = it.next();restoreState(state);return true;}

// Translation:
public override sealed bool IncrementToken(){if (it == null){it = cachedStates.GetEnumerator();}if (!it.MoveNext())return false;var state = it.Current;RestoreState(state);return true;}
// Original:
public DeleteTemplateResult deleteTemplate(DeleteTemplateRequest request) {request = beforeClientExecution(request);return executeDeleteTemplate(request);}

// Translation:
public virtual DeleteTemplateResponse DeleteTemplate(DeleteTemplateRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteTemplateRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteTemplateResponseUnmarshaller.Instance;return Invoke<DeleteTemplateResponse>(request, options);}
// Original:
public StartFaceSearchResult startFaceSearch(StartFaceSearchRequest request) {request = beforeClientExecution(request);return executeStartFaceSearch(request);}

// Translation:
public virtual StartFaceSearchResponse StartFaceSearch(StartFaceSearchRequest request){var options = new InvokeOptions();options.RequestMarshaller = StartFaceSearchRequestMarshaller.Instance;options.ResponseUnmarshaller = StartFaceSearchResponseUnmarshaller.Instance;return Invoke<StartFaceSearchResponse>(request, options);}
// Original:
public static int formatBase10(final byte[] b, int o, int value) {if (value == 0) {b[--o] = '0';return o;}final boolean isneg = value < 0;if (isneg)value = -value;while (value != 0) {b[--o] = base10byte[value % 10];value /= 10;}if (isneg)b[--o] = '-';return o;}

// Translation:
public static int FormatBase10(byte[] b, int o, int value){if (value == 0){b[--o] = (byte)('0');return o;}bool isneg = value < 0;if (isneg){value = -value;}while (value != 0){b[--o] = base10byte[value % 10];value /= 10;}if (isneg){b[--o] = (byte)('-');}return o;}
// Original:
public String toString(){StringBuilder buffer = new StringBuilder();buffer.append("[SINDEX]\n");buffer.append("    .index                = ").append("0x").append(HexDump.toHex(  getIndex ())).append(" (").append( getIndex() ).append(" )");buffer.append(System.getProperty("line.separator"));buffer.append("[/SINDEX]\n");return buffer.toString();}

// Translation:
public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append("[SINDEX]\n");buffer.Append("    .index                = ").Append("0x").Append(HexDump.ToHex(Index)).Append(" (").Append(Index).Append(" )");buffer.Append(Environment.NewLine);buffer.Append("[/SINDEX]\n");return buffer.ToString();}
// Original:
public DescribeDBSecurityGroupsResult describeDBSecurityGroups(DescribeDBSecurityGroupsRequest request) {request = beforeClientExecution(request);return executeDescribeDBSecurityGroups(request);}

// Translation:
public virtual DescribeDBSecurityGroupsResponse DescribeDBSecurityGroups(DescribeDBSecurityGroupsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeDBSecurityGroupsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeDBSecurityGroupsResponseUnmarshaller.Instance;return Invoke<DescribeDBSecurityGroupsResponse>(request, options);}
// Original:
public DeleteTrafficMirrorSessionResult deleteTrafficMirrorSession(DeleteTrafficMirrorSessionRequest request) {request = beforeClientExecution(request);return executeDeleteTrafficMirrorSession(request);}

// Translation:
public virtual DeleteTrafficMirrorSessionResponse DeleteTrafficMirrorSession(DeleteTrafficMirrorSessionRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteTrafficMirrorSessionRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteTrafficMirrorSessionResponseUnmarshaller.Instance;return Invoke<DeleteTrafficMirrorSessionResponse>(request, options);}
// Original:
public void stopWalk() {final int cur = ptr;final int cnt = cache.getEntryCount();if (cur < cnt)builder.keep(cur, cnt - cur);}

// Translation:
public override void StopWalk(){int cur = ptr;int cnt = cache.GetEntryCount();if (cur < cnt){builder.Keep(cur, cnt - cur);}}
// Original:
public ExpandedDouble normaliseBaseTwo() {MutableFPNumber cc = new MutableFPNumber(composeFrac(), 39);cc.multiplyByPowerOfTen(_relativeDecimalExponent);cc.normalise64bit();return cc.createExpandedDouble();}

// Translation:
public ExpandedDouble NormaliseBaseTwo(){MutableFPNumber cc = new MutableFPNumber(ComposeFrac(), 39);cc.multiplyByPowerOfTen(_relativeDecimalExponent);cc.Normalise64bit();return cc.CreateExpandedDouble();}
// Original:
public PutLexiconResult putLexicon(PutLexiconRequest request) {request = beforeClientExecution(request);return executePutLexicon(request);}

// Translation:
public virtual PutLexiconResponse PutLexicon(PutLexiconRequest request){var options = new InvokeOptions();options.RequestMarshaller = PutLexiconRequestMarshaller.Instance;options.ResponseUnmarshaller = PutLexiconResponseUnmarshaller.Instance;return Invoke<PutLexiconResponse>(request, options);}
// Original:
public int[] init() {if (perField.postingsArray == null) {perField.postingsArray = perField.createPostingsArray(2);perField.newPostingsArray();bytesUsed.addAndGet(perField.postingsArray.size * perField.postingsArray.bytesPerPosting());}return perField.postingsArray.textStarts;}

// Translation:
public override int[] Init(){if (perField.postingsArray == null){perField.postingsArray = perField.consumer.CreatePostingsArray(2);bytesUsed.AddAndGet(perField.postingsArray.size * perField.postingsArray.BytesPerPosting());}return perField.postingsArray.textStarts;}
// Original:
public DirCacheEntry getDirCacheEntry() {return entry;}

// Translation:
public virtual DirCacheEntry GetDirCacheEntry(){return entry;}
// Original:
public boolean include(TreeWalk walker) {return matchFilter(walker) <= 0;}

// Translation:
public override bool Include(TreeWalk walker){return walker.IsPathPrefix(pathRaw, pathRaw.Length) == 0;}
// Original:
public void open(String closer) {if (closer == null) {throw new NullPointerException("closer == null");}if (this == NOOP || !ENABLED) {return;}String message = "Explicit termination method '" + closer + "' not called";allocationSite = new Throwable(message);}

// Translation:
public void open(string closer){if (closer == null){throw new System.ArgumentNullException("closer == null");}if (this == NOOP || !ENABLED){return;}string message = "Explicit termination method '" + closer + "' not called";allocationSite = new System.Exception(message);}
// Original:
public List<ParseTreeMatch> findAll(ParseTree tree, String xpath) {Collection<ParseTree> subtrees = XPath.findAll(tree, xpath, matcher.getParser());List<ParseTreeMatch> matches = new ArrayList<ParseTreeMatch>();for (ParseTree t : subtrees) {ParseTreeMatch match = match(t);if ( match.succeeded() ) {matches.add(match);}}return matches;}

// Translation:
public virtual IList<ParseTreeMatch> FindAll(IParseTree tree, string xpath){ICollection<IParseTree> subtrees = XPath.FindAll(tree, xpath, matcher.Parser);IList<ParseTreeMatch> matches = new List<ParseTreeMatch>();foreach (IParseTree t in subtrees){ParseTreeMatch match = Match(t);if (match.Succeeded){matches.Add(match);}}return matches;}
// Original:
public static boolean hasSLLConflictTerminatingPrediction(PredictionMode mode, ATNConfigSet configs) {if (allConfigsInRuleStopStates(configs)) {return true;}if ( mode == PredictionMode.SLL ) {if ( configs.hasSemanticContext ) {ATNConfigSet dup = new ATNConfigSet();for (ATNConfig c : configs) {c = new ATNConfig(c,SemanticContext.NONE);dup.add(c);}configs = dup;}}Collection<BitSet> altsets = getConflictingAltSubsets(configs);boolean heuristic =hasConflictingAltSet(altsets) && !hasStateAssociatedWithOneAlt(configs);return heuristic;}

// Translation:
public static bool HasSLLConflictTerminatingPrediction(PredictionMode mode, ATNConfigSet configSet){if (AllConfigsInRuleStopStates(configSet.configs)){return true;}if (mode == PredictionMode.SLL){if (configSet.hasSemanticContext){ATNConfigSet dup = new ATNConfigSet();foreach (ATNConfig c in configSet.configs){dup.Add(new ATNConfig(c, SemanticContext.NONE));}configSet = dup;}}ICollection<BitSet> altsets = GetConflictingAltSubsets(configSet.configs);bool heuristic = HasConflictingAltSet(altsets) && !HasStateAssociatedWithOneAlt(configSet.configs);return heuristic;}
// Original:
public DescribeUpdateActionsResult describeUpdateActions(DescribeUpdateActionsRequest request) {request = beforeClientExecution(request);return executeDescribeUpdateActions(request);}

// Translation:
public virtual DescribeUpdateActionsResponse DescribeUpdateActions(DescribeUpdateActionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeUpdateActionsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeUpdateActionsResponseUnmarshaller.Instance;return Invoke<DescribeUpdateActionsResponse>(request, options);}
// Original:
public HashMap() {table = (HashMapEntry<K, V>[]) EMPTY_TABLE;threshold = -1; }

// Translation:
public HashMap(){table = (java.util.HashMap.HashMapEntry<K, V>[])EMPTY_TABLE;threshold = -1;}
// Original:
public Trie optimize(Trie orig) {List<CharSequence> cmds = orig.cmds;List<Row> rows = new ArrayList<>();List<Row> orows = orig.rows;int remap[] = new int[orows.size()];Arrays.fill(remap, -1);rows = removeGaps(orig.root, rows, new ArrayList<Row>(), remap);return new Trie(orig.forward, remap[orig.root], cmds, rows);}

// Translation:
public virtual Trie Optimize(Trie orig){IList<string> cmds = orig.cmds;IList<Row> rows = new List<Row>();IList<Row> orows = orig.rows;int[] remap = new int[orows.Count];Arrays.Fill(remap, -1);rows = RemoveGaps(orig.root, rows, new List<Row>(), remap);return new Trie(orig.forward, remap[orig.root], cmds, rows);}
// Original:
public CreateLifecyclePolicyResult createLifecyclePolicy(CreateLifecyclePolicyRequest request) {request = beforeClientExecution(request);return executeCreateLifecyclePolicy(request);}

// Translation:
public virtual CreateLifecyclePolicyResponse CreateLifecyclePolicy(CreateLifecyclePolicyRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateLifecyclePolicyRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateLifecyclePolicyResponseUnmarshaller.Instance;return Invoke<CreateLifecyclePolicyResponse>(request, options);}
// Original:
public void writeLong(long v) {writeInt((int)(v));writeInt((int)(v >> 32));}

// Translation:
public void WriteLong(long v){WriteInt((int)(v >> 0));WriteInt((int)(v >> 32));}
// Original:
public void set(char[] arr, int end) {this.buf = arr;this.len = end;}

// Translation:
public virtual void Set(char[] arr, int end){this.m_buf = arr;this.m_len = end;}
// Original:
public HMMChineseTokenizerFactory(Map<String,String> args) {super(args);if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

// Translation:
public HMMChineseTokenizerFactory(IDictionary<string, string> args): base(args){if (args.Any()){throw new ArgumentException("Unknown parameters: " + args);}}
// Original:
public String toString() {return getClass().getSimpleName()+" field:"+fieldName+" ctx="+ctx;}

// Translation:
public override string ToString(){return GetType().Name + " field:" + fieldName + " ctx=" + m_ctx;}
// Original:
public ResendContactReachabilityEmailResult resendContactReachabilityEmail(ResendContactReachabilityEmailRequest request) {request = beforeClientExecution(request);return executeResendContactReachabilityEmail(request);}

// Translation:
public virtual ResendContactReachabilityEmailResponse ResendContactReachabilityEmail(ResendContactReachabilityEmailRequest request){var options = new InvokeOptions();options.RequestMarshaller = ResendContactReachabilityEmailRequestMarshaller.Instance;options.ResponseUnmarshaller = ResendContactReachabilityEmailResponseUnmarshaller.Instance;return Invoke<ResendContactReachabilityEmailResponse>(request, options);}
// Original:
public GetApiKeyResult getApiKey(GetApiKeyRequest request) {request = beforeClientExecution(request);return executeGetApiKey(request);}

// Translation:
public virtual GetApiKeyResponse GetApiKey(GetApiKeyRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetApiKeyRequestMarshaller.Instance;options.ResponseUnmarshaller = GetApiKeyResponseUnmarshaller.Instance;return Invoke<GetApiKeyResponse>(request, options);}
// Original:
public void advance() {previousValue = value;if (value == 1) {value = minShingleSize;} else if (value == maxShingleSize) {reset();} else {++value;}}

// Translation:
public virtual void Advance(){previousValue = value;if (value == 1){value = outerInstance.minShingleSize;}else if (value == outerInstance.maxShingleSize){Reset();}else{++value;}}
// Original:
public int addConditionalFormatting(CellRangeAddress[] regions,ConditionalFormattingRule rule1) {return addConditionalFormatting(regions,  (HSSFConditionalFormattingRule)rule1);}

// Translation:
public int AddConditionalFormatting(CellRangeAddress[] regions,HSSFConditionalFormattingRule rule1){return AddConditionalFormatting(regions,rule1 == null ? null : new HSSFConditionalFormattingRule[]{rule1});}
// Original:
public RebaseCommand setUpstream(RevCommit upstream) {this.upstreamCommit = upstream;this.upstreamCommitName = upstream.name();return this;}

// Translation:
public virtual NGit.Api.RebaseCommand SetUpstream(RevCommit upstream){this.upstreamCommit = upstream;this.upstreamCommitName = upstream.Name;return this;}
// Original:
public GetDocumentTextDetectionResult getDocumentTextDetection(GetDocumentTextDetectionRequest request) {request = beforeClientExecution(request);return executeGetDocumentTextDetection(request);}

// Translation:
public virtual GetDocumentTextDetectionResponse GetDocumentTextDetection(GetDocumentTextDetectionRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetDocumentTextDetectionRequestMarshaller.Instance;options.ResponseUnmarshaller = GetDocumentTextDetectionResponseUnmarshaller.Instance;return Invoke<GetDocumentTextDetectionResponse>(request, options);}
// Original:
public CreateDBSecurityGroupRequest(String dBSecurityGroupName, String dBSecurityGroupDescription) {setDBSecurityGroupName(dBSecurityGroupName);setDBSecurityGroupDescription(dBSecurityGroupDescription);}

// Translation:
public CreateDBSecurityGroupRequest(string dbSecurityGroupName, string dbSecurityGroupDescription){_dbSecurityGroupName = dbSecurityGroupName;_dbSecurityGroupDescription = dbSecurityGroupDescription;}
// Original:
public Reader create(Reader input) {return new ICUNormalizer2CharFilter(input, normalizer);}

// Translation:
public override TextReader Create(TextReader input){return new ICUNormalizer2CharFilter(input, normalizer);}
// Original:
static public double pmt(double r, int nper, double pv) {return pmt(r, nper, pv, 0);}

// Translation:
static public double PMT(double r, int nper, double pv){return PMT(r, nper, pv, 0);}
// Original:
public void set(String name, String value) throws Exception {if (valByRound.get(name) != null) {throw new Exception("Cannot modify a multi value property!");}props.setProperty(name, value);}

// Translation:
public virtual void Set(string name, string value){object temp;if (valByRound.TryGetValue(name, out temp) && temp != null){throw new Exception("Cannot modify a multi value property!");}props[name] = value;}
// Original:
public DescribeFastSnapshotRestoresResult describeFastSnapshotRestores(DescribeFastSnapshotRestoresRequest request) {request = beforeClientExecution(request);return executeDescribeFastSnapshotRestores(request);}

// Translation:
public virtual DescribeFastSnapshotRestoresResponse DescribeFastSnapshotRestores(DescribeFastSnapshotRestoresRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeFastSnapshotRestoresRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeFastSnapshotRestoresResponseUnmarshaller.Instance;return Invoke<DescribeFastSnapshotRestoresResponse>(request, options);}
// Original:
public DescribeScheduledInstanceAvailabilityResult describeScheduledInstanceAvailability(DescribeScheduledInstanceAvailabilityRequest request) {request = beforeClientExecution(request);return executeDescribeScheduledInstanceAvailability(request);}

// Translation:
public virtual DescribeScheduledInstanceAvailabilityResponse DescribeScheduledInstanceAvailability(DescribeScheduledInstanceAvailabilityRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeScheduledInstanceAvailabilityRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeScheduledInstanceAvailabilityResponseUnmarshaller.Instance;return Invoke<DescribeScheduledInstanceAvailabilityResponse>(request, options);}
// Original:
public SendBonusResult sendBonus(SendBonusRequest request) {request = beforeClientExecution(request);return executeSendBonus(request);}

// Translation:
public virtual SendBonusResponse SendBonus(SendBonusRequest request){var options = new InvokeOptions();options.RequestMarshaller = SendBonusRequestMarshaller.Instance;options.ResponseUnmarshaller = SendBonusResponseUnmarshaller.Instance;return Invoke<SendBonusResponse>(request, options);}
// Original:
public UnpackException(Throwable why) {super(JGitText.get().unpackException);initCause(why);}

// Translation:
public UnpackException(Exception why) : base(JGitText.Get().unpackException, why){Sharpen.Extensions.InitCause(this, why);}
// Original:
public boolean remove(Object o) {if (!(o instanceof Map.Entry))return false;Map.Entry<?,?> e = (Map.Entry<?,?>)o;return ConcurrentHashMap.this.remove(e.getKey(), e.getValue());}

// Translation:
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());}
// Original:
public Iterator<V> iterator() {return newValueIterator();}

// Translation:
public override java.util.Iterator<V> iterator(){return new java.util.Hashtable<K, V>.ValueIterator(this._enclosing);}
// Original:
public DescribeVpcEndpointServiceConfigurationsResult describeVpcEndpointServiceConfigurations(DescribeVpcEndpointServiceConfigurationsRequest request) {request = beforeClientExecution(request);return executeDescribeVpcEndpointServiceConfigurations(request);}

// Translation:
public virtual DescribeVpcEndpointServiceConfigurationsResponse DescribeVpcEndpointServiceConfigurations(DescribeVpcEndpointServiceConfigurationsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeVpcEndpointServiceConfigurationsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeVpcEndpointServiceConfigurationsResponseUnmarshaller.Instance;return Invoke<DescribeVpcEndpointServiceConfigurationsResponse>(request, options);}
// Original:
public void setDiffComparator(RawTextComparator cmp) {comparator = cmp;}

// Translation:
public virtual void SetDiffComparator(RawTextComparator cmp){comparator = cmp;}
// Original:
public FilePassRecord clone() {return copy();}

// Translation:
public override Object Clone(){return this;}
// Original:
public DeleteServiceResult deleteService(DeleteServiceRequest request) {request = beforeClientExecution(request);return executeDeleteService(request);}

// Translation:
public virtual DeleteServiceResponse DeleteService(DeleteServiceRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteServiceRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteServiceResponseUnmarshaller.Instance;return Invoke<DeleteServiceResponse>(request, options);}
// Original:
public FormulaRecord() {field_8_parsed_expr = Formula.create(Ptg.EMPTY_PTG_ARRAY);}

// Translation:
public FormulaRecord(){field_8_parsed_expr = NPOI.SS.Formula.Formula.Create(Ptg.EMPTY_PTG_ARRAY);}
// Original:
public DescribeHsmClientCertificatesResult describeHsmClientCertificates(DescribeHsmClientCertificatesRequest request) {request = beforeClientExecution(request);return executeDescribeHsmClientCertificates(request);}

// Translation:
public virtual DescribeHsmClientCertificatesResponse DescribeHsmClientCertificates(DescribeHsmClientCertificatesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeHsmClientCertificatesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeHsmClientCertificatesResponseUnmarshaller.Instance;return Invoke<DescribeHsmClientCertificatesResponse>(request, options);}
// Original:
public ICUTokenizerFactory(Map<String,String> args) {super(args);tailored = new HashMap<>();String rulefilesArg = get(args, RULEFILES);if (rulefilesArg != null) {List<String> scriptAndResourcePaths = splitFileNames(rulefilesArg);for (String scriptAndResourcePath : scriptAndResourcePaths) {int colonPos = scriptAndResourcePath.indexOf(":");String scriptCode = scriptAndResourcePath.substring(0, colonPos).trim();String resourcePath = scriptAndResourcePath.substring(colonPos+1).trim();tailored.put(UCharacter.getPropertyValueEnum(UProperty.SCRIPT, scriptCode), resourcePath);}}cjkAsWords = getBoolean(args, "cjkAsWords", true);myanmarAsWords = getBoolean(args, "myanmarAsWords", true);if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

// Translation:
public ICUTokenizerFactory(IDictionary<string, string> args): base(args){tailored = new Dictionary<int, string>();string rulefilesArg = Get(args, RULEFILES);if (rulefilesArg != null){IList<string> scriptAndResourcePaths = SplitFileNames(rulefilesArg);foreach (string scriptAndResourcePath in scriptAndResourcePaths){int colonPos = scriptAndResourcePath.IndexOf(':');string scriptCode = scriptAndResourcePath.Substring(0, colonPos - 0).Trim();string resourcePath = scriptAndResourcePath.Substring(colonPos + 1).Trim();tailored[UChar.GetPropertyValueEnum(UProperty.Script, scriptCode)] = resourcePath;}}cjkAsWords = GetBoolean(args, "cjkAsWords", true);myanmarAsWords = GetBoolean(args, "myanmarAsWords", true);if (args.Count != 0){throw new ArgumentException("Unknown parameters: " + args);}}