void generador (int target) {   
 
  // "target" es la longitud total buscada; si target==0 queda librado al azar
  // elige una estructura B-T, lo que a su vez determina el número de grupettos (2-6)  
  // primero que nada elige un "tipo" de estructura: 2, 3, 2+2, 4, 2+3, 3+2, 3+3, 2+4, 4+2
  // hay 9 tipos de estructura B-T
    
  
  float curvature;
  if (target == 0) {curvature = .8;} else {curvature = 1;}
  
  do {
    int tipo_estruc = 1 + log_random (9, curvature);            // favorece estructuras largas 
    switch (tipo_estruc) {
      case 1: case 3: case 5: case 8: 
        num_grupet = 2; 
        estruct = est_2; 
        break;
      case 2: case 6: case 7: 
        num_grupet = 3;
        i = int (random (4)); estruct = est_3 [i]; 
        break;
      case 4: case 9:
        num_grupet = 4;
        i = int (random (3)); estruct = est_4 [i]; 
        break;
    }    
    switch (tipo_estruc) {
      case 3: case 6: case 9: 
        num_grupet += 2;
        estruct = estruct + est_2; 
        break;
      case 5: case 7: 
        num_grupet += 3;
        i = int (random (4)); estruct = estruct + est_3 [i]; 
        break;
      case 8:
        num_grupet += 4;
        i = int (random (3)); estruct = estruct  + est_4 [i]; 
        break;
    }
  } while ((num_grupet < (target+3)/4 || num_grupet > target/2) && target != 0);
  
  // num_gupet = estruct.length()
  
  // define la longitud de cada grupetto, lo que a su vez determina la longitud total
  // esto es importante para controlar la "regularidad" de los ritmos, por ejemplo: 
  // binarios: 4, 8, 16; ternarios: 6, 9, 12, 18, 24; pentarios: 5, 10, 15, 20; heptarios: 7, 14, 21; amorfos: 11, 13, 17, 19, 22, 23 
  
  grupetto = new int [num_grupet];
  int long_total;
  
  do {
    long_total = 0; 
    for (f = 0; f < num_grupet; f++) {
      grupetto[f] = 2 + log_random (3, curvature);     // favorece grupettos largos
      long_total += grupetto [f]; 
    }
  } while (long_total != target && target != 0);
  
  switch (long_total) {                                                 // analiza la regularidad y setea un modulo posible
    case 4: case 8: case 16: unidad = 8; break;                         // luego elige de posibles patterns para los platos y se desvia controladamente
    case 6: case 9: case 12: case 18: case 24: unidad = 6; break;
    case 5: case 10: case 15: case 20: unidad = 5; break;
    case 7: case 14: case 21: unidad = 7; break;
    default: unidad = int (random (2, 9)); break;                       // hubo cambios aca
  }
  
}