港交所收费项目繁多，按照如下逻辑计算税费：
        1. 税费比例为 0.11%，不足 1 元按 1 元记，四舍五入保留两位小数（包括印花税、交易征费、交易系统使用费）。
        2，五元固定费用（包括卖方收取的转手纸印花税、买方收取的过户费用）。
178471
def _get_tax(self, order_book_id, _, cost_money):
        
        instrument = Environment.get_instance().get_instrument(order_book_id)
        if instrument.type != 'CS':
            return 0
        tax = cost_money * self.tax_rate
        if tax < 1:
            tax = 1
        else:
            tax = round(tax, 2)
        return tax + 5
400574
public static function num2rmb($number = 0, $int_unit = '元', $is_round = true, $is_extra_zero = false)
    {
        // 将数字切分成两段
        $parts = explode('.', $number, 2);
        $int = isset($parts[0]) ? strval($parts[0]) : '0';
        $dec = isset($parts[1]) ? strval($parts[1]) : '';

        // 如果小数点后多于2位，不四舍五入就直接截，否则就处理
        $dec_len = strlen($dec);
        if (isset($parts[1]) && $dec_len > 2) {
            $dec = $is_round
                ? substr(strrchr(strval(round(floatval("0.".$dec), 2)), '.'), 1)
                : substr($parts[1], 0, 2);
        }

        // 当number为0.001时，小数点后的金额为0元
        if (empty($int) && empty($dec)) {
            return '零';
        }

        // 定义
        $chs = array('0','壹','贰','叁','肆','伍','陆','柒','捌','玖');
        $uni = array('','拾','佰','仟');
        $dec_uni = array('角', '分');
        $exp = array('', '万');
        $res = '';

        // 整数部分从右向左找
        for ($i = strlen($int) - 1, $k = 0; $i >= 0; $k++) {
            $str = '';
            // 按照中文读写习惯，每4个字为一段进行转化，i一直在减
            for ($j = 0; $j < 4 && $i >= 0; $j++, $i--) {
                $u = $int{$i} > 0 ? $uni[$j] : ''; // 非0的数字后面添加单位
                $str = $chs[$int{$i}] . $u . $str;
            }
            //echo $str."|".($k - 2)."<br>";
            $str = rtrim($str, '0');// 去掉末尾的0
            $str = preg_replace("/0+/", "零", $str); // 替换多个连续的0
            if (!isset($exp[$k])) {
                $exp[$k] = $exp[$k - 2] . '亿'; // 构建单位
            }
            $u2 = $str != '' ? $exp[$k] : '';
            $res = $str . $u2 . $res;
        }

        // 如果小数部分处理完之后是00，需要处理下
        $dec = rtrim($dec, '0');

        // 小数部分从左向右找
        if (!empty($dec)) {
            $res .= $int_unit;

            // 是否要在整数部分以0结尾的数字后附加0，有的系统有这要求
            if ($is_extra_zero) {
                if (substr($int, -1) === '0') {
                    $res.= '零';
                }
            }

            for ($i = 0, $cnt = strlen($dec); $i < $cnt; $i++) {
                $u = $dec{$i} > 0 ? $dec_uni[$i] : ''; // 非0的数字后面添加单位
                $res .= $chs[$dec{$i}] . $u;
            }
            $res = rtrim($res, '0');// 去掉末尾的0
            $res = preg_replace("/0+/", "零", $res); // 替换多个连续的0
        } else {
            $res .= $int_unit . '整';
        }
        return $res;
    }
1352284
function (val) {
            if (val === undefined || val === null) {
                return '';
            }
            //接收到的是raw包装的字符串，则不转义。If get an object with 'raw' property, no encode.
            if (val.$saker_raw$) {
                return val.str;
            }
            if (typeof val !== 'string') {
                return val;
            }
            var map = {
                '&': '&amp;',
                '<': '&lt;',
                '>': '&gt;',
                '"': '&quot;',
                "'": '&#039;'
            };

            return val.replace(/[&<>"']/g, function (m) {
                return map[m];
            });
        }
