以下是代码片段：

    /*测试定义*/
    int c1;
    int c2;
    /*测试赋值*/
    c2=(2006/-2);
    int endl()
    {
     cout(10,2);cout(13,2);
    }
    endl();
    cout(c2,1);
    c1    =    3+2006-((2006/-2)*-4)/2;
    endl();
    cout(c1,1);
    /*测试输入*/
    endl();
    cout('c',2);cout('1',2);cout(':',2);
    cin(c1,1);
    endl();
    cout('c',2);cout('2',2);cout(':',2);
    cin(c2,1);
    endl();
    cout(c1,1);
    endl();
    cout(c2,1);

    char f(int a1, int a2)
    {
        /*endl();cout('f',2);*/
        /*下面测试所有比较运算符并测试输出,还测试了if语句*/
        if(a1==a2){endl();cout(a1,1);cout('=',2);cout('=',2);cout(a2,1);}
        if(a1!=a2){endl();cout(a1,1);cout('!',2);cout('=',2);cout(a2,1);}
        if(a1>=a2){endl();cout(a1,1);cout('>',2);cout('=',2);cout(a2,1);}
        if(a1<=a2){endl();cout(a1,1);cout('<',2);cout('=',2);cout(a2,1);}
        if(a1>a2){endl();cout(a1,1);cout('>',2);cout(a2,1);}
        if(a1<a2){endl();cout(a1,1);cout('<',2);cout(a2,1);}

  /*定义一个jk函数,该函数使用while语句来计算输入参数的阶乘*/
        int jk(int a)
        {
         /*endl();cout('j',2);*/
         int b;
         b=1;
         /*C语言的变量定义必须在所有语句之前出现,而我们可以在任意位置*/
         int cc;
         cc=a;
         while(a>0)
         {
          /*一个个乘上小于等于参数a的正整数*/
             b=b*a;
             a=a-1;
         }

         /*
         再定义一个函数,表明在一个函数内部还可以定义函数
         实际上,可以无限层定义函数
         这里,还测试了多行注释
         最重要的是,这里的函数,使用了递归
         成功的区分变量作用域并实现无限函数以及无限函数递归,是我们的编译器的最大特色
         */
         int jkk(int y)
         {
          /*endl();cout('k',2);cout('y',2);cout(y,1);*/
             if(y<2)return 1;
             return jkk(y-1)*y;
         }
         if(jkk(cc)==b)
         /*测试两种方法得到的阶乘结果是否一样*/
         /*测试多个注释符一起出现*/
         /*测试函数应用于复杂表达式中构造算术表达式,并一起参加复杂的混合运算*/
         /*同时,这里也测试了返回语句后面可以是任何算术表达式*/
          return jkk(cc)+2006-((2006/-2)*-4)/2;
         else
          return -1;
        }
        endl();
        cout('!',2);cout(a1,1);cout('=',2);cout(jk(a1),1);
        endl();
        cout('!',2);cout(a2,1);cout('=',2);cout(jk(a2),1);
       
        /*
        再试试函数调用作为独立的语句
        */
        jk(a1);
       
        /*一个特殊的函数,求d1的d2次乘方*/
        int expf(int d1,int d2)
        {
/*         endl();cout('e',2);*/
         int i;
         i=1;
         while(d2>0)
         {
          i=i*d1;
          d2=d2-1;
         }
         return i;
        }
       
        /*
        顶顶大名的<<汉诺塔>>问题
        我们的编译器不仅支持递归,还支持中文编程
       
        <<汉诺塔>>问题
        有一定个数的盘,每个盘大小均不一样,任意小盘必须任何时候都放在大盘上面
        现在所有盘都放在 源盘 这里,请你借助一个 中间盘,把所有源盘移动到 目的盘上面去
        记住:任何时候,任意小盘都必须放在大盘上面
        解决思想:递归
        从 源盘 移动N个盘到目的盘,可以先移动最上面的N-1个到 中间盘
        然后移动 源盘 中最下面也是最大的那个盘到 目的盘
        再把刚才移动到 中间盘 的那N-1个盘移动到目的盘
        这是,移动N-1个盘,又构成了一个N-1的汉诺塔问题
        非常经典的递归
        */
        整型 移动(整型 个数,字符型 源盘,字符型 目的盘,字符型 中间盘)
  {
      如果(个数 小于 2)
      {
       输出(10,2);输出(13,2);
       输出('M',2);输出('o',2);输出('v',2);输出('e',2);输出(':',2);输出(32,2);
       输出(源盘,2);
       输出('-',2);输出('>',2);
       输出(目的盘,2);
       }
      否则
      {
       移动(个数 减 1,源盘,中间盘,目的盘);
       移动(1,源盘,目的盘,中间盘);
       移动(个数 减 1,中间盘,目的盘,源盘);
      }
      /*很遗憾,我们不支持void这个无类型*/
      返回 0;
  }
       
        endl();
        cout(a1,1);cout('!',2);cout(a2,1);cout('=',2);cout(expf(a1,a2),1);
        endl();
        cout(a2,1);cout('!',2);cout(a1,1);cout('=',2);cout(expf(a2,a1),1);
  /*我们的NewC语言,不管你什么时候换行,当然,就算都不换行,也同样可以识别
  这个行号对编译器没有任何意义,仅仅用于错误的提示而已*/
        if
        (expf(a1,a2)>=expf(a2,a1))
        {
         if(expf(a1,a2)>expf(a2,a1))
         return '>';/*返回expf(a1,a2)=expf(a2,a1)*/
         else
         return '=';
        }
        else return '<';
    }
    char ch1;
    endl();
    /*c1的c2次乘方,和 c2的c1次乘方 比较*/
    ch1=f(c1,c2);
    endl();
    cout(ch1,2);
    endl();
    cin(c1,2);  
    /*
    再试试函数调用作为独立的语句*/
 移动(c2,'A','B','C');
    endl();
    cout('E',2);cout('N',2);cout('D',2);
    ch1='#';
    cin(c1,2);