var getIx = function(x, ix, mx) {
  if (ix > x.length) {
      x = [];
      return null;
  }
  if (ix == x.length) {
      c.push(0);
      return 0;
  }
  var r = x[ix];
  if (r >= mx) {
      if (ix + 1 >= x.length) {
          x = [];
          return null;
      }
      for (var i = 0; i <= ix; i++) {
          x[ix] = 0;
      }
      x[ix + 1]++;
  }
  return r;
}

ZrfMove.prototype.determinate = function() {
  var r = [];
  for (var x = [0]; x.length > 0; x[0]++) {
      var m = Model.Game.createMove();
      var ix = 0;
      for (var i in this.actions) {
           var k = 0;
           var fp = this.actions[i][0];
           if (fp !== null) {
               k = getIx(x, ix++, fp.length);
               if (k === null) {
                   break;
               }
               fp = [ fp[k] ];
           }
           var tp = this.actions[i][1];
           if (tp !== null) {
               k = getIx(x, ix++, tp.length);
               if (k === null) {
                   break;
               }
               tp = [ tp[k] ];
           }
           var pc = this.actions[i][2];
           if (pc !== null) {
               k = getIx(x, ix++, pc.length);
               if (k === null) {
                   break;
               }
               pc = [ pc[k] ];
           }
           var pn = this.actions[i][3];
           m.actions.push([fp, tp, pc, pn]);
      }
      r.push(m);      
  }
  return r;
}

ZrfMove.prototype.getControlList = function() {
  return _.chain(this.actions)
   .map(function (action) {
        return _.chain(_.range(3))
         .map(function (ix) {
              if (action[ix] === null) {
                  return 0;
              } else {
                  return action[ix].length;
              }
          })
         .filter(function (n) { return n > 1; })
         .value();
    })
   .flatten()
   .map(function (n) { return _.range(n); })
   .cartesian()
   .value();
}

ZrfMove.prototype.determinate = function() {
  var c = this.getControlList();
  if (c.length > 1) {
      return _.chain(c)
       .map(function (l) {
           var r = new ZrfMove();
           var pos = 0;
           _.each(this.actions, function (action) {
              var x = [];
              _.each(_.range(3), function (ix) {
                 pos = pushItem(this, action[ix], l, pos);
              }, x);
              x.push(action[3]);
              if (isValidAction(x)) {
                  this.actions.push(x);
              }
           }, r);
           return r;
        }, this)
       .filter(isValidMove)
       .value();
  } else {
      return [ this ];
  }
}

var m = [ [ [0], [1, 2] ], [ [3, 4, 5], null ] ]; // Незначимые элементы опущены

m = _.map(m, function(action) {
        return _.chain(_.range(2))
         .map(function (ix) {
              if (action[ix] === null) {
                  return 0;
              } else {
                  return action[ix].length;
              }
          })
         .filter(function (n) { return n > 1; })
         .value();
});

m == [ [2], [3] ] // Только "недетерминированные" позиции

m == [ [0, 1], [0, 1, 2] ]

var cartesian = function(r, prefix, arr) {
   if (arr.length > 0) {
       _.each(_.first(arr), function (n) {
          var x = _.clone(prefix);
          x.push(n);
          cartesian(r, x, _.rest(arr));
       });
   } else {
       r.push(prefix);
   }
}

_.mixin({
  cartesian: function(x) {
     var r = [];
     cartesian(r, [], x);
     return r;
  }
});

      _.chain(m)
       .map(function(action) {
        return _.chain(_.range(2))
         .map(function (ix) {
              if (action[ix] === null) {
                  return 0;
              } else {
                  return action[ix].length;
              }
          })
         .filter(function (n) { return n > 1; })
         .value();
        })
       .flatten()
       .map(function (n) { return _.range(n); })
       .cartesian()
       .value();

[ [0, 0],  [0, 1], [0, 2], [1, 0], [1, 1], [1, 2] ]

Model.Game.PostActions = function(board) {
  PostActions(board);
  if (mode !== 0) {
      var moves = [];
      var mx = 0;
      var mk = 0;
      for (var i in board.moves) {
           var vl = 0;
           var kv = 0;
           for (var j in board.moves[i].actions) {
                var fp = board.moves[i].actions[j][0];
                var tp = board.moves[i].actions[j][1];
                if (tp === null) {
                    var piece = board.getPiece(fp[0]);
                    if (piece !== null) {
                        if (piece.type > 0) {
                            kv++;
                        }
                        vl++;
                    }
                }
           }
           if (vl > mx) {
               mx = vl;
           }
           if (kv > mk) {
               mk = kv;
           }
      }
      for (var i in board.moves) {
           var vl = 0;
           var kv = 0;
           for (var j in board.moves[i].actions) {
                var fp = board.moves[i].actions[j][0];
                var tp = board.moves[i].actions[j][1];
                if (tp === null) {
                    var piece = board.getPiece(fp[0]);
                    if (piece !== null) {
                        if (piece.type > 0) {
                            kv++;
                        }
                        vl++;
                    }
                }
           }
           if ((mode === 2) && (mk > 0)) {
               if (kv == mk) {
                   moves.push(board.moves[i]);
               }
           } else {
               if (vl == mx) {
                   moves.push(board.moves[i]);
               }
           }
      }
      board.moves = moves;
  }
}

Model.Game.PostActions = function(board) {
  PostActions(board);
  var captures = function(move) {
    return _.chain(move.actions)
     .filter(function(action) {
         return (action[0] !== null) && (action[1] === null);
      })
     .map(function(action) {
         return board.getPiece(action[0]);
      })
     .compact()
     .map(function(piece) {
         return piece.type;
      })
     .countBy(function(type) {
         return (type === 0) ? "Mans" : "Kings";
      })
     .defaults({ Mans: 0, Kings: 0 })
     .value();
  };
  if (mode !== 0) {
      var caps = _.map(board.moves, captures);
      var all = _.chain(caps)
       .map(function(captured) {
          return captured.Mans + captured.Kings;
        })
       .max()
       .value();
      var kings = _.chain(caps)
       .map(function(captured) {
          return captured.Kings;
        })
       .max()
       .value();
      board.moves = _.chain(board.moves)
       .filter(function(move) {
           var c = captures(move);
           if ((mode === 2) && (kings > 0)) {
               return c.Kings >= kings;
           } else {
               return c.Mans + c.Kings >= all;
           }
        })
       .value();
  }
}