90025
private static int getProcessPiece() {
		// 进程码
		// 因为静态变量类加载可能相同,所以要获取进程ID + 加载对象的ID值
		final int processPiece;
		// 进程ID初始化
		int processId;
		try {
			// 获取进程ID
			final String processName =ManagementFactory.getRuntimeMXBean().getName();
			final int atIndex = processName.indexOf('@');
			if (atIndex > 0) {
				processId = Integer.parseInt(processName.substring(0, atIndex));
			} else {
				processId = processName.hashCode();
			}
		} catch (Throwable t) {
			processId = RandomUtil.randomInt();
		}

		final ClassLoader loader = ClassLoaderUtil.getClassLoader();
		// 返回对象哈希码,无论是否重写hashCode方法
		int loaderId = (loader != null) ? System.identityHashCode(loader) : 0;

		// 进程ID + 对象加载ID
		StringBuilder processSb = new StringBuilder();
		processSb.append(Integer.toHexString(processId));
		processSb.append(Integer.toHexString(loaderId));
		// 保留前2位
		processPiece = processSb.toString().hashCode() & 0xFFFF;

		return processPiece;
	}
153134
function Ke(pt,ut,bt,ht){var It=pt.c,At=Oe,mt,yt,_t,vt,xt,St,kt;// if x is not Infinity or NaN...
if(It){// rd is the rounding digit, i.e. the digit after the digit that may be rounded up.
// n is a base 1e14 number, the value of the element of array x.c containing rd.
// ni is the index of n within x.c.
// d is the number of digits of n.
// i is the index of rd within n including leading zeros.
// j is the actual index of rd within n (if < 0, rd is a leading zero).
out:{// Get the number of digits of the first element of xc.
for(mt=1,vt=It[0];10<=vt;vt/=10,mt++);// If the rounding digit is in the first element of xc...
if(yt=ut-mt,0>yt)yt+=Re,_t=ut,xt=It[St=0],kt=0|xt/At[mt-_t-1]%10;else if(St=ke((yt+1)/Re),!(St>=It.length)){// Get the number of digits of n.
for(xt=vt=It[St],mt=1;10<=vt;vt/=10,mt++);// Get the index of rd within n.
yt%=Re,_t=yt-Re+mt,kt=0>_t?0:0|xt/At[mt-_t-1]%10}else if(ht){// Needed by sqrt.
for(;It.length<=St;It.push(0));xt=kt=0,mt=1,yt%=Re,_t=yt-Re+1}else break out;if(ht=ht||0>ut||// Are there any non-zero digits after the rounding digit?
// The expression  n % pows10[ d - j - 1 ]  returns all digits of n to the right
// of the digit at j, e.g. if n is 908714 and j is 2, the expression gives 714.
null!=It[St+1]||(0>_t?xt:xt%At[mt-_t-1]),ht=4>bt?(kt||ht)&&(0==bt||bt==(0>pt.s?3:2)):5<kt||5==kt&&(4==bt||ht||6==bt&&// Check whether the digit to the left of the rounding digit is odd.
1&(0<yt?0<_t?xt/At[mt-_t]:0:It[St-1])%10||bt==(0>pt.s?8:7)),1>ut||!It[0])return It.length=0,ht?(ut-=pt.e+1,It[0]=At[ut%Re],pt.e=-ut||0):It[0]=pt.e=0,pt;// Remove excess digits.
// Round up?
if(0==yt?(It.length=St,vt=1,St--):(It.length=St+1,vt=At[Re-yt],It[St]=0<_t?Ie(xt/At[mt-_t]%At[_t])*vt:0),ht)for(;;)// If the digit to be rounded up is in the first element of xc...
if(0==St){// i will be the length of xc[0] before k is added.
for(yt=1,_t=It[0];10<=_t;_t/=10,yt++);for(_t=It[0]+=vt,vt=1;10<=_t;_t/=10,vt++);// if i != k the length has increased.
yt!=vt&&(pt.e++,It[0]==Be&&(It[0]=1));break}else{if(It[St]+=vt,It[St]!=Be)break;It[St--]=0,vt=1}// Remove trailing zeros.
for(yt=It.length;0===It[--yt];It.pop());}// Overflow? Infinity.
pt.e>$e?pt.c=pt.e=null:pt.e<Qe&&(pt.c=[pt.e=0])}return pt}
594998
@Override
	public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
		// 单元格元素
		if (C_ELEMENT.equals(qName)) {

			// 获取当前列坐标
			String tempCurCoordinate = attributes.getValue(R_ATTR);
			// 前一列为null，则将其设置为"@",A为第一列，ascii码为65，前一列即为@，ascii码64
			if (preCoordinate == null) {
				preCoordinate = String.valueOf(ExcelSaxUtil.CELL_FILL_CHAR);
			} else {
				// 存在，则前一列要设置为上一列的坐标
				preCoordinate = curCoordinate;
			}
			// 重置当前列
			curCoordinate = tempCurCoordinate;
			// 设置单元格类型
			setCellType(attributes);
		}

		lastContent = "";
	}
