新零点

博客

  • Glibc 中的 memset

    Glibc的效率真的快！快到让我想不到！！！
    这个memset跑的贼快~！不过我还是没想通，为什么不用汇编呢？sep movw，速度可能更快!
    对memset的注释如下：

    C语言: [Codee#12483](http://fayaa.com/code/view/12483/)

void *memset(void *dstpp, int c, size_t len)
{
 long int dstp = (long int) dstpp;
 /* 正在翻阅为什么用long int 而不是void *. */
 /* 被高手指点了一下，不能用void *，因为它不能增，只能用char *. */

 /* 还有一位仙人告诉我, 这里用long int 纯粹只是个人喜好, 另见FreeBSD的代码:

 [http://www.freebsd.org/cgi/cvsweb.cgi/src/lib/libc/string/memset.c?rev=1.9](http://www.freebsd.org/cgi/cvsweb.cgi/src/lib/libc/string/memset.c?rev=1.9) */

 if (len >= 8) {
 size_t xlen;
 op_t cccc;
 /* 关于op_t这个类型, 在memcmp中有定义
 # define op_t unsigned long int
 # define OPSIZ (sizeof(op_t)) */

 /* 每次操作对多个字节进行赋值 */
 cccc = (unsigned char) c;
 cccc |= cccc << 8;
 cccc |= cccc << 16;
 if (OPSIZ > 4) /* 如果是64位的机子的话, 还可以再多用4个字节 */
 cccc |= (cccc << 16) << 16;

 while (dstp % OPSIZ != 0) { /* 让内存地址对齐地址总线的长度, 以
 得到最高的效率! */
 ((byte *) dstp)[0] = c;
 dstp += 1;
 len -= 1;
 }

 xlen = len / (OPSIZ * 8); /* 每次赋值8个，也就是说如果在32位的机子上的话
 每次赋值4*8=32个字节，64位的机子就是64字节 */
 while (xlen > 0) {
 ((op_t *) dstp)[0] = cccc;
 ((op_t *) dstp)[1] = cccc;
 ((op_t *) dstp)[2] = cccc;
 ((op_t *) dstp)[3] = cccc;
 ((op_t *) dstp)[4] = cccc;
 ((op_t *) dstp)[5] = cccc;
 ((op_t *) dstp)[6] = cccc;
 ((op_t *) dstp)[7] = cccc;
 dstp += 8 * OPSIZ;
 xlen -= 1;
 }
 len %= OPSIZ * 8; /* 得到余下的未赋值的字节数，一定小于32 */

 xlen = len / OPSIZ; /* 每次赋值1个, 32位机子4个字节一次, 64位8个 */
 while (xlen > 0) {
 ((op_t *) dstp)[0] = cccc;
 dstp += OPSIZ;
 xlen -= 1;
 }
 len %= OPSIZ; /* 得到余下的未赋值的字节书，一定小于4 */
 }

 while (len > 0) { /* 最后剩下的几个字节单独赋值 */
 ((byte *) dstp)[0] = c;
 dstp += 1;
 len -= 1;
 }

 return dstpp;
}

  • man df 中文版(本人翻译的)

    df(1)                                                                             1:用户命令

     

    命令名称:

    df —— 返回文件系统的使用情况

     

    基本结构:

    df[OPTION]…[FILE]…

     

    具体描述:

    这个man page(可以说成”描述文档”吧, 就是说你现在看到的这篇文章)是对df命令的GNU版本进行描述，df能够显示FILE 所在的文件系统和此文件系统的空间使用情况。如果没有给出FILE 参数，那么将会显示当前所有已经挂载(mounted)的文件系统的空间使用情况。在默认情况下是以1kb为单位显示空间，除非环境变量POSIXLY_CORRECT被设置了，那将以512-byte为单位显示。

    如果FILE 中包含一个已经挂载(mounted)了的绝对路径的磁盘设备文件，那么df会显示这个文件所指的文件系统，而不是这个文件所在的文件系统(通常是root文件系统)。这个版本(GNU)的df不能够显示未挂载的文件系统使用状况，因为这样做的话会让大部分操作系统使用不可移植的文件系统结构。

     

    参数[OPTIONS]:

    查看FILE 所在的文件系统或者是显示所有的文件系统的信息。

    长的命令参数和短的参数效果是一样的。

    -a, –all

    　　显示所有的文件系统(包括一些特殊的文件系统)。

    -B, –block-size=SIZE　　(使用方法如: df –B 10k, df –-block-size=10k)

    　　以SIZE 个blcok为单位。

    -h, –human-readable

    　　使用人们易读的方式显示(如: 1K, 234M, 2G)

    -H, –si

    　　同上，但是1kB是1000 byte而不是1024 byte来显示。

    -I, –inodes

    　　以inode(一个文件会分配一个inode)列出文件使用情况而不是以block。

    -k

    　　相当于—block-size=1k。

    -l, –local

    　　只显示本地文件系统的使用情况。

    –no-sync

    　　在显示信息之前不sync硬盘(默认的)(和—sync相反)。

    -P, –portability

    　　使用POSIX格式输出。

    –sync

    　　在显示信息之前sync硬盘(和—no-sync相反)。

    -t, –type=TYPE

    　　只显示指定的文件系统类型(如: ext2)。

    -T, –print-type

    　　显示出文件系统的类型。

    -x, –exclude-type=TYPE

    　　显示除指定的文件系统类型之外的文件系统。

    –help

    　　显示帮助信息。

    –version

    　　显示版本信息。

     

    作者:

    本页面的作者是Torbjorn Granlund, David MacKenzie, 和 Paul Eggert。

    由张青阳翻译。

     

    报告漏洞：

    报告给<bug-coreutils@gnu.org>

     

    版权:

    版权所有 (C) 2008自由软件基金会。GPLv3+批准:  GNU公共许可证版本3或更高(http://gnu.org/licenses/gpl.html) 自由软件：你能够自由的修改和发布它们，请在法律允许的范围内使用，我们不负任何责任。

     

    参见:

    对于df维护的完整手册作为Texinfo的手册。

     

    GNU 6.10                              2008年4月                  　　　　　           DF(1)

  • USACO 3.2.6 Sweet Butter 香甜的黄油 解题报告

    这题一开始我用的那个O(n^3)的算法，叫什么名字我忘了，肯定是超时了咯，因为图是稀疏图，这样是肯定超时的，后来就看标称，看了好久，真没想到标称竟然如此精妙，里面设计了一个能够以O(1)的速度查找元素的功能，整个程序是执行了至多n次Dijkstra算法，然后我在里面增加了一些优化（几乎和时间无关的优化，因为数据量太大，CPU又太好用了），比如用位运算代替乘除法(乘以或除以2)，在上滤和下滤的过程把递归改成了非递归，防止重复的牛所在的牧场进行计算，让heap_val在上滤和下滤的过程中不修改，反正最大的数据程序还是要0.16s才能完成，不知道算不算快。
    不过此代码是我写的可读性最低的代码之一，能读都就读吧。

    /*
LANG: C
ID: zqynux2
PROG: butter
*/
#include <stdio.h>
const int INTMAX = 1<<30;

int heap_val[800];
int heap_id[800];
int heap_lookup[800];
int heap_size;
#define left(i) (((i) << 1) + 1)
#define right(i) (((i) << 1) + 2)
#define parent(i) ((i - 1) >> 1) 

void heapdown(int t)
{
 int i, ch;
 int id = heap_id[t];
 for(i = t; left(i) < heap_size; i = ch){
 ch = left(i);
 if(ch + 1 < heap_size && heap_val[heap_id[ch + 1]] <
 heap_val[heap_id[ch]]){
 ch++;
 }
 if(heap_val[id] > heap_val[heap_id[ch]]){
 heap_lookup[heap_id[ch]] = i;
 heap_id[i] = heap_id[ch];
 }else{
 break;
 }
 }
 heap_lookup[id] = i;
 heap_id[i] = id;
}

void heapup(int t)
{
 int i;
 int id = heap_id[t];
 for(i = t; i > 0 && heap_val[id]
 < heap_val[heap_id[parent(i)]]; i = parent(i)){
 heap_lookup[heap_id[parent(i)]] = i;
 heap_id[i] = heap_id[parent(i)];
 }
 heap_lookup[id] = i;
 heap_id[i] = id;
}

int cows[500];
int link[800][800];
int value[800][800];
int count[800];
int used[500];
int fixed[800];
int dist[800][800];
int n, p, c;

int main(void)
{
 int i, j, k;
 int t, s;
 freopen(butter.in, r, stdin);
 freopen(butter.out, w, stdout);
 scanf(%d%d%d, &n, &p, &c);
 for(i = 0; i < n; i++){
 scanf(%d, &cows[i]);
 cows[i]--; //掉了这一行代码 
 }
 {
 int a, b, d;
 for(i = 0; i < c; i++){
 scanf(%d%d%d, &a, &b, &d);
 a--, b--;
 link[a][count[a]] = b;
 link[b][count[b]] = a;
 value[a][count[a]] = value[b][count[b]] = d;
 count[a]++, count[b]++;
 }
 }
 for(i = 0; i < n; i++){
 if(used[i]){
 continue;
 }
 used[i] = 1;
 heap_size = p;
 for(j = 0; j < p; j++){
 heap_id[j] = j;
 heap_val[j] = INTMAX;
 heap_lookup[j] = j;
 }
 heap_val[cows[i]] = 0;
 heapup(cows[i]);
 memset(fixed, 0, sizeof(fixed));
 while(heap_size != 0){
 t = heap_id[0];
 dist[cows[i]][t] = heap_val[t];
 fixed[t] = 1;
 heap_size--;
 heap_lookup[heap_id[heap_size]] = 0;
 heap_id[0] = heap_id[heap_size];
 heapdown(0);
 for(k = 0; k < count[t]; k++){
 s = link[t][k];
 if(!fixed[s] && heap_val[s] > heap_val[t] + value[t][k]){
 heap_val[s] = heap_val[t] + value[t][k];
 heapup(heap_lookup[s]);
 }
 }
 }
 }
 {
 int ans = INTMAX, tmp;
 for(i = 0; i < p; i++){
 tmp = 0;
 for(j = 0; j < n; j++){
 tmp += dist[cows[j]][i];
 }
 if(ans > tmp){
 ans = tmp;
 }
 }
 printf(%d\\n, ans);
 }
 return 0;
}

  • 奖学金 解题报告

    这是个水题，我直接使用了库函数qsort进行了排序，然后输出前五个就可以了，唯一想要说的就是明天或后天把Glibc中的qsort代码看下，学习一下是怎么对超级巨大的数据量进行快速排序的，一个个交换肯定不是，这些都明天再说吧。

    #include <stdio.h>
#include <stdlib.h>
#define MAX 300
struct grade{
 int a, b, c;
 int id;
}totle[MAX];
int compare(const void *a, const void *b)
{
 struct grade i = *(struct grade *)a, j = *(struct grade *)b;
 int sum1 = i.a + i.b + i.c,
 sum2 = j.a + j.b + j.c;
 if(sum1 == sum2){
 if(i.a == j.a){
 return i.id - j.id;
 }
 return j.a - i.a;
 }
 return sum2 - sum1;
}

int main(void)
{
 int i;
 int n;
 scanf(%d, &n);
 for(i = 0; i < n; i++){
 totle[i].id = i + 1;
 scanf(%d%d%d, &totle[i].a, &totle[i].b, &totle[i].c);
 }
 qsort(totle, n, sizeof(struct grade), compare);
 for(i = 0; i < 5; i++){
 printf(%d %d\\n, totle[i].id, totle[i].a + totle[i].b +
 totle[i].c);
 }
 return 0;
}

  • 2^k进制数 解题报告

    这题困扰了我好几天，详细看了别人的题解，自己反复琢磨，终于琢磨透了。
    把我的思路讲一下，f[i][j] 表示第i位(从右向左数, 如12中的1是第二位)，则很容易得到一个DP：
    f[i][j] = f[i – 1][j + 1] + f[i – 1][j + 2] + f[i – 1][j + 3] + …. + f[i – 1][n] (n为极限，放在后面讲。)
    不用说，用这个递推公式绝对会超时，所以还需要对公式观察一下：
    f[i][j] = f[i – 1][j + 1] + f[i – 1][j + 2] + f[i – 1][j + 3] + …. + f[i – 1][n]
    上面用红色标记出来的能够用f[i][j + 1] 表示，怎么来的？呵呵，就是因为
    f[i][j] = f[i – 1][j + 1] + f[i – 1][j + 2] + f[i – 1][j + 3] + …. + f[i – 1][n] 所以
    f[i][j + 1] = f[i – 1][j + 2] + f[i – 1][j + 3] + …. + f[i – 1][n].所以
    f[i][j] = f[i][j + 1] + f[i – 1][j + 1]
    这就好求了，但是这里需要从大数向小数递减（即j是从n – 1 递减到 1）
    然后，我提供一个小剪枝，第i个数的最大值位(1 << k) – j，比如只有一位数字的时候（题目要求至少两位，但是这里只是说明。）当k=3的时候，第一位能够选择的数字是1-7；当有两位数字且k=3是，第二位就只能是1~6而不是1~7了（自己思考下）

    还有一个重要的就是需要高精度！！别人都说int要压4位运算，但是这里我压了9位，原因很简单，压4位数的原因是99999^2 > 2^32，就是说当遇到最坏情况下的乘法时，只能使用4位，5位就会溢出；但是这个题目要清楚一点，高精度只用实现加法！所以可以压9位，再多的话也是会超时的。
    代码就在下面提供了吧:

    
#include <stdio.h>
#define MAX 24
#define USED 1000000000
#define max(a, b) ((a)>(b)?(a):(b))
typedef unsigned bignum[MAX];
bignum count[513][513];
bignum ans;

void add(bignum a, bignum b)
{
 int i, j, t;
 int c = max(a[0], b[0]);
 unsigned to = 0;
 if(a[0] < b[0]){
 a[0] = b[0];
 }
 for(i = 0; i < c; i++){
 t = MAX - 1 - i;
 a[t] += b[t] + to;
 to = a[t] / USED;
 if(to > 0){
 a[t] %= USED;
 }
 }
 if(to != 0){
 a[MAX - 1 - i] = to; //狂晕,,, 这里的to写成了t 
 a[0]++;
 }
}

void output(bignum n)
{
 int i, t;
 for(i = MAX - n[0]; i <= MAX - 1; i++){
 printf(%.*d, (i == MAX - n[0]) ? 0 : 9, n[i]);
 }
}

int main(void)
{
 int i, j;
 int top, limit;
 int k, w, n;
 scanf(%d%d, &k, &w);
 n = w / k;
 top = limit = (1 << k) - 1;
 if(w - n * k > 0){
 top = (1 << (w - n * k)) - 1;
 n++;
 }
 if(limit < n){
 n = limit;
 }
 for(i = 1; i <= limit; i++){
 count[1][i][0] = 1;
 count[1][i][MAX - 1] = 1;
 }
 for(i = 2; i <= n; i++){
 for(j = limit - i + 1; j >= 1; j--){
 add(count[i][j], count[i - 1][j + 1]);
 add(count[i][j], count[i][j + 1]);
 }
 }
 for(i = 2; i < n; i++){
 for(j = 1; j <= limit; j++){
 add(ans, count[i][j]);
 }
 }
 for(j = 1; j <= top; j++){
 add(ans, count[i][j]);
 }
 output(ans);
 return 0;
}

  • 中文man shutdown(在线手册)

    shutdown(8)                                                      8: 系统管理员可用的管理指令

    指令名称:

    shutdown – 关机命令

    基本结构:

    shutdown[OPTION] … TIME [MESSAGE]

    描述:

    shutdown让系统安全的关机. 它会通知所有在线的用户系统将会在 TIME 所制定的时间内关闭, 同时防止新用户的登陆.

    TIME 拥有多种格式, 最常见的是字符串‘now’, 它将导致系统立刻关机. 其他有效格式有: +m 和 hh:mm .前者中代表系统将会在 m 分钟内之后关机, 后者将会在制定的时间关机(24时制).

    当 TIME 制定的时间到了, shutdown 会发送一个消息给守护进程init(8), 使系统进入指定的运行级别.

    选项:

    -r 使系统重新启动.

    -h 使系统关机或挂起.

    -H 使系统挂起.

    -P 使系统关机.

    -c 取消一个正在运行的shutdown. 不需要指定TIME, 第一个参数是MESSAGE.

    -k 仅仅发送一条警告信息, 并且让用户无法登陆, 但是却不让系统bring down.

    作者:

    Scott James Remnant.

    报告Bug:

    如果您发现了bug, 请在在https://launchpad.net/products/upstart/+bugs报告.

    还可参考:

    init(8)       telinit(8)

    2007.3                                                                           shutdown(8)

  • Glibc 的 strcmp

    Glibc的设计确实巧妙的让人想不到，如下strcmp的代码就十分巧妙：

    C语言: Codee#12462

    int
strcmp (p1, p2)
 const char p1;
 const char p2;
{
 register const unsigned char s1 = (const unsigned char ) p1;
 register const unsigned char s2 = (const unsigned char ) p2;
 unsigned reg_char c1, c2;

 do
 {
 c1 = (unsigned char) s1++;
 c2 = (unsigned char) s2++;
 if (c1 == \'\\0\')
 return c1 - c2;
 }
 while (c1 == c2);

 return c1 - c2;
}

    它使用了寄存器变量就会很快了，又只是用了两个判断来确定循环是否继续，这才是程序的关键！因为如果c2==\’\0\’的话，那么c1有两种情况，第一c1不等于\’\0\’，这种情况下那就会不满足c1 == c2 这个条件，退出循环；然而如果c1也等于\’\0\’的话，那么程序满足c1 == \’\0\’的条件，那退出程序。

  • 快速成法

    　　当x乘以n的时候，一般人使用的是mul指令（即直接相乘），而我会使用位运算来优化这些速度，比如乘以3，就等于((x << 1) + x)，相当于2x+x 就是3x了，然而这后者的速度比前者的速度快很多。
    　　乘以3只是一个情况，乘以n的话，就要把n拆分成2的次方相加，更一般地，就是把n用二进制表示，然后把位为1的进行处理，没表达清楚吧，再举个例子：5，它的二进制是101，也就是4+1，那么就可以把n5表示成4n+n，也就是((n << 2) + n)，再比如8把，8*n的二进制是1000，也就是2^3，那么就可以写成(n << 3)
    　　现在发现位运算比很多运算要快很多！！

  • 快速置零 xor %eax, %eax

    　　在<<Linux 内核完全注释>>里面看到了几次xor ax, ax，很想不通，为什么不直接用mov ax, 0呢？今日到网上一搜才知道，我的天啊，xor ax, ax 只需要计算机2条指令，而mov ax, 0会消耗计算机5指令，什么意思？就是近三倍的速度差别。

  • [转]as86的man

    as86(1)                                                                as86(1)

    名称
          as86 – as86-8086..80386    处理器的汇编程序

    概要格式
          as86  [-0123agjuw]  [-lm[list]]  [-n name]  [-o obj] [-b[bin]] [-s sym]
          [-t textseg] src

          as86_encap prog.s prog.v [prefix_] [as86 options]

    描述
         as86    是8086..80386处理器下的汇编程序，它所采用的语法与Intel/MS采取的语法类似，而不同于广泛运用于UNIX下的汇编语法（译注,gas中的语法，AT&T汇编）

        命令行中的src参数可为‘-‘,代表对标准输入进行汇编。

        as86_encap是一个脚本，使用了as86汇编程序，并且把生成的二进制文件转为一个C文件prog.v，用于被连接或者包含到程序里，例如引导块安装程序。prefix_参数定义一个加到源文件中所有定义的变量的前缀，缺省前缀是源文件名。…

    选项
         -0         以16位代码段运行，当使用了高于8086指令集的指令时警告。

         -1     以16位代码段运行，当使用了高于80186指令集的指令时警告。

         -2     以16位代码段运行，当使用了高于80286指令集的指令时警告。

         -3     以32位代码段运行，不对任何指令发出警告信息（就算使用了486或586的指令）

         -a     使汇编程序部分兼容于Minix asld.交换了[]与()的用法，并且改变了一些16位跳转与调用的语法(“jmp @(bx)” 就成了一个合法的指令)

         -g     仅仅把global符号写入目标或者符号文件中

         -j     把所有短跳转指令(译注：8位跳转称为短跳转)换成相似的16位或者32位跳转。并且把16位条件转移指令换为一个条件短转移命令与一个无条件长跳转组合

         -O     汇编程序会做几遍额外的工作，以尝试支持向前引用。最多30遍。不推荐使用

         -l     产生清单文件(list file),文件名写在选项后

         -m     把宏展开后写在清单文件里

         -n     把模块名写在选项之后(目标模块，而非源文件)

         -o     生成目标文件，文件名写在选项之后

         -b     生成纯二进制文件，文件名写在后面。这是一个没有头部的纯二进制文件（译注：类似Dos下的com和sys）如果没有-s选项程序将会在内存地址0处开始执行

         -s     生成一个ASCII码符号文件，文件名写在选项后。很简单就能将其转换，用于与-b选项生成的二进制文件相关联和封装。如果二进制文件不从地址0处开始执行。那么符号文件表中前两项分别代表起始地址与结束地址

         -u     假定未定义符号在未指定的段中被导入了

         -w-    允许汇编程序输出警告信息

         -t n   把所有text段的数据放到段n+3中.

    AS86 资料
              特殊字符

         *    本行起始地址

         ;或! 注释起始符,另外，在一行起始处的“unexpected”字符被认为是注释（但是仍然会被显示在终端上）

         $      16进制数的前缀, C风格的前缀, 比如0x1234, 也可以使用.

         %      2进制数的前缀.

         #      立即数的前缀.

         [ ]    间接寻址运算符.

                与MASM不同，汇编程序没有标识符的类型信息，每个标识符仅仅代表是一个段地址和偏移地址。[]与立即数操作与传统汇编程序一致

                 例:

                      mov     ax,bx

                      jmp     bx

                 寄存器寻址, jmp指令把bx寄存器中的值拷到程序计数器中

                      mov ax,[bx]

                      jmp [bx]

                 简单的寄存器间接寻址, jmp指令把bx寄存器值指向的内存单元的值拷到程序计数器中

                      mov ax,#1234

                 立即数, 把1234赋值给ax寄存器

                      mov ax,1234

                      mov ax,_hello

                      mov ax,[_hello]

                 直接寻址，内存地址1234处的存储字赋给ax寄存器。注意第三个指令并不十分严格，只是为了与asld保持兼容所以保留（译注：若想将_hello标识符表示的值作为立即数使用，需要加上#前缀 #_hello）

                      mov ax,_table[bx]

                      mov ax,_table[bx+si]

                      mov eax,_table[ebx*4]

     

                      mov ax,[bx+_table]

                      mov ax,[bx+si+_table]

                      mov eax,[ebx*4+_table]

                 变址寻址。两种形式都可以，但是我认为第一种要更正确些，但是我往往用第二种形式🙂

          条件判断

          IF, ELSE, ELSEIF, ENDIF

                 数字比较

          IFC, ELSEIFC

                 字符串比较 (str1,str2)

     

         FAIL .FAIL

                 生成用户错误

          段相关

          .TEXT .ROM .DATA .BSS
                     设置当前段。可以在前面加上关键字.SECT

          LOC    数字表示段 0=TEXT, 3=DATA,ROM,BSS, 14=MAX.  连接器设定的段顺序现在是0,4,5,6,7,8,9,A,B,C,D,E,1,2,3.段 0 以及所有3以上的段都假设为text段。注意64K限制对3-14的段不适用。

         标识符类型定义

          EXPORT PUBLIC .DEFINE
                     导出符号

          ENTRY  强制连接器在a.out文件里包含这个特殊符号

          .GLOBL .GLOBAL
                     将一个标识符定义为外部的，并且强制就算不使用，也必须导入

          EXTRN EXTERN IMPORT .EXTERN
                     导入外部标识符列表

    NB: bin格式的文件不支持外部变量（译注：关于这些格式，推荐参考一下NASM的手册。纯C论坛上有中文的NASM手册）

          .ENTER 标识出旧式bin格式(obs)的程序入口

          数据定义

          DB .DATA1 .BYTE FCB
                 1    字节的对象列表

          DW .DATA2 .SHORT FDB .WORD
                 2    字节的对象列表

          DD .DATA4 .LONG
                 4    字节的对象列表

          .ASCII FCC
                   写到输出的Ascii码字符串.

          .ASCIZ Ascii 写到输出的Ascii码字符串，末尾添加nul

          空间定义

          .BLKB RMB .SPACE
                     以字节为单位计算空间

          .BLKW .ZEROW
                     以字为单位计算空间 (一字2字节)

          COMM .COMM LCOMM .LCOMM
                     通用数据域定义

          其他实用伪指令

          .ALIGN .EVEN
                     对齐

          EQU    定义标识符（译注：可参考NASM或者MASM的EQU）

          SET    定义可重定义的标识符

          ORG .ORG
                     定义汇编位置（译注：即设置地址计数器的值，建议参考MASM的资料）

          BLOCK  定义汇编位置并且把原来的汇编位置入栈

          ENDB   回到刚才栈里记录的汇编位置

          GET INCLUDE
                     插入新文件 (no quotes on name)

    USE16 [cpu]
                定义默认操作数大小为16位，参数表示程序代码将会运行在什么样的CPU的(86,186, 286,386,486,586)指令集上.使用了指定指令集之上的指令会产生警告信息

    USE32 [cpu]
               定义默认操作数大小为32位，参数表示程序代码将会运行在什么样的CPU的(86,186,     286,386,486,586)指令集上.使用了指定指令集之上的指令会产生警告信息

          END    标识出本文件停止汇编的地方

          .WARN  警告信息开关

          .LIST  清单 on/off (1,-1)

          .MACLIST
                     宏清单 on/off (1,-1)

         宏的使用形式如下

              MACRO sax
                 mov ax,#?1
              MEND
              sax(1)

         未实现/未使用的

          IDENT  Define object identity string.

          SETDP  Set DP value on 6809

          MAP    Set binary symbol table map number.

         寄存器
                 BP BX DI SI
                 EAX EBP EBX ECX EDI EDX ESI ESP
                 AX CX DX SP
                 AH AL BH BL CH CL DH DL
                 CS DS ES FS GS SS
                 CR0 CR2 CR3 DR0 DR1 DR2 DR3 DR6 DR7
                 TR3 TR4 TR5 TR6 TR7 ST

         操作数类型说明
                 BYTE DWORD FWORD FAR PTR PWORD QWORD TBYTE WORD NEAR

                 near和far关键字并没有提供段间寻址编程的能力,所有”far”操作都是
                     都是通过显式地使用以下指令得到的：指令: jmpi, jmpf, callf, retf,
                     等等. Near关键字可以被用来强制使用80386的16位条件跳转指令    .
                 ‘Dword’    和‘word’ 能控制远跳转和远调用的操作数的大小

         普通指令.
                     这些指令和其他8086汇编程序所提供的指令大体上差不多,(译注:后面的
                     看不明白了.我的英语功底啊~555) the main exceptions being a few ‘
                 Bcc’ (BCC, BNE,  BGE,  etc)  instructions which are shorthands f
                 or a short branch plus a long jump and ‘BR’ which is the longest
                 unconditional jump (16 or 32 bit).

          长分支
                 BCC  BCS  BEQ  BGE BGT BHI BHIS BLE BLO BLOS BLT BMI BNE BPC BPL
                 BPS BVC BVS BR

          段间操作
                 CALLI CALLF JMPI JMPF

         段修饰符指令
                 ESEG FSEG GSEG SSEG

         字节操作指令
                 ADCB ADDB ANDB CMPB DECB DIVB IDIVB IMULB  INB  INCB  MOVB  MULB
                 NEGB  NOTB ORB OUTB RCLB RCRB ROLB RORB SALB SARB SHLB SHRB SBBB
                 SUBB TESTB XCHGB XORB

         标准指令
                 AAA AAD AAM AAS ADC ADD AND ARPL BOUND BSF BSR BSWAP BT BTC  BTR
                 BTS CALL CBW CDQ CLC CLD CLI CLTS CMC CMP CMPS CMPSB CMPSD CMPSW
                 CMPW CMPXCHG CSEG CWD CWDE DAA DAS DEC DIV DSEG ENTER  HLT  IDIV
                 IMUL  IN  INC  INS  INSB INSD INSW INT INTO INVD INVLPG INW IRET
                 IRETD J JA JAE JB JBE JC JCXE JCXZ JE JECXE JECXZ JG JGE JL  JLE
                 JMP  JNA JNAE JNB JNBE JNC JNE JNG JNGE JNL JNLE JNO JNP JNS JNZ
                 JO JP JPE JPO JS JZ LAHF LAR LDS LEA LEAVE LES LFS LGDT LGS LIDT
                 LLDT  LMSW  LOCK  LODB  LODS  LODSB  LODSD LODSW LODW LOOP LOOPE
                 LOOPNE LOOPNZ LOOPZ LSL LSS LTR MOV MOVS MOVSB MOVSD MOVSW MOVSX
                 MOVW  MOVZX  MUL  NEG NOP NOT OR OUT OUTS OUTSB OUTSD OUTSW OUTW
                 POP POPA POPAD POPF POPFD PUSH PUSHA PUSHAD PUSHF PUSHFD RCL RCR
                 REP REPE REPNE REPNZ REPZ RET RETF RETI ROL ROR SAHF SAL SAR SBB
                 SCAB SCAS SCASB SCASD SCASW SCAW SEG SETA SETAE SETB SETBE  SETC
                 SETE SETG SETGE SETL SETLE SETNA SETNAE SETNB SETNBE SETNC SETNE
                 SETNG SETNGE SETNL SETNLE SETNO  SETNP  SETNS  SETNZ  SETO  SETP
                 SETPE  SETPO SETS SETZ SGDT SHL SHLD SHR SHRD SIDT SLDT SMSW STC
                 STD STI STOB STOS STOSB STOSD STOSW STOW STR SUB TEST VERR  VERW
                 WAIT WBINVD XADD XCHG XLAT XLATB XOR

          浮点
                 F2XM1  FABS  FADD  FADDP FBLD FBSTP FCHS FCLEX FCOM FCOMP FCOMPP
                 FCOS FDECSTP FDISI FDIV FDIVP  FDIVR  FDIVRP  FENI  FFREE  FIADD
                 FICOM  FICOMP  FIDIV  FIDIVR FILD FIMUL FINCSTP FINIT FIST FISTP
                 FISUB FISUBR FLD FLD1 FLDL2E FLDL2T FLDCW FLDENV  FLDLG2  FLDLN2
                 FLDPI  FLDZ  FMUL  FMULP  FNCLEX FNDISI FNENI FNINIT FNOP FNSAVE
                 FNSTCW FNSTENV FNSTSW FPATAN FPREM FPREM1 FPTAN  FRNDINT  FRSTOR
                 FSAVE  FSCALE  FSETPM  FSIN  FSINCOS FSQRT FST FSTCW FSTENV FSTP
                 FSTSW FSUB FSUBP FSUBR FSUBRP FTST FUCOM  FUCOMP  FUCOMPP  FWAIT
                 FXAM FXCH FXTRACT FYL2X FYL2XP1