public SyncCommand(int nCode, String strParam, int nCmdParam, boolean bShowStatus)
	        {
		        m_nCmdCode = nCode;
		        m_strCmdParam = strParam;
                m_nCmdParam = nCmdParam;
                m_bShowStatus = bShowStatus;
	        }

          public SyncCommand(int nCode, boolean bShowStatus, String query_params)
 		    {
 			    m_nCmdCode = nCode;
 			    m_nCmdParam = 0;
 			    m_bShowStatus = bShowStatus;
              m_strQueryParams = query_params != null ? query_params : "";
 		    }

     public SyncNotification(String strUrl, String strParams, boolean bRemoveAfterFire)
     {
         if ( strUrl.length() > 0 )
             m_strUrl = RHODESAPP().canonicalizeRhoUrl(strUrl);
 	
 	    m_strParams = strParams; 
 	    m_bRemoveAfterFire = bRemoveAfterFire; 
     }

 //Helper Method to check if a row, column or section is valid
 private boolean validHelper(char[][] board, int sRow, int eRow, int sCol, int eCol){
     boolean[] used = new boolean[10];
     for(int i=sRow; i<=eRow;i++){
         for(int j=sCol;j<=eCol;j++){
             if(board[i][j]=='.')  //if the cell is empty
                 continue;
             if(used[board[i][j]-'0'])  //if the number already used, not valid
                 return false;
             used[board[i][j]-'0']=true; //if the number is not used, set it as used
         }
     }
     return true;
 }

	public IDBResult executeSQL(String strStatement, Object[] values, boolean bNoCopy)
    {
		LOG.TRACE("executeSQL: " + strStatement + ";" + values);
		IDBResult res = null;
		Lock();
		try{
            res = m_dbStorage.executeSQL(strStatement, values, false, bNoCopy);
		}finally
		{
			Unlock();
		}
		return res;
	}

        public static int JoyInit() {
            if ( s_initialized ) {
                JoyReset();
            }
            s_initialized = true;
            int num_joydev = (int)win32.joyGetNumDevs();
#if DEBUG
            cadencii.debug.push_log( "winmmhelp.JoyInit" );
            cadencii.debug.push_log( "    num_joydev=" + num_joydev );
#endif
            if ( num_joydev <= 0 ) {
                num_joydev = 0;
                return num_joydev;
            }
            s_joy_attatched = new boolean[num_joydev];
            s_joycaps = new JOYCAPSW[num_joydev];
            int count = 0;
            for ( int k = 0; k < num_joydev; k++ ) {
                JOYINFO ji = new JOYINFO();
                if ( win32.joyGetPos( (uint)k, ref ji ) == win32.JOYERR_NOERROR ) {
                    s_joy_attatched[k] = true;
                    JOYCAPSW jc = new JOYCAPSW();
                    win32.joyGetDevCapsW( (uint)k, ref jc, (uint)Marshal.SizeOf( jc ) );
                    s_joycaps[k] = jc;
                    count++;
                } else {
                    s_joy_attatched[k] = false;
                }
            }
            if ( count > 0 ) {
                s_joy_available = new int[count];
                int c = -1;
                for ( int i = 0; i < num_joydev; i++ ) {
                    if ( s_joy_attatched[i] ) {
                        c++;
                        if ( c >= count ) {
                            break; //ここに来るのはエラー
                        }
                        s_joy_available[c] = i;
                    }
                }
            }
            s_num_joydev = (uint)count;
            return (int)s_num_joydev;
        }

        public Rorschach(String [] args)
        {
            base (args, true, true, true, 16, 2000);

            depth = option.intt ("depth", "level of details", 10000);
            draw_delay = option.longg ("draw-delay",
              "delay between iterations in millis", 10);
            offset = option.intt ("offset", "compactness of pattern", 4);
            int step_count = option.intt ("step-count",
              "total number of steps", 50);
            x_symmetry = option.booleann ("x-symmetry",
              "if symmetry along x-axis", true);
            y_symmetry = option.booleann ("y-symmetry",
              "if symmetry along y-axis", false);

            about ("0.1", "simulate ink-blot patterns",
              "Stephen Tse <[email protected]>",
              "http://escher.sourceforge.net/");

            if (help_option) return;

            step_size = depth / step_count;
        }

        public Munch(String [] args)
        {
            base (args, true, true, false, 16, 2000);

            draw_delay = option.longg ("draw-delay",
              "delay between iterations in millis", 10);
            min_size = option.intt ("min-size",
              "minimum size of square", 64);
            shift = option.booleann ("shift",
              "shift factor = munch in random order", true);
            square_count = option.intt ("square-count",
              "total number of squares", 5);
            xor = option.booleann ("xor",
              "use xor function to draw", true);

            about ("0.1", "munching squares",
              "Stephen Tse <[email protected]>",
              "http://escher.sourceforge.net/");

            if (help_option) return;

            // TODO alpha composite (from RENDER/GLX) instead of xor?
            if (xor) gc.set_function (gnu.x11.GC.Values.XOR);
        }

 void statements(boolean cond, int x)
 {
     reg(new ISink() {

 public game()
 {
     this.scriptVersionField = "0.0.0.0";
     this.usetwosidedtableField = boolean.True;
     this.noteBackgroundColorField = "#FFEBE8C5";
     this.noteForegroundColorField = "#FF000000";
 }

 public counter()
 {
     this.defaultField = "0";
     this.resetField = boolean.True;
 }

 public propertyDef()
 {
     this.ignoreTextField = boolean.False;
     this.textKindField = propertyDefTextKind.Free;
     this.hiddenField = "False";
 }

 public group()
 {
     this.orderedField = boolean.True;
     this.movetoField = boolean.True;
     this.collapsedField = boolean.False;
 }

 public gameVariable()
 {
     this.defaultField = "0";
     this.resetField = boolean.True;
     this.globalField = boolean.True;
 }

 public action()
 {
     this.defaultField = boolean.False;
 }

 /** 
  * Load class file data into namespace of this class loader.
  *
  * @param name fully-qualified class name
  * @param data raw bytes of class file
  */
 public Class load (String name, byte [] data, boolean resolve) {
   Class klass = defineClass (name, data, 0, data.Length);
   if (resolve) resolveClass (klass);
   classes.put (name, klass);
   return klass;
 }

 public void setNonThreadedMode(boolean b){m_bNoThreaded = b;}

 public void ASSERT(boolean exp, String message)
 {
     if (!exp)
         logMessage(L_FATAL, message);
 }

 /// <summary>
 /// 使用中のリソースをすべてクリーンアップします。
 /// </summary>
 /// <param name="disposing">マネージ リソースが破棄される場合 true、破棄されない場合は false です。</param>
 protected override void Dispose( boolean disposing )
 {
     if ( disposing && (components != null) ) {
         components.Dispose();
     }
     base.Dispose( disposing );
 }

 public void setAlwaysOnTop( boolean alwaysOnTop ) {
     base.TopMost = alwaysOnTop;
 }