359706
function (which) {
        var top = document.getElementsByClassName('RRFixTop'),
            right = document.getElementsByClassName('RRFixRight'),
            bottom = document.getElementsByClassName('RRFixBottom'),
            left = document.getElementsByClassName('RRFixLeft');
        if (top && top.length > 1) {
            console.error('fixes的元素同一方向只允许存在一个，top方向有多个fixes元素存在')
        }
        if (right && right.length > 1) {
            console.error('fixes的元素同一方向只允许存在一个，right方向有多个fixes元素存在')
        }
        if (bottom && bottom.length > 1) {
            console.error('fixes的元素同一方向只允许存在一个，bottom方向有多个fixes元素存在')
        }
        if (left && left.length > 1) {
            console.error('fixes的元素同一方向只允许存在一个，left方向有多个fixes元素存在')
        }
        var getF = function (node, i) {
            switch (i) {
                case 0:
                    node[0] = top[0] || false;
                    break;
                case 1:
                    node[1] = right[0] || false;
                    break;
                case 2:
                    node[2] = bottom[0] || false;
                    break;
                case 3:
                    node[3] = left[0] || false;
                    break;
                default:
                    throw new Error('方法：getFixes，参数：which，是个只能包含0-3之间整数的数组，或者为空')
            }
        };
        var node = [];
        if (which && which.length > 0) {
            for (var a = 0; a < which.length; a++) {
                getF(node, which[a])
            }
        } else {
            var _witch = [0, 1, 2, 3];
            for (var b = 0; b < _witch.length; b++) {
                getF(node, _witch[b])
            }
        }
        return node;
    }
560884
def warp(self, order):
        

        # 因为成交模式对时间的封装

        if order.order_model == ORDER_MODEL.MARKET:

            if order.frequence is FREQUENCE.DAY:
                # exact_time = str(datetime.datetime.strptime(
                #     str(order.datetime), '%Y-%m-%d %H-%M-%S') + datetime.timedelta(day=1))

                order.date = order.datetime[0:10]
                order.datetime = '{} 09:30:00'.format(order.date)
            elif order.frequence in [FREQUENCE.ONE_MIN,
                                     FREQUENCE.FIVE_MIN,
                                     FREQUENCE.FIFTEEN_MIN,
                                     FREQUENCE.THIRTY_MIN,
                                     FREQUENCE.SIXTY_MIN]:
                exact_time = str(
                    datetime.datetime
                    .strptime(str(order.datetime),
                              '%Y-%m-%d %H:%M:%S') +
                    datetime.timedelta(minutes=1)
                )
                order.date = exact_time[0:10]
                order.datetime = exact_time
            self.market_data = self.get_market(order)
            if self.market_data is None:
                return order
            order.price = (
                float(self.market_data["high"]) +
                float(self.market_data["low"])
            ) * 0.5
        elif order.order_model == ORDER_MODEL.NEXT_OPEN:
            try:
                exact_time = str(
                    datetime.datetime
                    .strptime(str(order.datetime),
                              '%Y-%m-%d %H-%M-%S') + datetime.timedelta(day=1)
                )
                order.date = exact_time[0:10]
                order.datetime = '{} 09:30:00'.format(order.date)
            except:
                order.datetime = '{} 15:00:00'.format(order.date)
            self.market_data = self.get_market(order)
            if self.market_data is None:
                return order
            order.price = float(self.market_data["close"])
        elif order.order_model == ORDER_MODEL.CLOSE:

            try:
                order.datetime = self.market_data.datetime
            except:
                if len(str(order.datetime)) == 19:
                    pass
                else:
                    order.datetime = '{} 15:00:00'.format(order.date)
            self.market_data = self.get_market(order)
            if self.market_data is None:
                return order
            order.price = float(self.market_data["close"])

        elif order.order_model == ORDER_MODEL.STRICT:
            '加入严格模式'
            if order.frequence is FREQUENCE.DAY:
                exact_time = str(
                    datetime.datetime
                    .strptime(order.datetime,
                              '%Y-%m-%d %H-%M-%S') + datetime.timedelta(day=1)
                )

                order.date = exact_time[0:10]
                order.datetime = '{} 09:30:00'.format(order.date)
            elif order.frequence in [FREQUENCE.ONE_MIN,
                                     FREQUENCE.FIVE_MIN,
                                     FREQUENCE.FIFTEEN_MIN,
                                     FREQUENCE.THIRTY_MIN,
                                     FREQUENCE.SIXTY_MIN]:
                exact_time = str(
                    datetime.datetime
                    .strptime(order.datetime,
                              '%Y-%m-%d %H-%M-%S') +
                    datetime.timedelta(minute=1)
                )
                order.date = exact_time[0:10]
                order.datetime = exact_time
            self.market_data = self.get_market(order)
            if self.market_data is None:
                return order
            if order.towards == 1:
                order.price = float(self.market_data["high"])
            else:
                order.price = float(self.market_data["low"])

        return order
1160027
@SuppressLint("DrawAllocation")
    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);

        final int restore = canvas.save();

        final int cx = getMeasuredWidth() / 2;
        final int cy = getMeasuredHeight() / 2;
        final int radius = getMeasuredWidth() / 2 - strokeWidth / 2;

        float drawPercent = percent;
        if (drawPercent > 0.97 && drawPercent < 1) {
            // 设计师说这样比较好
            drawPercent = 0.97f;
        }

        // 画渐变圆
        canvas.save();
        canvas.rotate(-90, cx, cy);
        int[] colors;
        float[] positions;
        if (drawPercent < 1 && drawPercent > 0) {
            calculatePercentEndColor(drawPercent);
            customColors[1] = percentEndColor;
            colors = customColors;
            customPositions[1] = drawPercent;
            customPositions[2] = drawPercent;
            positions = customPositions;
        } else if (drawPercent == 1) {
            percentEndColor = endColor;
            colors = fullColors;
            positions = extremePositions;
        } else {
            // <= 0 || > 1?
            colors = emptyColors;
            positions = extremePositions;
        }
        final SweepGradient sweepGradient = new SweepGradient(getMeasuredWidth() / 2, getMeasuredHeight() / 2, colors, positions);
        paint.setShader(sweepGradient);
        canvas.drawCircle(cx, cy, radius, paint);
        canvas.restore();

        if (drawPercent > 0) {
            // 绘制结束的半圆
            if (drawPercent < 1 || (isFootOverHead && drawPercent == 1)) {
                canvas.save();
                endPaint.setColor(percentEndColor);
                canvas.rotate((int) Math.floor(360.0f * drawPercent) - 1, cx, cy);
                canvas.drawArc(rectF, -90f, 180f, true, endPaint);
                canvas.restore();
            }
            if (!isFootOverHead || drawPercent < 1) {
                canvas.save();
                // 绘制开始的半圆
                canvas.drawArc(rectF, 90f, 180f, true, startPaint);
                canvas.restore();
            }
        }


        canvas.restoreToCount(restore);

    }
390582
function convertFormatNumber (value, num) {
  // 序数
  if (num === 0) {
    return suji(value, '序数');
  }
  // 0埋め
  if (typeof value === 'number') {
    value = value + '';
    return value.length < num ? ('000000000' + value).slice(-num) : value;
  }
  // 切り捨て
  return num && num < value.length ? value.substring(0, num) : value;
}
1179341
private static void processBiGram() {
        //移除二元模型出现频率为1的情况
        Iterator<String> iter = BIGRAM.keySet().iterator();
        while(iter.hasNext()){
            String key = iter.next();
            if(BIGRAM.get(key) < 2){
                iter.remove();
            }
        }
        try(BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("src/main/resources/bigram.txt"),"utf-8"))){
            for(Entry<String, Integer> item : BIGRAM.entrySet()){
                writer.write(item.getKey()+" "+item.getValue()+"\n");
            }
        }catch(Exception e){
            LOGGER.info("保存bigram模型失败：", e);
        }
    }
328607
@SuppressWarnings("unchecked")
	
	/**
	 * 返回列表 key 中，下标为 index 的元素。
	 * 下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，
	 * 以 1 表示列表的第二个元素，以此类推。
	 * 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
	 * 如果 key 不是列表类型，返回一个错误。
	 */
	public <T> T lindex(Object key, long index) {
		Jedis jedis = getJedis();
		try {
			return (T)valueFromBytes(jedis.lindex(keyToBytes(key), index));
		}
		finally {close(jedis);}
	}
1081876
function ze(pt,ut,bt,ht){var It=pt.indexOf("."),At=We,wt=Xe,mt,yt,_t,vt,xt,St,kt;// Remove trailing zeros.
for(37>bt&&(pt=pt.toLowerCase()),0<=It&&(_t=dt,dt=0,pt=pt.replace(".",""),kt=new Le(bt),xt=kt.pow(pt.length-It),dt=_t,kt.c=ue(he(ce(xt.c),xt.e),10,ut),kt.e=kt.c.length),St=ue(pt,bt,ut),yt=_t=St.length;0==St[--_t];St.pop());if(!St[0])return"0";if(0>It?--yt:(xt.c=St,xt.e=yt,xt.s=ht,xt=qe(xt,kt,At,wt,ut),St=xt.c,vt=xt.r,yt=xt.e),mt=yt+At+1,It=St[mt],_t=ut/2,vt=vt||0>mt||null!=St[mt+1],vt=4>wt?(null!=It||vt)&&(0==wt||wt==(0>xt.s?3:2)):It>_t||It==_t&&(4==wt||vt||6==wt&&1&St[mt-1]||wt==(0>xt.s?8:7)),1>mt||!St[0])pt=vt?he("1",-At):"0";else{if(St.length=mt,vt)// Rounding up may mean the previous digit has to be rounded up and so on.
for(--ut;++St[--mt]>ut;)St[mt]=0,mt||(++yt,St.unshift(1));// Determine trailing zeros.
for(_t=St.length;!St[--_t];);// E.g. [4, 11, 15] becomes 4bf.
for(It=0,pt="";It<=_t;pt+=Pe.charAt(St[It++]));pt=he(pt,yt)}// The caller will add the sign.
return pt}
967513
function(num){
        // 非法值默认处理为none
        if(config.rounding !== 'none' && !Math[config.rounding]){
            config.rounding = 'none'
        }

        return config.rounding === 'none' ?         
            parseInt((num*config.constant *100)/100) :
            (Math[config.rounding](num*config.constant *100)/100).toString().indexOf('.0') > -1 ? 
                // 如果结果后边有小数'.0'，直接取整，否则调用Math方法
                parseInt(Math[config.rounding](num*config.constant *100)/100):
                Math[config.rounding](num*config.constant *100)/100;
    }
465269
function parseCompoundGlyf(reader, glyf) {
            glyf.compound = true;
            glyf.glyfs = [];

            var flags;
            var g;

            // 读取复杂字形
            do {
                flags = reader.readUint16();
                g = {};
                g.flags = flags;
                g.glyphIndex = reader.readUint16();

                var arg1 = 0;
                var arg2 = 0;
                var scaleX = 16384;
                var scaleY = 16384;
                var scale01 = 0;
                var scale10 = 0;

                if (componentFlag.ARG_1_AND_2_ARE_WORDS & flags) {
                    arg1 = reader.readInt16();
                    arg2 = reader.readInt16();

                }
                else {
                    arg1 = reader.readInt8();
                    arg2 = reader.readInt8();
                }

                if (componentFlag.ROUND_XY_TO_GRID & flags) {
                    arg1 = Math.round(arg1);
                    arg2 = Math.round(arg2);
                }

                if (componentFlag.WE_HAVE_A_SCALE & flags) {
                    scaleX = reader.readInt16();
                    scaleY = scaleX;
                }
                else if (componentFlag.WE_HAVE_AN_X_AND_Y_SCALE & flags) {
                    scaleX = reader.readInt16();
                    scaleY = reader.readInt16();
                }
                else if (componentFlag.WE_HAVE_A_TWO_BY_TWO & flags) {
                    scaleX = reader.readInt16();
                    scale01 = reader.readInt16();
                    scale10 = reader.readInt16();
                    scaleY = reader.readInt16();
                }

                if (componentFlag.ARGS_ARE_XY_VALUES & flags) {
                    g.useMyMetrics = !!flags & componentFlag.USE_MY_METRICS;
                    g.overlapCompound = !!flags & componentFlag.OVERLAP_COMPOUND;

                    g.transform = {
                        a: Math.round(10000 * scaleX / 16384) / 10000,
                        b: Math.round(10000 * scale01 / 16384) / 10000,
                        c: Math.round(10000 * scale10 / 16384) / 10000,
                        d: Math.round(10000 * scaleY / 16384) / 10000,
                        e: arg1,
                        f: arg2
                    };
                }
                else {
                    error.raise(10202);
                }

                glyf.glyfs.push(g);

            } while (componentFlag.MORE_COMPONENTS & flags);

            if (componentFlag.WE_HAVE_INSTRUCTIONS & flags) {
                var length = reader.readUint16();
                if (length < MAX_INSTRUCTION_LENGTH) {
                    var instructions = [];
                    for (var i = 0; i < length; ++i) {
                        instructions.push(reader.readUint8());
                    }
                    glyf.instructions = instructions;
                }
                else {
                    console.warn(length);
                }
            }

            return glyf;
        }
599113
public void removeZero() {
		boolean freeze = false;
		if (feature.isStopIncrement()) {
			feature.setStopIncrement(false);
			freeze = true;
		}
		TIntObjectHashMap<String> index = (TIntObjectHashMap<String>) feature.toInverseIndexMap();
		
		System.out.println("原字典大小"+index.size());
		System.out.println("原字典大小"+feature.size());
		StringFeatureAlphabet newfeat = new StringFeatureAlphabet();
		cl.factory.setDefaultFeatureAlphabet(newfeat);
		for(int i=0;i<weights.length;i++){
				TIntFloatIterator itt = weights[i].data.iterator();
				HashSparseVector ww = new HashSparseVector();
				while(itt.hasNext()){
					itt.advance();
					float v = itt.value();
					if(Math.abs(v)<1e-3f)
						continue;
					String fea = index.get(itt.key());
					int newidx = newfeat.lookupIndex(fea);
					ww.put(newidx, v);				
			}
			weights[i] = ww;	
		}
		
		newfeat.setStopIncrement(freeze);
		System.out.println("新字典大小"+newfeat.size());		
		System.out.println("新字典大小"+feature.size());		
		index.clear();		
	}
97485
function()
        {
            // 如果导入了 pinyin_dict_firstletter.js
            if(pinyin_dict_firstletter)
            {
                dict.firstletter = pinyin_dict_firstletter;
            }
            // 如果导入了 pinyin_dict_notone.js
            if(window.pinyin_dict_notone)
            {
                dict.notone = {};
                dict.py2hz = pinyin_dict_notone; // 拼音转汉字
                for(var i in pinyin_dict_notone)
                {
                    var temp = pinyin_dict_notone[i];
                    for(var j=0, len=temp.length; j<len; j++)
                    {
                        if(!dict.notone[temp[j]]) dict.notone[temp[j]] = i; // 不考虑多音字
                    }
                }
            }
            // 如果导入了 pinyin_dict_withtone.js
            if(window.pinyin_dict_withtone)
            {
                dict.withtone = {}; // 汉字与拼音映射，多音字用空格分开，类似这种结构：{'大': 'da tai'}
                var temp = pinyin_dict_withtone.split(',');
                for(var i=0, len = temp.length; i<len; i++)
                {
                    // 这段代码耗时28毫秒左右，对性能影响不大，所以一次性处理完毕
                    dict.withtone[String.fromCharCode(i + 19968)] = temp[i]; // 这里先不进行split(' ')，因为一次性循环2万次split比较消耗性能
                }

                // 拼音 -> 汉字
                if(window.pinyin_dict_notone)
                {
                    // 对于拼音转汉字，我们优先使用pinyin_dict_notone字典文件
                    // 因为这个字典文件不包含生僻字，且已按照汉字使用频率排序
                    dict.py2hz = pinyin_dict_notone; // 拼音转汉字
                }
                else
                {
                    // 将字典文件解析成拼音->汉字的结构
                    // 与先分割后逐个去掉声调相比，先一次性全部去掉声调然后再分割速度至少快了3倍，前者大约需要120毫秒，后者大约只需要30毫秒（Chrome下）
                    var notone = pinyinUtil.removeTone(pinyin_dict_withtone).split(',');
                    var py2hz = {}, py, hz;
                    for(var i=0, len = notone.length; i<len; i++)
                    {
                        hz = String.fromCharCode(i + 19968); // 汉字
                        py = notone[i].split(' '); // 去掉了声调的拼音数组
                        for(var j=0; j<py.length; j++)
                        {
                            py2hz[py[j]] = (py2hz[py[j]] || '') + hz;
                        }
                    }
                    dict.py2hz = py2hz;
                }
            }
        }